//=========================================================================
/// <summary>
/// Find the init property item in the array.
/// </summary>
/// <param name="initName">Name of the init array.</param>
/// <param name="idx">Array item index.</param>
/// <returns>The typed value found at the index.</returns>
//=========================================================================
private TTypedValue findElementRead(string initName, int idx)
{
TTypedValue aValue = null;
TTypedValue result;
readValue(initName, ref aValue);
if (aValue == null)
{
result = null;
}
else
{
if (!aValue.isArray())
{
throw (new TypeMisMatchException("Attempt to read array from non-array value " + initName));
}
if ((idx < 1) || (idx > aValue.count()))
{
throw (new ArrayIndexException("Attempt to read out of range of array value " + initName));
}
result = aValue.item((uint)idx);
}
return(result);
}
//=======================================================================
private void addTreeModelNode(TreeNode parentNode, String name, TTypedValue typedValue)
{
uint i = 1;
uint j = 1;
parentNode.Name = name;
parentNode.Text = name;
parentNode.Tag = new TAFTreeViewColumnTag(typedValue);
if ((typedValue.isArray()) || (typedValue.isRecord()))
{
uint iCount = typedValue.count();
while (i <= iCount)
{
TTypedValue typedValueChild = typedValue.item(i);
if (typedValueChild != null)
{
TreeNode trNode2 = new TreeNode();
parentNode.Nodes.Add(trNode2);
string sVarName = j.ToString();
if (typedValue.isArray())
{
sVarName = "[" + sVarName + "]";
}
j++;
if (typedValueChild.Name.Length > 0)
{
sVarName = typedValueChild.Name;
}
addTreeModelNode(trNode2, sVarName, typedValueChild);
}
i++;
}
}
}
//=========================================================================
/// <summary>
/// Writes the srcValue to destValue.
/// </summary>
/// <param name="srcValue">The source value.</param>
/// <param name="destValue">The destination item.</param>
//=========================================================================
private void writeData(TTypedValue srcValue, TTypedValue destValue)
{
uint Idx;
if (destValue.isScalar())
{
if (srcValue != null)
{
destValue.setValue(srcValue);
}
else if ((destValue.baseType() >= TTypedValue.TBaseType.ITYPE_INT1) && (destValue.baseType() <= TTypedValue.TBaseType.ITYPE_DOUBLE))
{
destValue.setValue(0);
}
else
{
destValue.setValue("");
}
}
else if (destValue.isArray())
{
if (srcValue == null)
{
destValue.setElementCount(0);
}
else
{
destValue.setElementCount(srcValue.count());
for (Idx = 1; Idx <= srcValue.count(); Idx++)
{
writeData(srcValue.item(Idx), destValue.item(Idx));
}
}
}
else // record
{
for (Idx = 1; Idx <= destValue.count(); Idx++)
{
writeData(srcValue.member(destValue.item(Idx).Name), destValue.item(Idx));
}
}
}
//============================================================================
/// <summary>
/// Formats the xml text for the 'field' or 'element' description of the typed
/// value stored as a TPropertyInfo or TDriverInfo.
/// </summary>
/// <param name="attrInfo">The TypedValue attribute.</param>
/// <param name="indent">Indentation in chars.</param>
/// <param name="tab">Number of spaces in each tab</param>
/// <returns>XML text for the field</returns>
//============================================================================
protected override String writeFieldInfo(TTypedValue attrInfo, int indent, int tab)
{
uint i;
uint iFirst;
int oneIndent;
int nextIndent;
int startIndent;
String CR = "";
//determine how much to indent this description
oneIndent = 0;
startIndent = 0;
if (indent > -1)
{
oneIndent = tab;
startIndent = indent;
CR = "\r\n";
}
nextIndent = indent;
String sIndent = new String(' ', startIndent + oneIndent);
StringBuilder xml = new StringBuilder("");
xml.Append(" kind=\"" + attrInfo.typeName() + "\"");
if (attrInfo.isArray())
{
xml.Append(" array=\"T\"");
}
if ((attrInfo.units().Length > 0) && (attrInfo.units()[0] != '-'))
{
xml.Append(" unit=\"" + attrInfo.units() + "\"");
}
xml.Append(">" + CR);
//if a scalar or array of scalars then write the defval|minval|maxval elements
if (attrInfo.isScalar() || (attrInfo.isArray() && attrInfo.baseType() == TTypedValue.TBaseType.ITYPE_DEF))
{
TInitValue initInfo = new TInitValue(attrInfo);
if (initInfo != null)
{
if (initInfo.getDefault() != null)
{
xml.Append(sIndent + "<defval>" + initInfo.getDefault().asEscapedString() + "</defval>" + CR);
}
if (initInfo.getMin() != null)
{
xml.Append(sIndent + "<minval>" + initInfo.getMin().asEscapedString() + "</minval>" + CR);
}
if (initInfo.getMax() != null)
{
xml.Append(sIndent + "<maxval>" + initInfo.getMax().asEscapedString() + "</maxval>" + CR);
}
}
}
//now nest into the fields/elements
sIndent = new String(' ', startIndent);
if (!attrInfo.isScalar())
{
// Special handling for non-scalar arrays of length 0, to ensure type definition is output
iFirst = (uint)((attrInfo.isArray() && attrInfo.count() == 0) ? 0 : 1);
for (i = iFirst; i <= attrInfo.count(); i++)
{ //for each child field
if (attrInfo.isArray() && attrInfo.baseType() == TTypedValue.TBaseType.ITYPE_DEF)
{
xml.Append(sIndent + "<element");
xml.Append(writeFieldInfo(attrInfo.item(i), nextIndent, oneIndent));
xml.Append(sIndent + "</element>" + CR);
}
else if (attrInfo.isRecord())
{
xml.Append(sIndent + "<field name=\"" + attrInfo.item(i).Name + "\"");
xml.Append(writeFieldInfo(attrInfo.item(i), nextIndent, oneIndent));
xml.Append(sIndent + "</field>" + CR);
}
}
}
return(xml.ToString());
}
//============================================================================
/// <summary>
/// Formats the xml text for the 'field' or 'element' description of the typed
/// value stored as a TTypedValue.
/// </summary>
/// <param name="attrInfo"></param>
/// <param name="indent"></param>
/// <param name="tab">Number of spaces in each tab</param>
/// <returns>Buffer containing the text</returns>
/// N.Herrmann Apr 2002
//============================================================================
protected override String writeFieldInfo(TTypedValue attrInfo, int indent, int tab)
{
String elementType;
uint i;
int nextIndent;
int oneIndent;
String CR = "";
TTypedValue firstElement;
String sIndent = "";
//determine how much to indent this description
oneIndent = 0;
nextIndent = -1;
if (indent > -1)
{
CR = Environment.NewLine;
oneIndent = tab;
nextIndent = indent + oneIndent;
sIndent = new String(' ', nextIndent); //begin at this level
}
StringBuilder xml = new StringBuilder("");
if (attrInfo.baseType() != TBaseType.ITYPE_DEF)
{
xml.Append(" kind=\"" + attrInfo.typeName() + "\"");
}
if (attrInfo.isArray())
{
xml.Append(" array=\"T\"");
}
if ((attrInfo.units().Length > 0) && (attrInfo.units()[0] != '-'))
{
xml.Append(" unit=\"" + attrInfo.units() + "\"");
}
//now nest into the fields/elements for this DDML type
if (!attrInfo.isScalar())
{
xml.Append(">" + CR);
if (attrInfo.isArray() && (attrInfo.baseType() == TBaseType.ITYPE_DEF)) //an array will only show the first child for DDML
{
if (attrInfo.count() == 0)
{
firstElement = attrInfo.item(0);
}
else
{
firstElement = attrInfo.item(1);
}
elementType = "element";
xml.Append(sIndent + "<" + elementType);
xml.Append(writeFieldInfo(firstElement, nextIndent, oneIndent));
if (!firstElement.isScalar())
{
xml.Append(sIndent + "</" + elementType + ">" + CR);
}
}
else if (attrInfo.isRecord())
{
for (i = 1; i <= attrInfo.count(); i++) //for each child field
{
elementType = "field";
xml.Append(sIndent + "<" + elementType + " name=\"" + attrInfo.item(i).Name + "\"");
xml.Append(writeFieldInfo(attrInfo.item(i), nextIndent, oneIndent));
if (!attrInfo.item(i).isScalar())
{
xml.Append(sIndent + "</" + elementType + ">" + CR);
}
}
}
}
else
{
xml.Append("/>" + CR);
}
return(xml.ToString());
}
//==============================================================================
/// <summary>
/// Recursive logic for the AggregateValues routine
/// For a scalar value, finds the corresponding output column and updates it.
/// For an array or collection, recurses into each element or member.
/// </summary>
/// <param name="aValue"></param>
/// <param name="aTree"></param>
//==============================================================================
private void aggregateValue(TTypedValue aValue, TValTree aTree)
{
int iColNo;
int i;
int oldLen;
int parentId;
if (aTree.varId < 0)
{ // Hasn't been defined yet...
if (aTree.parent != null)
{
parentId = aTree.parent.varId;
}
else
{
parentId = -1;
}
aTree.varId = defineVariable(aTree.FullColumnName(), (TDDMLValue)aValue, parentId, (int)aTree.index, aTree.specifier);
}
if (aValue.isScalar()) // Scalar - we store or summarise the
{ // data
if (aTree.colNo < 0) // Doesn't have a column number yet...
{
aTree.colNo = FColumns.Count;
TOutputScalar aScalar = new TOutputScalar(aValue, aTree.specifier.Aggreg, aTree.specifier.iDecPl);
aScalar.Name = aTree.FullColumnName();
FColumns.Add(aScalar);
}
iColNo = aTree.colNo;
FColumns[iColNo].Update(aValue);
}
else // Array or collection - recurse
{
if (aValue.count() > aTree.subTrees.Count)
{ // Need to add new subTrees
oldLen = aTree.subTrees.Count;
//SetLength(aTree.subTrees, aValue.count());
for (i = oldLen; i < aValue.count(); i++)
//for (i = oldLen; i <= aTree.subTrees.Count - 1; i++)
{
aTree.subTrees.Add(new TValTree(aTree, aTree.specifier));
aTree.subTrees[i].index = (uint)i + 1;
if (aValue.isArray())
{
aTree.subTrees[i].columnName = "[" + aTree.subTrees[i].index.ToString() + "]";
}
else
{
if (aValue.isRecord())
{
aTree.subTrees[i].columnName = ":" + aValue.item((uint)aTree.subTrees[i].index).Name;
}
}
aTree.subTrees[i].varId = defineVariable(aTree.subTrees[i].FullColumnName(),
(TDDMLValue)(aValue.item(aTree.subTrees[i].index)),
aTree.varId, (int)aTree.subTrees[i].index,
aTree.subTrees[i].specifier);
}
}
for (i = 1; i <= aValue.count(); i++)
{
aggregateValue(aValue.item((uint)i), aTree.subTrees[i - 1]);
}
}
}
//=====================================================================
/// <summary>
///
/// </summary>
/// <param name="typedValue"></param>
public TAFTreeViewColumnTag(TTypedValue typedValue)
{
_typedValue = typedValue;
//_sColumnData = ipsColumnData;
_sVariable = _typedValue.Name;
_sValue = _typedValue.asString();
_sType = _typedValue.typeName();
if (_sType.ToLower().Equals("defined") || (_typedValue.isRecord() == true))
{
_sType = "record";
}
if (_typedValue.isArray())
{
_sType = "array";
}
_sUnit = _typedValue.units();
if (typedValue is TInitValue)
{
TInitValue initValue = _typedValue as TInitValue;
_sDescr = initValue.getDescr();
if (initValue.getDefault() != null)
{
_sDefault = initValue.getDefault().asString();
}
else
{
_sDefault = "";
}
if (initValue.getMin() != null)
{
_sMin = initValue.getMin().asString();
}
else
{
_sMin = "";
}
if (initValue.getMax() != null)
{
//_sMax = Math.Round( initValue.getMax().asDouble(),3).ToString();
_sMax = initValue.getMax().asString();
//initValue.getMax().typeName()
//double dMaxValue = double.MaxValue;
//switch (initValue.baseType())
//{
// case TTypedValue.TBaseType.ITYPE_INT1:
// {
// //FMax.setValue(+VERYLARGE_I1);
// //FMin.setValue(-VERYLARGE_I1);
// } break;
// case TTypedValue.TBaseType.ITYPE_INT2:
// {
// //FMax.setValue(+VERYLARGE_I2);
// //FMin.setValue(-VERYLARGE_I2);
// } break;
// case TTypedValue.TBaseType.ITYPE_INT4:
// {
// //FMax.setValue(+VERYLARGE_I4);
// //FMin.setValue(-VERYLARGE_I4);
// } break;
// case TTypedValue.TBaseType.ITYPE_INT8:
// {
// //FMax.setValue(+VERYLARGE_I8);
// //FMin.setValue(-VERYLARGE_I8);
// } break;
// case TTypedValue.TBaseType.ITYPE_SINGLE:
// {
// //FMax.setValue(+1.0 * VERYLARGE_S);
// //FMin.setValue(-1.0 * VERYLARGE_S);
// } break;
// case TTypedValue.TBaseType.ITYPE_DOUBLE:
// {
// dMaxValue = TInitValue.VERYLARGE_D_POS;
// //FMin.setValue(VERYLARGE_D_NEG);
// } break;
//}
//if (initValue.getMax().asDouble() == dMaxValue)
//{
// Console.WriteLine("equal");
// _sMax = "";
//}
}
else
{
_sMax = "";
}
}
}
//============================================================================
/// <summary>
/// Writes the SDML value as XML.
/// </summary>
/// <param name="attrInfo">The typed value to use.</param>
/// <param name="indent">Indent spaces to use. -1 = no indent.</param>
/// <param name="tab">Number of spaces in each tab</param>
/// <returns>The XML for the SDML value.</returns>
//============================================================================
protected override String writeFieldInfo(TTypedValue attrInfo, int indent, int tab)
{
uint i;
int oneIndent;
int nextIndent;
int startIndent;
String CR = "";
//determine how much to indent this description
oneIndent = 0;
startIndent = 0;
if (indent > -1)
{
oneIndent = tab;
startIndent = indent;
CR = "\r\n";
}
String sIndent = new String(' ', startIndent); //begin at this level
nextIndent = indent + oneIndent;
StringBuilder xml = new StringBuilder("");
if (attrInfo.baseType() != TTypedValue.TBaseType.ITYPE_DEF)
{
xml.Append(" kind=\"" + attrInfo.typeName() + "\"");
}
if (attrInfo.isArray())
{
xml.Append(" array=\"T\"");
}
if ((attrInfo.units().Length > 0) && (attrInfo.units()[0] != '-'))
{
xml.Append(" unit=\"" + attrInfo.units() + "\"");
}
xml.Append(">" + CR);
if (attrInfo.isScalar()) // Scalars - use a <val> element
{
xml.Append(sIndent + "<val>" + scalarString(attrInfo) + "</val>" + CR);
}
else
{
//now nest into the fields/elements
for (i = 1; i <= attrInfo.count(); i++)
{
if (attrInfo.isArray() && (attrInfo.baseType() != TTypedValue.TBaseType.ITYPE_DEF))
{
xml.Append(new String(' ', oneIndent) + "<val>" + scalarString(attrInfo.item(i)) + "</val>" + CR); // Scalar array, indented format
}
else if (attrInfo.isArray()) // All other arrays
{
xml.Append(sIndent + "<element"
+ writeFieldInfo(attrInfo.item(i), nextIndent, oneIndent)
+ sIndent + "</element>" + CR);
}
else if (attrInfo.isRecord()) // Records
{
xml.Append(sIndent + "<field name=\"" + attrInfo.item(i).Name + "\""
+ writeFieldInfo(attrInfo.item(i), nextIndent, oneIndent)
+ sIndent + "</field>" + CR);
}
}
}
return(xml.ToString());
}