/// <summary>
/// Constructs a new choice definition
/// </summary>
/// <param name="fields">The fields of the choice</param>
public ChoiceDefinition(FieldDefinition[] fields)
{
this.Fields = fields;
}
/// <summary>
/// Returns the type name for a sequence field
/// </summary>
/// <param name="field">The field</param>
/// <returns>The type name</returns>
private string _sequenceFieldTypeName(FieldDefinition field)
{
return _getDefinitionName(null, _sequenceFieldEffectiveNameForType(field), field.Type);
}
/// <summary>
/// Determines whether a choice option requires a wrapper type
/// </summary>
/// <param name="field">The choice field</param>
/// <returns>True if a wrapper is required, false otherwise</returns>
private bool _choiceOptionNeedsWrapper(FieldDefinition field)
{
return field.Type.Type != DefinitionType.Sequence;
}
/// <summary>
/// Determines whether a sequence field type name needs -type appended
/// to it so it won't conflict with a property name
/// </summary>
/// <param name="field">The sequence field</param>
/// <returns>True if the suffix is needed, false otherwise</returns>
private bool _sequenceFieldNeedsTypeSuffix(FieldDefinition field)
{
var type = field.Type;
if (type.Type == DefinitionType.Option)
type = ((OptionDefinition)type).ElementType;
if (type.Type == DefinitionType.Array)
type = ((ArrayDefinition)type).ElementType;
switch (type.Type)
{
case DefinitionType.Enumeration:
case DefinitionType.BitString:
case DefinitionType.Sequence:
case DefinitionType.Choice:
return true;
}
return false;
}
/// <summary>
/// Returns the effective field name for a sequence field
/// that is used to determine the type name for the field
/// </summary>
/// <param name="field">The field</param>
/// <returns>The effective field name</returns>
private string _sequenceFieldEffectiveNameForType(FieldDefinition field)
{
string name = field.Name;
if (_sequenceFieldNeedsTypeSuffix(field))
name = name + "-type";
return name;
}
/// <summary>
/// Gets the parameters that need to be forwarded to a choice option's
/// constructor
/// </summary>
/// <param name="field">The choice field</param>
/// <returns>The parameter array</returns>
private Parameter[] _getChoiceOptionForwardedParameters(FieldDefinition field)
{
if(_choiceOptionNeedsWrapper(field))
{
var wrappedTypeName = _getDefinitionName(null, field.Name, field.Type);
var tempName = _fieldNameToTempName(field.Name);
return new Parameter[] {
new Parameter(wrappedTypeName, tempName)
};
}
else
{
var seq = (SequenceDefinition)field.Type;
List<Parameter> ps = new List<Parameter>();
foreach(var f in seq.Fields)
{
var typeName = _getDefinitionName(null, f.Name, f.Type);
var tempName = _fieldNameToTempName(f.Name);
ps.Add(new Parameter(typeName, tempName));
}
return ps.ToArray();
}
}
/// <summary>
/// Generates a choice option
/// </summary>
/// <param name="field">The field to generate the option for</param>
private void _generateChoiceOption(CSharpEmitter emitter, string choiceName, FieldDefinition field)
{
var tag = _transformFieldName(field.Name);
_generateDefinition(emitter, null, field.Name, field.Type, false, tag, choiceName);
}
/// <summary>
/// Constructs a new sequence definition
/// </summary>
/// <param name="fields">The fields of the sequence</param>
public SequenceDefinition(FieldDefinition[] fields)
{
this.Fields = fields;
}
