public override void Visit(EnumerationDeclaration decl)
{
cb.WriteLine("enum class {0} {{", decl.Name);
cb.Indent();
bool first = true;
foreach (var element in decl.Elements)
{
if (first)
{
first = false;
}
else
{
cb.Write(',');
cb.WriteLine();
}
cb.WriteIndent();
cb.Write(element);
}
cb.WriteLine();
cb.Unindent();
cb.WriteIndent();
cb.Write("};");
cb.WriteLine();
}
public void Render(CodeDom.CodeObject target, DesignObject designObject)
{
var enumeration = (Enumeration)designObject;
var enumCodeObject = new EnumerationDeclaration
{
Name = enumeration.Name
};
(target as CodeDom.Module).TypeDeclarations.Add(enumCodeObject);
enumCodeObject.Scope = enumeration.Scope.Convert();
OnRenderEnumDeclaration(enumCodeObject);
foreach (var member in enumeration.Values)
{
var memberDeclaration = new EnumMemberDeclaration
{
Name = member.Name,
Value = member.Value
};
OnRenderEnumMemberDeclaration(memberDeclaration);
enumCodeObject.Values.Add(memberDeclaration);
}
OnAfterRenderEnumDeclaration(enumCodeObject);
}
public static UnitDeclaration Generate(Machine machine, CGeneratorOptions options)
{
MachineUnitGenerator.options = options;
NamespaceMemberList memberList = new NamespaceMemberList();
// Crea el tipus enumerador pels valors del estat.
//
List <string> stateList = new List <string>();
foreach (var state in machine.States)
{
stateList.Add(String.Format("State_{0}", state.Name));
}
EnumerationDeclaration stateType = new EnumerationDeclaration("State", AccessSpecifier.Public, stateList);
memberList.Add(stateType);
// Crea la variabe 'state'
//
VariableDeclaration stateVariable = new VariableDeclaration();
stateVariable.Access = AccessSpecifier.Private;
stateVariable.Name = String.Format("{0}_state", machine.Name);
stateVariable.ValueType = TypeIdentifier.FromName("State");
memberList.Add(stateVariable);
// Crea les funcions de transicio [machine]_[state]_[transition]()
//
foreach (var state in machine.States)
{
foreach (var transitionName in state.GetTransitionNames())
{
memberList.Add(MakeStateTransitionFunction(machine, state, transitionName));
}
}
// Crea la funcio [machine]_Start()
//
memberList.Add(MakeStartFunction(machine));
// Crea les funcions de despatch de les transicions [machine]_[transition]()
//
foreach (var transitionName in machine.GetTransitionNames())
{
memberList.Add(MakeMachineTransitionFunction(machine, transitionName));
}
return(new UnitDeclaration(new NamespaceDeclaration {
Name = "",
Members = memberList
}));;
}
public void CSharpCodeGenerator_EnumDeclaration()
{
var type = new EnumerationDeclaration("Sample");
type.BaseType = typeof(uint);
type.Modifiers = Modifiers.Internal;
type.Members.Add(new EnumerationMember("A", 1));
type.Members.Add(new EnumerationMember("B", 2));
type.CustomAttributes.Add(new CustomAttribute(typeof(FlagsAttribute)));
var generator = new CSharpCodeGenerator();
var result = generator.Write(type);
Assert.That.StringEquals(@"[System.FlagsAttribute]
internal enum Sample : uint
{
A = 1,
B = 2
}
", result);
}
private static TypeDeclaration GenerateEnumerationJsonConverter(CompilationUnit unit, EnumerationDeclaration enumType)
{
var serializationNamespace = unit.AddNamespace(SerializationNamespace);
// EnumMembers
var enumMember = serializationNamespace.AddType(new ClassDeclaration("EnumMember"));
enumMember.Modifiers = Modifiers.Partial | Modifiers.Internal;
var enumMemberType = WellKnownTypes.EnumMemberTypeReference.MakeGeneric(enumType);
var arrayType = enumMemberType.Clone();
arrayType.ArrayRank = 1;
// EnumMember.Field
var initArray = enumMember.AddMember(new MethodDeclaration("Create" + enumType.Name + "Members"));
initArray.Modifiers = Modifiers.Private | Modifiers.Static;
initArray.ReturnType = arrayType;
initArray.Statements = new StatementCollection();
var result = new VariableDeclarationStatement(arrayType, "result", new NewArrayExpression(enumMemberType, enumType.Members.Count));
initArray.Statements.Add(result);
for (var i = 0; i < enumType.Members.Count; i++)
{
var enumerationMember = enumType.Members[i];
var model = (EnumerationMember)enumerationMember.Data["EnumerationMember"];
if (model == null)
{
continue;
}
initArray.Statements.Add(new AssignStatement(
new ArrayIndexerExpression(result, i),
new NewObjectExpression(enumMemberType,
new MemberReferenceExpression(new TypeReferenceExpression(enumType), ToPropertyName(enumerationMember.Name)),
model.FinalSerializationName)));
}
initArray.Statements.Add(new ReturnStatement(result));
var membersField = enumMember.AddMember(new FieldDeclaration("s" + ToFieldName(enumType.Name) + "Members", arrayType));
membersField.Modifiers = Modifiers.Private | Modifiers.Static | Modifiers.ReadOnly;
membersField.InitExpression = new MethodInvokeExpression(new MemberReferenceExpression(new TypeReferenceExpression(enumMember), initArray));
// EnumMember.FromString
var fromString = enumMember.AddMember(new MethodDeclaration(enumType.Name + "FromString"));
var fromStringArg = fromString.AddArgument("value", typeof(string));
fromString.Modifiers = Modifiers.Public | Modifiers.Static;
fromString.ReturnType = enumType;
fromString.Statements = new StatementCollection
{
new ReturnStatement(new MethodInvokeExpression(
new MemberReferenceExpression(new TypeReferenceExpression(enumMember), "FromString"),
fromStringArg,
new MemberReferenceExpression(new TypeReferenceExpression(enumMember), membersField))),
};
// EnumMember.ToString
var toString = enumMember.AddMember(new MethodDeclaration("ToString"));
var toStringArg = toString.AddArgument("value", enumType);
toString.Modifiers = Modifiers.Public | Modifiers.Static;
toString.ReturnType = typeof(string);
toString.Statements = new StatementCollection();
foreach (var member in enumType.Members)
{
var model = (EnumerationMember)member.Data["EnumerationMember"];
if (model == null)
{
continue;
}
toString.Statements.Add(new ConditionStatement()
{
Condition = new BinaryExpression(BinaryOperator.Equals, toStringArg, new MemberReferenceExpression(new TypeReferenceExpression(enumType), ToPropertyName(member.Name))),
TrueStatements = new ReturnStatement(model.FinalSerializationName),
});
}
toString.Statements.Add(new ThrowStatement(
new NewObjectExpression(typeof(ArgumentOutOfRangeException),
new NameofExpression(toStringArg),
new MethodInvokeExpression(new MemberReferenceExpression(typeof(string), "Concat"), "Value '", new MethodInvokeExpression(new MemberReferenceExpression(toStringArg, "ToString")), "' is not valid"))));
// Json converter
var converterType = serializationNamespace.AddType(new ClassDeclaration(enumType.Name + "JsonConverter"));
converterType.BaseType = new TypeReference("Meziantou.GitLab.Serialization.EnumBaseJsonConverter").MakeGeneric(enumType);
converterType.Modifiers = Modifiers.Partial | Modifiers.Sealed | Modifiers.Internal;
// ToString
var converterToString = converterType.AddMember(new MethodDeclaration("ToString"));
converterToString.Modifiers = Modifiers.Protected | Modifiers.Override;
converterToString.ReturnType = typeof(string);
var convertToStringArg = converterToString.AddArgument("value", enumType);
converterToString.Statements =
new ReturnStatement(
new MethodInvokeExpression(
new MemberReferenceExpression(new TypeReferenceExpression(enumMember), "ToString"),
convertToStringArg));
// FromString
var converterFromString = converterType.AddMember(new MethodDeclaration("FromString"));
converterFromString.Modifiers = Modifiers.Protected | Modifiers.Override;
converterFromString.ReturnType = enumType;
var convertFromStringArg = converterFromString.AddArgument("value", typeof(string));
converterFromString.Statements =
new ReturnStatement(
new MethodInvokeExpression(
new MemberReferenceExpression(new TypeReferenceExpression(enumMember), enumType.Name + "FromString"),
convertFromStringArg));
return(converterType);
}
protected virtual void OnAfterRenderEnumDeclaration(EnumerationDeclaration declaration)
{
AfterRenderEnumDeclaration?.Invoke(this, new RenderEnumDeclarationEventArgs {
Declaration = declaration
});
}
public virtual void VisitEnumerationDeclaration(EnumerationDeclaration enumerationDeclaration)
{
DefaultVisit(enumerationDeclaration);
}
