/*
|
* Licensed to the Apache Software Foundation (ASF) Under one or more
|
* contributor license agreements. See the NOTICE file distributed with
|
* this work for Additional information regarding copyright ownership.
|
* The ASF licenses this file to You Under the Apache License, Version 2.0
|
* (the "License"); you may not use this file except in compliance with
|
* the License. You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed Under the License is distributed on an "AS Is" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations Under the License.
|
*/
|
/*
|
* Created on May 14, 2005
|
*
|
*/
|
namespace HH.WMS.Utils.NPOI.SS.Formula.Eval
|
{
|
using System;
|
/**
|
* @author Amol S. Deshmukh < amolweb at ya hoo dot com >
|
*
|
*/
|
public class ValueEvalToNumericXlator
|
{
|
|
public static int STRING_IS_PARSED = 0x0001;
|
public static int BOOL_IS_PARSED = 0x0002;
|
public static int BLANK_IS_PARSED = 0x0004; // => blanks are not ignored, Converted to 0
|
|
public static int REF_STRING_IS_PARSED = 0x0008;
|
public static int REF_BOOL_IS_PARSED = 0x0010;
|
public static int REF_BLANK_IS_PARSED = 0x0020;
|
|
public static int STRING_IS_INVALID_VALUE = 0x0800;
|
|
private int flags;
|
|
|
public ValueEvalToNumericXlator(int flags)
|
{
|
this.flags = flags;
|
}
|
|
/**
|
* returned value can be either A NumericValueEval, BlankEval or ErrorEval.
|
* The params can be either NumberEval, BoolEval, StringEval, or
|
* RefEval
|
* @param eval
|
*/
|
public ValueEval AttemptXlateToNumeric(ValueEval eval)
|
{
|
ValueEval retval = null;
|
|
if (eval == null)
|
{
|
retval = BlankEval.instance;
|
}
|
|
// most common case - least worries :)
|
else if (eval is NumberEval)
|
{
|
retval = eval;
|
}
|
|
// booleval
|
else if (eval is BoolEval)
|
{
|
retval = ((flags & BOOL_IS_PARSED) > 0)
|
? (NumericValueEval)eval
|
: XlateBlankEval(BLANK_IS_PARSED);
|
}
|
|
// stringeval
|
else if (eval is StringEval)
|
{
|
retval = XlateStringEval((StringEval)eval); // TODO: recursive call needed
|
}
|
|
// refeval
|
else if (eval is RefEval)
|
{
|
retval = XlateRefEval((RefEval)eval);
|
}
|
|
// erroreval
|
else if (eval is ErrorEval)
|
{
|
retval = eval;
|
}
|
|
else if (eval is BlankEval)
|
{
|
retval = XlateBlankEval(BLANK_IS_PARSED);
|
}
|
|
// probably AreaEval? then not acceptable.
|
else
|
{
|
throw new Exception("Invalid ValueEval type passed for conversion: " + eval.GetType());
|
}
|
|
return retval;
|
}
|
|
/**
|
* no args are required since BlankEval has only one
|
* instance. If flag is Set, a zero
|
* valued numbereval is returned, else BlankEval.INSTANCE
|
* is returned.
|
*/
|
private ValueEval XlateBlankEval(int flag)
|
{
|
return ((flags & flag) > 0)
|
? (ValueEval)NumberEval.ZERO
|
: BlankEval.instance;
|
}
|
|
/**
|
* uses the relevant flags to decode the supplied RefVal
|
* @param eval
|
*/
|
private ValueEval XlateRefEval(RefEval reval)
|
{
|
ValueEval eval = reval.InnerValueEval;
|
|
// most common case - least worries :)
|
if (eval is NumberEval)
|
{
|
return eval;
|
}
|
|
if (eval is BoolEval)
|
{
|
return ((flags & REF_BOOL_IS_PARSED) > 0)
|
? (ValueEval)eval
|
: BlankEval.instance;
|
}
|
|
if (eval is StringEval)
|
{
|
return XlateRefStringEval((StringEval)eval);
|
}
|
|
if (eval is ErrorEval)
|
{
|
return eval;
|
}
|
|
if (eval is BlankEval)
|
{
|
return XlateBlankEval(REF_BLANK_IS_PARSED);
|
}
|
|
throw new Exception("Invalid ValueEval type passed for conversion: ("
|
+ eval.GetType().Name + ")");
|
}
|
|
/**
|
* uses the relevant flags to decode the StringEval
|
* @param eval
|
*/
|
private ValueEval XlateStringEval(StringEval eval)
|
{
|
|
if ((flags & STRING_IS_PARSED) > 0)
|
{
|
String s = eval.StringValue;
|
double d = OperandResolver.ParseDouble(s);
|
if (double.IsNaN(d))
|
{
|
return ErrorEval.VALUE_INVALID;
|
}
|
return new NumberEval(d);
|
}
|
// strings are errors?
|
if ((flags & STRING_IS_INVALID_VALUE) > 0)
|
{
|
return ErrorEval.VALUE_INVALID;
|
}
|
|
// ignore strings
|
return XlateBlankEval(BLANK_IS_PARSED);
|
}
|
|
/**
|
* uses the relevant flags to decode the StringEval
|
* @param eval
|
*/
|
private ValueEval XlateRefStringEval(StringEval sve)
|
{
|
if ((flags & REF_STRING_IS_PARSED) > 0)
|
{
|
String s = sve.StringValue;
|
double d = OperandResolver.ParseDouble(s);
|
if (double.IsNaN(d))
|
{
|
return ErrorEval.VALUE_INVALID;
|
}
|
return new NumberEval(d);
|
}
|
// strings are blanks
|
return BlankEval.instance;
|
}
|
}
|
}
|
