/// <summary>
/// Constructs a new option definition instance
/// </summary>
/// <param name="elementType">The optional type</param>
public OptionDefinition(TypeDefinition elementType)
{
Contract.Requires(elementType != null);
this.ElementType = elementType;
}
/// <summary>
/// Constructs a new named type instance
/// </summary>
/// <param name="name">The name of the type</param>
/// <param name="definition">The type definition</param>
public NamedType(string name, TypeDefinition definition)
{
this.Name = name;
this.Definition = definition;
}
/// <summary>
/// Generates a definition
/// </summary>
/// <param name="name">The name of the type</param>
/// <param name="def">The definition</param>
private void _generateDefinition(CSharpEmitter emitter, string name, string fieldName, TypeDefinition def, bool root = false, string tag = null, string choiceBase = null)
{
switch(def.Type)
{
case DefinitionType.Enumeration:
_generateEnumeration(emitter, name, fieldName, (EnumerationDefinition)def);
break;
case DefinitionType.BitString:
_generateBitString(emitter, name, fieldName, (BitStringDefinition)def);
break;
case DefinitionType.Sequence:
_generateSequence(emitter, name, fieldName, (SequenceDefinition)def, root, tag, choiceBase);
break;
case DefinitionType.Choice:
_generateChoice(emitter, name, fieldName, (ChoiceDefinition)def, root);
break;
case DefinitionType.Array:
_generateArrayType(emitter, name, fieldName, (ArrayDefinition)def, root);
break;
case DefinitionType.Option:
_generateOptionType(emitter, name, fieldName, (OptionDefinition)def, root);
break;
case DefinitionType.Name:
_generateNameType(emitter, name, fieldName, (NameDefinition)def, root);
break;
case DefinitionType.Primitive:
_generatePrimitiveType(emitter, name, fieldName, (PrimitiveDefinition)def, root);
break;
}
}
/// <summary>
/// Gets the type name for a defined type
/// </summary>
/// <param name="typeName">The name of the type</param>
/// <param name="fieldName">The name of the current field</param>
/// <param name="definition">The defined type</param>
/// <returns>The type name</returns>
private string _getDefinitionName(string typeName, string fieldName, TypeDefinition definition)
{
if (!string.IsNullOrEmpty(typeName))
return typeName;
if (definition.Type == DefinitionType.Primitive)
{
var prim = ((PrimitiveDefinition)definition).Primitive;
switch (prim)
{
case PrimitiveType.Null: return "Null";
case PrimitiveType.Boolean: return "bool";
case PrimitiveType.Unsigned8: return "byte";
case PrimitiveType.Unsigned16: return "ushort";
case PrimitiveType.Unsigned32: return "uint";
case PrimitiveType.Unsigned64: return "ulong";
case PrimitiveType.Signed8: return "sbyte";
case PrimitiveType.Signed16: return "short";
case PrimitiveType.Signed32: return "int";
case PrimitiveType.Signed64: return "long";
case PrimitiveType.Float32: return "float";
case PrimitiveType.Float64: return "double";
case PrimitiveType.OctetString: return "byte[]";
case PrimitiveType.CharString: return "string";
case PrimitiveType.BitString8: return "BitString8";
case PrimitiveType.BitString24: return "BitString24";
case PrimitiveType.BitString56: return "BitString56";
case PrimitiveType.Enumerated: return "Enumerated";
case PrimitiveType.Date: return "Date";
case PrimitiveType.Time: return "Time";
case PrimitiveType.ObjectId: return "ObjectId";
case PrimitiveType.Generic: return "GenericValue";
default:
throw new InvalidDataException(prim.ToString());
}
}
else if (definition.Type == DefinitionType.Name)
{
var name = ((NameDefinition)definition).Name;
return _transformTypeName(name);
}
else if(definition.Type == DefinitionType.Option)
{
var option = (OptionDefinition)definition;
return "Option<" + _getDefinitionName(null, fieldName, option.ElementType) + ">";
}
else if(definition.Type == DefinitionType.Array)
{
var array = (ArrayDefinition)definition;
return "ReadOnlyArray<" + _getDefinitionName(null, fieldName, array.ElementType) + ">";
}
else
{
return _fieldNameToTypeName(fieldName);
}
}
/// <summary>
/// Constructs a new field definition instance
/// </summary>
/// <param name="name">The name of the field</param>
/// <param name="tag">The tag of the field</param>
/// <param name="type">The type of the field</param>
public FieldDefinition(string name, byte tag, TypeDefinition type)
{
this.Name = name;
this.Tag = tag;
this.Type = type;
}
