/// <summary>
/// Provides the graph of this function if it has been statically defined
/// </summary>
/// <param name="context">the context used to create the graph</param>
/// <param name="parameter"></param>
/// <param name="explain"></param>
/// <returns></returns>
public override Graph CreateGraph(InterpretationContext context, Parameter parameter, ExplanationPart explain)
{
Graph retVal = null;
Graph graph = createGraphForValue(context, context.FindOnStack(Function).Value, explain, parameter);
if (graph != null)
{
double speed = GetDoubleValue(context.FindOnStack(Speed).Value);
double solutionX = graph.SolutionX(speed);
if (solutionX == double.MaxValue)
{
// No value found, return Unknown
Range distanceType = (Range)EFSSystem.FindByFullName("Default.BaseTypes.Distance");
EnumValue unknownDistance = distanceType.findEnumValue("Unknown");
retVal = Graph.createGraph(distanceType.getValueAsDouble(unknownDistance));
}
else
{
// Create the graph for this solution
retVal = Graph.createGraph(solutionX);
}
}
else
{
Function.AddError("Cannot create graph for " + Function);
}
return(retVal);
}
/// <summary>
/// Provides the special values based on the special_or_reserved_values information
/// </summary>
/// <param name="special_or_reserved_values"></param>
/// <returns></returns>
private List <DataDictionary.Constants.EnumValue> getSpecialValues(SpecialOrReservedValue[] special_or_reserved_values)
{
List <DataDictionary.Constants.EnumValue> retVal = new List <DataDictionary.Constants.EnumValue>();
if (special_or_reserved_values != null)
{
foreach (SpecialOrReservedValue value in special_or_reserved_values)
{
if (value.match is MatchRange)
{
// Skip
}
else
{
DataDictionary.Constants.EnumValue enumValue = (DataDictionary.Constants.EnumValue)DataDictionary.Generated.acceptor.getFactory().createEnumValue();
if (value.match is string)
{
enumValue.Name = FormatIdentifier(value.meaning.value);
enumValue.setValue((string)value.match);
}
OrderedInsert(enumValue, retVal);
}
}
}
return(retVal);
}
/// <summary>
/// Provides the enum value which corresponds to the name provided
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public EnumValue findEnumValue(string name)
{
EnumValue retVal = null;
retVal = (EnumValue)NamableUtils.FindByName(name, SpecialValues);
return(retVal);
}
public void AddValue(DataDictionary.Constants.EnumValue value)
{
value.Name = "<EnumValue" + (GetNodeCount(false) + 1) + ">";
value.setValue("");
Item.appendValues(value);
Nodes.Add(new EnumerationValueTreeNode(value));
SortSubNodes();
}
/// <summary>
/// Appends an enum value to the enum provided
/// </summary>
/// <param name="enclosing"></param>
/// <param name="name"></param>
/// <returns></returns>
protected EnumValue CreateEnumValue(Enum enclosing, string name)
{
EnumValue retVal = (EnumValue)Factory.createEnumValue();
enclosing.appendValues(retVal);
retVal.Name = name;
return(retVal);
}
/// <summary>
/// Provides the enum value which corresponds to the name provided
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public EnumValue FindEnumValue(string name)
{
EnumValue retVal = (EnumValue)NamableUtils.FindByName(name, Values);
if (retVal == null && EnclosingEnum != null)
{
retVal = EnclosingEnum.FindEnumValue(name);
}
return(retVal);
}
/// <summary>
/// Adds a model element in this model element
/// </summary>
/// <param name="copy"></param>
public override void AddModelElement(IModelElement element)
{
{
EnumValue item = element as EnumValue;
if (item != null)
{
appendSpecialValues(item);
}
}
base.AddModelElement(element);
}
/// <summary>
/// Converts a value in this type
/// </summary>
/// <param name="value">The value to convert</param>
/// <returns></returns>
public override IValue convert(IValue value)
{
IValue retVal = null;
EnumValue enumValue = value as EnumValue;
if (enumValue != null && enumValue.Range != null)
{
retVal = findEnumValue(enumValue.Name);
if (retVal == null)
{
AddError("Cannot convert " + enumValue.Name + " to " + FullName);
}
}
else
{
try
{
switch (getPrecision())
{
case acceptor.PrecisionEnum.aIntegerPrecision:
{
Decimal val = getValueAsInt(value);
Decimal min = MinValueAsLong;
Decimal max = MaxValueAsLong;
if (val >= min && val <= max)
{
retVal = new IntValue(this, val);
}
}
break;
case acceptor.PrecisionEnum.aDoublePrecision:
{
double val = getValueAsDouble(value);
double min = MinValueAsDouble;
double max = MaxValueAsDouble;
if (val >= min && val <= max)
{
retVal = new DoubleValue(this, val);
}
break;
}
}
}
catch (Exception exception)
{
AddException(exception);
}
}
return(retVal);
}
/// <summary>
/// Converts a value into a string
/// </summary>
/// <param name="obj"></param>
/// <param name="displayActualDefaultValue">
/// Indicates that the actual default value should be displayed instead of
/// "<default>"
/// </param>
/// <returns></returns>
private static string ValueStringonizer(object obj, bool displayActualDefaultValue)
{
string retVal;
IValue value = DerefVariable(obj);
StructureValue structureValue = value as StructureValue;
ListValue listValue = value as ListValue;
if (structureValue != null)
{
retVal = "";
}
else if (listValue != null)
{
retVal = "";
}
else
{
if (displayActualDefaultValue)
{
// Dereference enumeration constants to get the actual value
EnumValue enumValue = value as EnumValue;
while (enumValue != null)
{
value = enumValue.Value;
if (value != enumValue.Value)
{
enumValue = value as EnumValue;
}
else
{
enumValue = null;
}
}
retVal = value.Name;
}
else
{
if (IsDefaultValue(value))
{
retVal = DefaultConst;
}
else
{
retVal = value.Name;
}
}
}
return(retVal);
}
/// <summary>
/// Derefs enumerate values
/// </summary>
/// <param name="val"></param>
/// <returns></returns>
private IValue derefEnum(IValue val)
{
IValue retVal = val;
EnumValue enumValue = retVal as EnumValue;
if (enumValue != null)
{
retVal = enumValue.Value;
}
return(retVal);
}
/// <summary>
/// Inserts the enum value using the correct order (by value)
/// </summary>
/// <param name="enumValue"></param>
/// <param name="values"></param>
private void OrderedInsert(DataDictionary.Constants.EnumValue enumValue, List <DataDictionary.Constants.EnumValue> values)
{
int i = 0;
foreach (DataDictionary.Constants.EnumValue val in values)
{
long v1 = long.Parse(val.getValue());
long v2 = long.Parse(enumValue.getValue());
if (v1 > v2)
{
break;
}
i = i + 1;
}
values.Insert(i, enumValue);
}
/// <summary>
/// Ensures that the length of the section is consistent with EFS's length scale
/// </summary>
/// <param name="length"></param>
/// <returns></returns>
private IValue SegmentLength(double length)
{
IValue retVal = new DoubleValue(EFSSystem.DoubleType, length);
NameSpace defaultNameSpace = OverallNameSpaceFinder.INSTANCE.findByName(EFSSystem.Dictionaries[0],
"Default.BaseTypes");
Range LengthType = defaultNameSpace.findTypeByName("Length") as Range;
EnumValue infinity = LengthType.findEnumValue("Infinity");
if (!LengthType.Less(retVal, infinity))
{
retVal = infinity;
}
return(retVal);
}
/// <summary>
/// Provides the double value from the IValue provided
/// </summary>
/// <param name="val"></param>
/// <returns></returns>
private double getValue(IValue val)
{
double retVal = 0;
EnumValue enumValue = val as EnumValue;
if (enumValue != null)
{
val = enumValue.Value;
}
DoubleValue vd = val as DoubleValue;
if (vd != null)
{
retVal = vd.Val;
}
else
{
IntValue vi = val as IntValue;
if (vi != null)
{
retVal = (double)vi.Val;
}
else
{
Function function = val as Function;
if (function != null)
{
Graph graph = function.Graph;
if (graph != null)
{
if (graph.Segments.Count == 1)
{
retVal = graph.Evaluate(0);
}
}
}
}
}
return(retVal);
}
/// <summary>
/// Performs the dereferencing and launches an exception if the enum cannot be used for arithmetic operations
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
private static IValue derefEnumForArithmeticOperation(IValue value)
{
IValue retVal = value;
EnumValue enumValue = value as EnumValue;
if (enumValue != null)
{
if (enumValue.getForbidArithmeticOperation())
{
throw new Exception("Cannot perform arithmetic operation with " + value.LiteralName);
}
else
{
retVal = enumValue.Value;
}
}
return(retVal);
}
/// <summary>
/// Handles setting all the update information for this element (this updates source)
/// </summary>
/// <param name="source"></param>
public override void SetUpdateInformation(ModelElement source)
{
base.SetUpdateInformation(source);
Enum sourceEnum = source as Enum;
if (sourceEnum != null)
{
Requirements.Clear();
setUpdates(source.Guid);
foreach (EnumValue value in Values)
{
EnumValue matchingValue = sourceEnum.FindEnumValue(value.Name);
value.setUpdates(matchingValue.Guid);
}
foreach (Enum subEnum in SubEnums)
{
Enum matchingEnum = sourceEnum.FindSubEnum(subEnum.Name);
subEnum.SetUpdateInformation(matchingEnum);
}
}
}
/// <summary>
/// Provides the int value from the IValue provided
/// </summary>
/// <param name="val"></param>
/// <returns></returns>
private int getValue(IValue val)
{
int retVal = 0;
EnumValue enumValue = val as EnumValue;
if (enumValue != null)
{
val = enumValue.Value;
}
IntValue vi = val as IntValue;
if (vi != null)
{
retVal = (int)vi.Val;
}
else
{
throw new Exception("Cannot get integer value from " + val.LiteralName);
}
return(retVal);
}
public virtual void AddSpecialValueHandler(object sender, EventArgs e)
{
Item.appendSpecialValues(EnumValue.CreateDefault(Item.SpecialValues));
}
/// <summary>
/// Adds a new special value to this range
/// </summary>
/// <param name="value"></param>
public void AppendSpecialValue(DataDictionary.Constants.EnumValue value)
{
Item.appendSpecialValues(value);
Nodes.Add(new EnumerationValueTreeNode(value));
SortSubNodes();
}
public override void AddSpecialValueHandler(object sender, EventArgs e)
{
DataDictionary.Constants.EnumValue value = (DataDictionary.Constants.EnumValue)DataDictionary.Generated.acceptor.getFactory().createEnumValue();
value.Name = "<unnamed>";
AppendSpecialValue(value);
}
public void AddValueHandler(object sender, EventArgs args)
{
DataDictionary.Constants.EnumValue value = (DataDictionary.Constants.EnumValue)DataDictionary.Generated.acceptor.getFactory().createEnumValue();
valuesTreeNode.AddValue(value);
}
/// <summary>
/// Converts a DataDictionary.Values.IValue into an EFSIPCInterface.Value
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public Value ConvertOut(IValue value)
{
// Handles the boolean case
{
BoolValue v = value as BoolValue;
if (v != null)
{
return(new Values.BoolValue(v.Val));
}
}
// Handles the integer case
{
IntValue v = value as IntValue;
if (v != null)
{
return(new Values.IntValue(v.Val));
}
}
// Handles the double case
{
DoubleValue v = value as DoubleValue;
if (v != null)
{
return(new Values.DoubleValue(v.Val));
}
}
// Handles the string case
{
StringValue v = value as StringValue;
if (v != null)
{
return(new Values.StringValue(v.Val));
}
}
// Handles the state case
{
State v = value as State;
if (v != null)
{
return(new StateValue(v.FullName));
}
}
// Handles the enumeration value case
{
EnumValue v = value as EnumValue;
if (v != null)
{
return(new Values.EnumValue(v.FullName));
}
}
// Handles the list case
{
ListValue v = value as ListValue;
if (v != null)
{
List <Value> list = new List <Value>();
foreach (IValue item in v.Val)
{
list.Add(ConvertOut(item));
}
return(new Values.ListValue(list));
}
}
// Handles the structure case
{
StructureValue v = value as StructureValue;
if (v != null)
{
Dictionary <string, Value> record = new Dictionary <string, Value>();
foreach (KeyValuePair <string, INamable> pair in v.Val)
{
IVariable variable = pair.Value as IVariable;
if (variable != null)
{
record.Add(variable.Name, ConvertOut(variable.Value));
}
}
return(new Values.StructureValue(record));
}
}
// Handles the function case
{
DataDictionary.Functions.Function v = value as DataDictionary.Functions.Function;
if (v != null)
{
List <Segment> segments = new List <Segment>();
if (v.FormalParameters.Count == 1)
{
Graph graph = v.CreateGraph(new InterpretationContext(), (Parameter)v.FormalParameters[0], null);
if (graph != null)
{
foreach (Graph.Segment segment in graph.Segments)
{
double length = segment.End - segment.Start;
segments.Add(new Segment
{
A = segment.Expression.A,
V0 = segment.Expression.V0,
D0 = segment.Start,
Length = length
});
}
}
}
return(new FunctionValue(segments));
}
}
// Handles the 'empty' value
{
EmptyValue emptyValue = value as EmptyValue;
if (emptyValue != null)
{
return(null);
}
}
throw new FaultException <EFSServiceFault>(new EFSServiceFault("Cannot convert value " + value));
}
