/// <summary>
/// Writes the import statements.
/// </summary>
private string LoadTemplate_Imports(Template template, Context context)
{
string namespaceUri = context.Target as string;
if (namespaceUri == null)
{
return(null);
}
if (!m_exportAll)
{
template.WriteLine(String.Empty);
template.Write(context.Prefix);
if (namespaceUri == Namespaces.OpcUaBuiltInTypes)
{
template.Write("<opc:Import Namespace=\"{0}\" />", Namespaces.OpcUaBuiltInTypes);
}
else
{
template.Write(GetImportStatment(namespaceUri));
}
return(null);
}
return(TemplatePath + "BuiltInTypes.bsd");
}
/// <summary>
/// Chooses the template for the data type.
/// </summary>
private string LoadTemplate_ComplexTypeFields(Template template, Context context)
{
ComplexType complexType = context.Target as ComplexType;
if (complexType == null)
{
return(null);
}
foreach (FieldType field in complexType.Field)
{
template.WriteLine(String.Empty);
template.Write(context.Prefix);
template.Write("<opc:Field Name=\"{0}\" DataType=\"{1}\"", field.Name, GetPrefixedName(field.DataType));
if (field.ValueRank >= 0)
{
template.Write(" ValueRank=\"Array\"");
}
template.Write(" />");
}
return(null);
}
/// <summary>
/// Writes an enumerated value in an OPCBinary schema.
/// </summary>
private string LoadTemplate_EnumeratedValue(Template template, Context context)
{
EnumeratedValue valueType = context.Target as EnumeratedValue;
if (valueType == null)
{
return(null);
}
template.WriteLine(String.Empty);
template.Write(context.Prefix);
template.Write("<xs:enumeration value=\"{0}_{1}\" />", valueType.Name, valueType.Value);
/*
* if (valueType.Value != 1)
* {
* template.WriteLine(">");
* template.WriteLine("{0} <xs:annotation>", context.Prefix);
* template.WriteLine("{0} <xs:appinfo>", context.Prefix);
* template.WriteLine("{0} <EnumerationValue xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">{1}</EnumerationValue>", context.Prefix, valueType.Value);
* template.WriteLine("{0} </xs:appinfo>", context.Prefix);
* template.WriteLine("{0} </xs:annotation>", context.Prefix);
* template.WriteLine("{0}</xs:enumeration>", context.Prefix);
* }
* else
* {
* template.Write(" />");
* }
*/
return(null);
}
/// <summary>
/// Writes an enumerated value in an OPCBinary schema.
/// </summary>
private string LoadTemplate_EnumeratedValue(Template template, Context context)
{
EnumeratedValue valueType = context.Target as EnumeratedValue;
if (valueType == null)
{
return(null);
}
template.WriteLine(String.Empty);
template.Write(context.Prefix);
template.Write("<opc:EnumeratedValue Name=\"{0}\" Value=\"{1}\" />", valueType.Name, valueType.Value);
return(null);
}
/// <summary>
/// Chooses the template for the data type.
/// </summary>
private string LoadTemplate_EnumeratedTypeValues(Template template, Context context)
{
EnumeratedType enumeratedType = context.Target as EnumeratedType;
if (enumeratedType == null)
{
return(null);
}
foreach (EnumeratedValue value in enumeratedType.Value)
{
template.WriteLine(String.Empty);
template.Write(context.Prefix);
template.Write("<opc:Field Name=\"{0}\" Identifier=\"{1}\" />", value.Name, value.Value);
}
return(null);
}
private bool WriteTemplate_Enum(Template template, Context context)
{
EnumeratedValue field = context.Target as EnumeratedValue;
if (field != null)
{
context.BlankLine = false;
template.Write(string.Format("\n {{ {0}, \"{1}\" }},", field.Value, field.Name));
return(true);
}
return(false);
}
private bool WriteTemplate_Parser(Template template, Context context)
{
FieldType field = context.Target as FieldType;
if (field != null)
{
DataType dt = m_validator.ResolveType(field.DataType);
string sDataTypeName = dt.Name;
if (field.ValueRank == -1)
{
//if (field.DataType.Namespace == "http://opcfoundation.org/UA/BuiltInTypes/" ||
// field.DataType.Namespace == "http://opcfoundation.org/UA/Core/DataTypes/")
if (m_hashSimpleTypes.ContainsKey(sDataTypeName))
{
m_lstFields.Add(new HFEntry(field.Name, sDataTypeName));
template.Write(string.Format("\n parse{0}(subtree, tvb, pOffset, hf_opcua_{1});", sDataTypeName, field.Name));
}
else if ((dt as EnumeratedType) != null)
{
template.Write(string.Format("\n parse{0}(subtree, tvb, pOffset);", sDataTypeName));
}
else
{
template.Write(string.Format("\n parse{0}(subtree, tvb, pOffset, \"{1}\");", sDataTypeName, field.Name));
}
}
else
{
//if (field.DataType.Namespace == "http://opcfoundation.org/UA/BuiltInTypes/" ||
// field.DataType.Namespace == "http://opcfoundation.org/UA/Core/DataTypes/")
if (m_hashSimpleTypes.ContainsKey(sDataTypeName))
{
m_lstFields.Add(new HFEntry(field.Name, sDataTypeName));
template.Write(string.Format("\n parseArraySimple(subtree, tvb, pOffset, hf_opcua_{1}, parse{0});", sDataTypeName, field.Name));
}
else if ((dt as EnumeratedType) != null)
{
template.Write(string.Format("\n parseArrayEnum(subtree, tvb, pOffset, parse{0});", sDataTypeName));
}
else
{
template.Write(string.Format("\n parseArrayComplex(subtree, tvb, pOffset, \"{1}\", parse{0});", sDataTypeName, field.Name));
}
}
}
return(false);
}
/// <summary>
/// Writes a field in an OPCBinary schema.
/// </summary>
private string LoadTemplate_Field(Template template, Context context)
{
FieldType fieldType = context.Target as FieldType;
if (fieldType == null)
{
return(null);
}
// resolve any type definitions.
DataType datatype = Validator.ResolveType(fieldType.DataType);
if (datatype == null)
{
throw new ApplicationException(String.Format("Could not find datatype '{0}' for field '{1}'.", fieldType.DataType, fieldType.Name));
}
template.WriteLine(String.Empty);
template.Write(context.Prefix);
template.Write("<xs:element name=\"{0}\"", fieldType.Name);
if (datatype.Name == "XmlElement" && fieldType.ValueRank < 0)
{
template.WriteLine(">");
template.WriteLine("{0} <xs:complexType>", context.Prefix);
template.WriteLine("{0} <xs:sequence>", context.Prefix);
template.WriteLine("{0} <xs:any minOccurs=\"0\" processContents=\"lax\" />", context.Prefix);
template.WriteLine("{0} </xs:sequence>", context.Prefix);
template.WriteLine("{0} </xs:complexType>", context.Prefix);
template.Write("{0}</xs:element>", context.Prefix);
}
else
{
template.Write(" type=\"{0}\" minOccurs=\"0\"", GetXmlSchemaTypeName(datatype.QName, fieldType.ValueRank));
if (datatype.Name == "String" || datatype.Name == "ByteString")
{
template.Write(" nillable=\"true\"");
}
template.Write(" />");
}
return(null);
}
/// <summary>
/// Writes a field in an OPCBinary schema.
/// </summary>
private string LoadTemplate_Field(Template template, Context context)
{
FieldType fieldType = context.Target as FieldType;
if (fieldType == null)
{
return(null);
}
// resolve any type definitions.
DataType datatype = Validator.ResolveType(fieldType.DataType);
if (datatype == null)
{
throw new ApplicationException(String.Format("Could not find datatype '{0}' for field '{1}'.", fieldType.DataType, fieldType.Name));
}
template.WriteLine(String.Empty);
template.Write(context.Prefix);
if (fieldType.ValueRank == 0)
{
template.WriteLine("<opc:Field Name=\"NoOf{0}\" TypeName=\"opc:Int32\" />", fieldType.Name);
template.Write(context.Prefix);
}
template.Write("<opc:Field Name=\"{0}\"", fieldType.Name);
template.Write(" TypeName=\"{0}\"", GetBinarySchemaTypeName(datatype.QName));
if (fieldType.ValueRank == 0)
{
template.Write(" LengthField=\"NoOf{0}\"", fieldType.Name);
}
template.Write(" />");
return(null);
}
private bool WriteTemplate_Field(Template template, Context context)
{
HFEntry entry = context.Target as HFEntry;
if (entry != null)
{
string sVariableName = "hf_opcua_" + entry.FieldName();
string sFieldName = entry.FieldName();
string sDataType = "";
string sBase = "BASE_NONE";
context.BlankLine = false;
switch (entry.DataTypeName())
{
case "Boolean": sDataType = "FT_BOOLEAN"; break;
case "Byte": sDataType = "FT_UINT8"; sBase = "BASE_DEC"; break;
case "SByte": sDataType = "FT_INT8"; sBase = "BASE_DEC"; break;
case "UInt16": sDataType = "FT_UINT16"; sBase = "BASE_DEC"; break;
case "Int16": sDataType = "FT_INT16"; sBase = "BASE_DEC"; break;
case "UInt32": sDataType = "FT_UINT32"; sBase = "BASE_DEC"; break;
case "Int32": sDataType = "FT_INT32"; sBase = "BASE_DEC"; break;
case "UInt64": sDataType = "FT_UINT64"; sBase = "BASE_DEC"; break;
case "Int64": sDataType = "FT_INT64"; sBase = "BASE_DEC"; break;
case "Float": sDataType = "FT_FLOAT"; break;
case "Double": sDataType = "FT_DOUBLE"; break;
case "Guid": sDataType = "FT_GUID"; break;
case "String": sDataType = "FT_STRING"; break;
case "StatusCode": sDataType = "FT_UINT32"; sBase = "BASE_HEX"; break;
case "ByteString": sDataType = "FT_BYTES"; sBase = "BASE_HEX"; break;
case "XmlElement": sDataType = "FT_BYTES"; sBase = "BASE_HEX"; break;
case "DateTime": sDataType = "FT_ABSOLUTE_TIME"; break;
default:
sDataType = "FT_UNKNOWN";
break;
}
if (sDataType != "FT_UNKNOWN")
{
if (context.Token == "// _INDECES_")
{
string sFormat = "\nint {0} = -1;";
string sEntry = string.Format(sFormat, sVariableName);
template.Write(sEntry);
}
else if (context.Token == "// _EXTERNINDECES_")
{
string sFormat = "\nextern int {0};";
string sEntry = string.Format(sFormat, sVariableName);
template.Write(sEntry);
}
else if (context.Token == "// _FIELDS_")
{
string sFormat = "\n {{ &{0}, {{ \"{1}\", \"\", {2}, {3}, NULL, 0x0, \"\", HFILL }} }}";
string sEntry = string.Format(sFormat, sVariableName, sFieldName, sDataType, sBase);
if (!context.FirstInList)
{
template.Write(",");
}
template.Write(sEntry);
}
}
}
return(true);
}
