public List <String> GetTypes(Schema Schema)
{
var Primitives = GetPrimitives(Schema);
var NamespaceToClasses = new Dictionary <String, List <List <String> > >();
void AddClass(String ClassNamespaceName, IEnumerable <String> ClassContent)
{
if (!NamespaceToClasses.ContainsKey(ClassNamespaceName))
{
NamespaceToClasses.Add(ClassNamespaceName, new List <List <String> >());
}
NamespaceToClasses[ClassNamespaceName].Add(ClassContent.ToList());
}
foreach (var c in Schema.Types)
{
if (c.OnPrimitive)
{
continue;
}
else if (c.OnAlias)
{
AddClass(c.NamespaceName(), Alias(c.Alias));
}
else if (c.OnRecord)
{
AddClass(c.NamespaceName(), Record(c.Record));
}
else if (c.OnTaggedUnion)
{
AddClass(c.NamespaceName(), TaggedUnion(c.TaggedUnion));
}
else if (c.OnEnum)
{
AddClass(c.NamespaceName(), Enum(c.Enum));
}
else if (c.OnClientCommand)
{
}
else if (c.OnServerCommand)
{
}
else
{
throw new InvalidOperationException();
}
}
if (NamespaceToClasses.Count > 1)
{
throw new NotSupportedException("PythonMultipleNamespace"); //Python不支持nested class import
}
var Classes = NamespaceToClasses.Select(p => p.Value.Join(new String[] { "" }));
return((new List <List <String> > {
Primitives
}).Concat(Classes).Join(new String[] { "" }).ToList());
}
public List <String> GetTypes(Schema Schema)
{
var NamespaceName = Schema.Types.Concat(Schema.TypeRefs).Where(t => !t.OnPrimitive).FirstOrDefault()?.NamespaceName() ?? "";
var Primitives = GetPrimitives(Schema);
var NamespaceToClasses = new Dictionary <String, List <List <String> > >();
void AddClass(String ClassNamespaceName, IEnumerable <String> ClassContent)
{
if (!NamespaceToClasses.ContainsKey(ClassNamespaceName))
{
NamespaceToClasses.Add(ClassNamespaceName, new List <List <String> >());
}
NamespaceToClasses[ClassNamespaceName].Add(ClassContent.ToList());
}
AddClass(NamespaceName, Streams());
AddClass(NamespaceName, BinaryTranslator(Schema, NamespaceName));
if (NamespaceToClasses.Count > 1)
{
throw new NotSupportedException("PythonMultipleNamespace"); //Python不支持nested class import
}
var Classes = NamespaceToClasses.Select(p => p.Value.Join(new String[] { "" }));
return((new List <List <String> > {
Primitives
}).Concat(Classes).Join(new String[] { "" }).ToList());
}
public List <String> GetTypes(Schema Schema, String NamespaceName)
{
var Primitives = GetPrimitives(Schema);
var NamespaceToClasses = new List <KeyValuePair <String, List <List <String> > > >();
void AddClass(String ClassNamespaceName, IEnumerable <String> ClassContent)
{
if ((NamespaceToClasses.Count > 0) && (NamespaceToClasses[NamespaceToClasses.Count - 1].Key == ClassNamespaceName))
{
NamespaceToClasses[NamespaceToClasses.Count - 1].Value.Add(ClassContent.ToList());
}
else
{
NamespaceToClasses.Add(new KeyValuePair <String, List <List <String> > >(ClassNamespaceName, new List <List <String> > {
ClassContent.ToList()
}));
}
}
AddClass(NamespaceName, Streams());
AddClass(NamespaceName, BinaryTranslator(Schema, NamespaceName));
var Commands = Schema.Types.Where(t => t.OnClientCommand || t.OnServerCommand).ToList();
if (Commands.Count > 0)
{
var SchemaClosureGenerator = Schema.GetSchemaClosureGenerator();
var Hash = SchemaClosureGenerator.GetSubSchema(Schema.Types.Where(t => (t.OnClientCommand || t.OnServerCommand) && t.Version() == ""), new List <TypeSpec> {
}).GetNonattributed().Hash();
if (WithServer)
{
AddClass(NamespaceName, BinarySerializationServer(Hash, Commands, SchemaClosureGenerator, NamespaceName));
}
if (WithClient)
{
AddClass(NamespaceName, IBinarySender());
AddClass(NamespaceName, BinarySerializationClient(Hash, Commands, SchemaClosureGenerator, NamespaceName));
}
}
var Classes = NamespaceToClasses.Select(p => WrapNamespace(p.Key, p.Value.Join(new String[] { "" })));
return((new List <List <String> > {
Primitives
}).Concat(Classes).Join(new String[] { "" }).ToList());
}
public List <String> GetTypes(Schema Schema, String NamespaceName)
{
var Primitives = GetPrimitives(Schema);
var NamespaceToClasses = new Dictionary <String, List <List <String> > >();
void AddClass(String ClassNamespaceName, IEnumerable <String> ClassContent)
{
if (!NamespaceToClasses.ContainsKey(ClassNamespaceName))
{
NamespaceToClasses.Add(ClassNamespaceName, new List <List <String> >());
}
NamespaceToClasses[ClassNamespaceName].Add(ClassContent.ToList());
}
var Commands = Schema.Types.Where(t => t.OnClientCommand || t.OnServerCommand).ToList();
if (Commands.Count > 0)
{
var SchemaClosureGenerator = Schema.GetSchemaClosureGenerator();
var Hash = SchemaClosureGenerator.GetSubSchema(Schema.Types.Where(t => (t.OnClientCommand || t.OnServerCommand) && t.Version() == ""), new List <TypeSpec> {
}).GetNonattributed().Hash();
AddClass(NamespaceName, JsonSerializationServer(Hash, Commands, SchemaClosureGenerator, NamespaceName));
AddClass(NamespaceName, IJsonSender());
AddClass(NamespaceName, JsonSerializationClient(Hash, Commands, SchemaClosureGenerator, NamespaceName));
AddClass(NamespaceName, JsonLogAspectWrapper(Commands, NamespaceName));
}
AddClass(NamespaceName, JsonTranslator(Schema, NamespaceName));
var Classes = NamespaceToClasses.Select(p => Inner.WrapNamespace(p.Key, p.Value.Join(new String[] { "" })));
return((new List <List <String> > {
Primitives
}).Concat(Classes).Join(new String[] { "" }).ToList());
}
public List <String> GetTypes(Schema Schema, String NamespaceName)
{
var Primitives = GetPrimitives(Schema);
var NamespaceToClasses = new Dictionary <String, List <List <String> > >();
void AddClass(String ClassNamespaceName, IEnumerable <String> ClassContent)
{
if (!NamespaceToClasses.ContainsKey(ClassNamespaceName))
{
NamespaceToClasses.Add(ClassNamespaceName, new List <List <String> >());
}
NamespaceToClasses[ClassNamespaceName].Add(ClassContent.ToList());
}
foreach (var c in Schema.Types)
{
if (c.OnPrimitive)
{
if (c.VersionedName() == "Unit")
{
AddClass(c.NamespaceName(), Primitive_Unit());
}
else if (c.VersionedName() == "Optional")
{
AddClass(c.NamespaceName(), Primitive_Optional());
}
else
{
continue;
}
}
else if (c.OnAlias)
{
AddClass(c.NamespaceName(), Alias(c.Alias));
}
else if (c.OnRecord)
{
AddClass(c.NamespaceName(), Record(c.Record));
}
else if (c.OnTaggedUnion)
{
AddClass(c.NamespaceName(), TaggedUnion(c.TaggedUnion));
}
else if (c.OnEnum)
{
AddClass(c.NamespaceName(), Enum(c.Enum));
}
else if (c.OnClientCommand)
{
AddClass(c.NamespaceName(), ClientCommand(c.ClientCommand));
}
else if (c.OnServerCommand)
{
AddClass(c.NamespaceName(), ServerCommand(c.ServerCommand));
}
else
{
throw new InvalidOperationException();
}
}
var Commands = Schema.Types.Where(t => t.OnClientCommand || t.OnServerCommand).ToList();
if (Commands.Count > 0)
{
AddClass(NamespaceName, IApplicationServer(Commands, NamespaceName));
AddClass(NamespaceName, IApplicationClient(Commands, NamespaceName));
AddClass(NamespaceName, IEventPump(Commands, NamespaceName));
}
var Classes = NamespaceToClasses.Select(p => WrapNamespace(p.Key, p.Value.Join(new String[] { "" })));
return((new List <List <String> > {
Primitives
}).Concat(Classes).Join(new String[] { "" }).ToList());
}
public Dictionary <String, IEnumerable <String> > GetPackageFiles(Schema Schema, String NamespaceName)
{
var NamespaceToClasses = new Dictionary <String, List <KeyValuePair <String, List <String> > > >();
void AddClass(String ClassNamespaceName, String ClassName, IEnumerable <String> ClassContent)
{
if (!NamespaceToClasses.ContainsKey(ClassNamespaceName))
{
NamespaceToClasses.Add(ClassNamespaceName, new List <KeyValuePair <String, List <String> > >());
}
NamespaceToClasses[ClassNamespaceName].Add(new KeyValuePair <String, List <String> >(ClassName, ClassContent.ToList()));
}
var Commands = Schema.Types.Where(t => t.OnClientCommand || t.OnServerCommand).Where(t => t.Version() == "").ToList();
if (Commands.Count > 0)
{
var SchemaClosureGenerator = Schema.GetSchemaClosureGenerator();
var Hash = SchemaClosureGenerator.GetSubSchema(Schema.Types.Where(t => (t.OnClientCommand || t.OnServerCommand) && t.Version() == ""), new List <TypeSpec> {
}).GetNonattributed().Hash();
AddClass(NamespaceName, "IJsonSender", IJsonSender());
AddClass(NamespaceName, "JsonSerializationClient", JsonSerializationClient(Hash, Commands, SchemaClosureGenerator, NamespaceName));
}
AddClass(NamespaceName, "JsonTranslator", JsonTranslator(Schema, NamespaceName));
return(NamespaceToClasses.SelectMany(p => p.Value.Select(v => new KeyValuePair <String, IEnumerable <String> >(String.Join("/", p.Key.Split('.').Where(NamespacePart => NamespacePart != "").Select(NamespacePart => LowercaseCamelize(NamespacePart)).Concat(new String[] { v.Key })), WrapModule(p.Key, Schema.Imports, v.Value)))).ToDictionary(p => p.Key, p => p.Value));
}
public Dictionary <String, IEnumerable <String> > GetPackageFiles(Schema Schema, String NamespaceName)
{
var NamespaceToClasses = new Dictionary <String, List <KeyValuePair <String, List <String> > > >();
void AddClass(String ClassNamespaceName, String ClassName, IEnumerable <String> ClassContent)
{
if (!NamespaceToClasses.ContainsKey(ClassNamespaceName))
{
NamespaceToClasses.Add(ClassNamespaceName, new List <KeyValuePair <String, List <String> > >());
}
NamespaceToClasses[ClassNamespaceName].Add(new KeyValuePair <String, List <String> >(ClassName, ClassContent.ToList()));
}
foreach (var c in Schema.Types)
{
if (c.OnPrimitive)
{
if (c.VersionedName() == "Unit")
{
AddClass(c.NamespaceName(), "Unit", Primitive_Unit());
}
else if (c.VersionedName() == "Set")
{
AddClass(c.NamespaceName(), "Set", Primitive_Set());
}
else
{
var p = c.Primitive;
if (PrimitiveMapping.ContainsKey(p.VersionedName()))
{
var Name = p.VersionedName();
var PlatformName = PrimitiveMapping[Name];
if (Name != PlatformName && p.GenericParameters.Count() == 0 && PlatformName != "Error")
{
AddClass(c.NamespaceName(), Name, Primitive(Name, PlatformName));
}
else
{
continue;
}
}
}
}
else if (c.OnAlias)
{
AddClass(c.NamespaceName(), c.DefinitionName(), Alias(c.Alias));
}
else if (c.OnRecord)
{
AddClass(c.NamespaceName(), c.DefinitionName(), Record(c.Record));
}
else if (c.OnTaggedUnion)
{
AddClass(c.NamespaceName(), c.DefinitionName(), TaggedUnion(c.TaggedUnion));
}
else if (c.OnEnum)
{
AddClass(c.NamespaceName(), c.DefinitionName(), Enum(c.Enum));
}
else if (c.OnClientCommand)
{
var tc = c.ClientCommand;
var RequestRef = GetSuffixedTypeRef(tc.Name, tc.Version, "Request");
var Request = new RecordDef {
Name = RequestRef.Name, Version = RequestRef.Version, GenericParameters = new List <VariableDef> {
}, Fields = tc.OutParameters, Attributes = tc.Attributes, Description = tc.Description
};
var ReplyRef = GetSuffixedTypeRef(tc.Name, tc.Version, "Reply");
var Reply = new TaggedUnionDef {
Name = ReplyRef.Name, Version = ReplyRef.Version, GenericParameters = new List <VariableDef> {
}, Alternatives = tc.InParameters, Attributes = tc.Attributes, Description = tc.Description
};
AddClass(c.NamespaceName(), Request.DefinitionName(), Record(Request));
AddClass(c.NamespaceName(), Reply.DefinitionName(), TaggedUnion(Reply));
}
else if (c.OnServerCommand)
{
var tc = c.ServerCommand;
var EventRef = GetSuffixedTypeRef(tc.Name, tc.Version, "Event");
var Event = new RecordDef {
Name = EventRef.Name, Version = EventRef.Version, GenericParameters = new List <VariableDef> {
}, Fields = tc.OutParameters, Attributes = tc.Attributes, Description = tc.Description
};
AddClass(c.NamespaceName(), Event.DefinitionName(), Record(Event));
}
else
{
throw new InvalidOperationException();
}
}
var scg = Schema.GetSchemaClosureGenerator();
var sc = scg.GetClosure(Schema.TypeRefs.Concat(Schema.Types), new List <TypeSpec> {
});
var Tuples = sc.TypeSpecs.Where(t => t.OnTuple).ToList();
foreach (var t in Tuples)
{
AddClass(NamespaceName, t.SimpleName(NamespaceName), Tuple(t, NamespaceName));
}
var Commands = Schema.Types.Where(t => t.OnClientCommand || t.OnServerCommand).Where(t => t.Version() == "").ToList();
if (Commands.Count > 0)
{
AddClass(NamespaceName, "IApplicationClient", IApplicationClient(Commands, NamespaceName));
}
return(NamespaceToClasses.SelectMany(p => p.Value.Select(v => new KeyValuePair <String, IEnumerable <String> >(String.Join("/", p.Key.Split('.').Where(NamespacePart => NamespacePart != "").Select(NamespacePart => LowercaseCamelize(NamespacePart)).Concat(new String[] { v.Key })), WrapModule(p.Key, Schema.Imports, v.Value)))).ToDictionary(p => p.Key, p => p.Value));
}
public List <String> GetTypes(Schema Schema, String NamespaceName)
{
var Primitives = GetPrimitives(Schema);
var NamespaceToClasses = new List <KeyValuePair <String, List <List <String> > > >();
void AddClass(String ClassNamespaceName, IEnumerable <String> ClassContent)
{
if ((NamespaceToClasses.Count > 0) && (NamespaceToClasses[NamespaceToClasses.Count - 1].Key == ClassNamespaceName))
{
NamespaceToClasses[NamespaceToClasses.Count - 1].Value.Add(ClassContent.ToList());
}
else
{
NamespaceToClasses.Add(new KeyValuePair <String, List <List <String> > >(ClassNamespaceName, new List <List <String> > {
ClassContent.ToList()
}));
}
}
foreach (var c in Schema.Types)
{
if (c.OnEnum)
{
AddClass(c.NamespaceName(), Enum(c.Enum));
}
else
{
continue;
}
}
foreach (var c in Schema.Types)
{
if (c.OnPrimitive)
{
continue;
}
else if (c.OnEnum)
{
continue;
}
AddClass(c.NamespaceName(), GetTypePredefinition(c));
}
foreach (var c in Schema.Types)
{
if (c.OnAlias)
{
AddClass(c.NamespaceName(), Alias(c.Alias));
}
else
{
continue;
}
}
foreach (var c in Schema.Types)
{
if (c.OnEnum)
{
AddClass("std", EnumFunctor(c.Enum));
}
else
{
continue;
}
}
foreach (var c in Schema.Types)
{
if (c.OnPrimitive)
{
continue;
}
else if (c.OnAlias)
{
continue;
}
else if (c.OnRecord)
{
AddClass(c.NamespaceName(), Record(c.Record));
}
else if (c.OnTaggedUnion)
{
AddClass(c.NamespaceName(), TaggedUnion(c.TaggedUnion));
}
else if (c.OnEnum)
{
continue;
}
else if (c.OnClientCommand)
{
AddClass(c.NamespaceName(), ClientCommand(c.ClientCommand));
}
else if (c.OnServerCommand)
{
AddClass(c.NamespaceName(), ServerCommand(c.ServerCommand));
}
else
{
throw new InvalidOperationException();
}
}
var Commands = Schema.Types.Where(t => t.OnClientCommand || t.OnServerCommand).ToList();
if (Commands.Count > 0)
{
AddClass(NamespaceName, IApplicationServer(Commands, NamespaceName));
AddClass(NamespaceName, IApplicationClient(Commands, NamespaceName));
AddClass(NamespaceName, IEventPump(Commands, NamespaceName));
}
var Classes = NamespaceToClasses.Select(p => WrapNamespace(p.Key, p.Value.Join(new String[] { "" })));
return((new List <List <String> > {
Primitives
}).Concat(Classes).Join(new String[] { "" }).ToList());
}
public Dictionary <String, IEnumerable <String> > GetPackageFiles(Schema Schema, String NamespaceName)
{
var NamespaceToClasses = new Dictionary <String, List <KeyValuePair <String, List <String> > > >();
void AddClass(String ClassNamespaceName, String ClassName, IEnumerable <String> ClassContent)
{
if (!NamespaceToClasses.ContainsKey(ClassNamespaceName))
{
NamespaceToClasses.Add(ClassNamespaceName, new List <KeyValuePair <String, List <String> > >());
}
NamespaceToClasses[ClassNamespaceName].Add(new KeyValuePair <String, List <String> >(ClassName, ClassContent.ToList()));
}
AddClass(NamespaceName, "IReadableStream", IReadableStream());
AddClass(NamespaceName, "IWritableStream", IWritableStream());
AddClass(NamespaceName, "BinaryTranslator", BinaryTranslator(Schema, NamespaceName));
var NamespaceParts = NamespaceName.Split('.');
var Imports = new List <String>();
for (int k = 1; k < NamespaceParts.Length; k += 1)
{
Imports.Add(String.Join(".", NamespaceParts.Take(k).Select(p => LowercaseCamelize(p))) + ".*");
}
return(NamespaceToClasses.SelectMany(p => p.Value.Select(v => new KeyValuePair <String, IEnumerable <String> >(String.Join("/", p.Key.Split('.').Where(NamespacePart => NamespacePart != "").Select(NamespacePart => LowercaseCamelize(NamespacePart)).Concat(new String[] { v.Key })), WrapModule(p.Key, Imports.Concat(Schema.Imports).ToList(), v.Value)))).ToDictionary(p => p.Key, p => p.Value));
}
public Dictionary <String, IEnumerable <String> > GetPackageFiles(Schema Schema, String NamespaceName)
{
var NamespaceToClasses = new Dictionary <String, List <KeyValuePair <String, List <String> > > >();
void AddClass(String ClassNamespaceName, String ClassName, IEnumerable <String> ClassContent)
{
if (!NamespaceToClasses.ContainsKey(ClassNamespaceName))
{
NamespaceToClasses.Add(ClassNamespaceName, new List <KeyValuePair <String, List <String> > >());
}
NamespaceToClasses[ClassNamespaceName].Add(new KeyValuePair <String, List <String> >(ClassName, ClassContent.ToList()));
}
AddClass("niveum.lang", "Record", Attribute_Record());
AddClass("niveum.lang", "Alias", Attribute_Alias());
AddClass("niveum.lang", "TaggedUnion", Attribute_TaggedUnion());
AddClass("niveum.lang", "Tag", Attribute_Tag());
AddClass("niveum.lang", "Tuple", Attribute_Tuple());
AddClass("niveum.lang", "Unit", Primitive_Unit());
foreach (var c in Schema.Types)
{
if (c.OnPrimitive)
{
continue;
}
else if (c.OnAlias)
{
AddClass(c.NamespaceName(), c.DefinitionName(), Alias(c.Alias));
}
else if (c.OnRecord)
{
AddClass(c.NamespaceName(), c.DefinitionName(), Record(c.Record));
}
else if (c.OnTaggedUnion)
{
var tu = c.TaggedUnion;
var TagName = GetSuffixedTypeName(tu.Name, tu.Version, "Tag", tu.NamespaceName());
AddClass(c.NamespaceName(), TagName, TaggedUnionTag(c.TaggedUnion));
AddClass(c.NamespaceName(), c.DefinitionName(), TaggedUnion(c.TaggedUnion));
}
else if (c.OnEnum)
{
AddClass(c.NamespaceName(), c.DefinitionName(), Enum(c.Enum));
}
else if (c.OnClientCommand)
{
var tc = c.ClientCommand;
var RequestRef = GetSuffixedTypeRef(tc.Name, tc.Version, "Request");
var Request = new RecordDef {
Name = RequestRef.Name, Version = RequestRef.Version, GenericParameters = new List <VariableDef> {
}, Fields = tc.OutParameters, Attributes = tc.Attributes, Description = tc.Description
};
var ReplyRef = GetSuffixedTypeRef(tc.Name, tc.Version, "Reply");
var Reply = new TaggedUnionDef {
Name = ReplyRef.Name, Version = ReplyRef.Version, GenericParameters = new List <VariableDef> {
}, Alternatives = tc.InParameters, Attributes = tc.Attributes, Description = tc.Description
};
var ReplyTagName = GetSuffixedTypeName(Reply.Name, Reply.Version, "Tag", tc.NamespaceName());
AddClass(c.NamespaceName(), Request.DefinitionName(), Record(Request));
AddClass(c.NamespaceName(), ReplyTagName, TaggedUnionTag(Reply));
AddClass(c.NamespaceName(), Reply.DefinitionName(), TaggedUnion(Reply));
}
else if (c.OnServerCommand)
{
var tc = c.ServerCommand;
var EventRef = GetSuffixedTypeRef(tc.Name, tc.Version, "Event");
var Event = new RecordDef {
Name = EventRef.Name, Version = EventRef.Version, GenericParameters = new List <VariableDef> {
}, Fields = tc.OutParameters, Attributes = tc.Attributes, Description = tc.Description
};
AddClass(c.NamespaceName(), Event.DefinitionName(), Record(Event));
}
else
{
throw new InvalidOperationException();
}
}
var scg = Schema.GetSchemaClosureGenerator();
var sc = scg.GetClosure(Schema.TypeRefs.Concat(Schema.Types), new List <TypeSpec> {
});
var Tuples = sc.TypeSpecs.Where(t => t.OnTuple).ToList();
var GenericTypeSpecs = sc.TypeSpecs.Where(t => t.OnGenericTypeSpec).ToList();
foreach (var t in Tuples)
{
AddClass(NamespaceName, t.SimpleName(NamespaceName), Tuple(t, NamespaceName));
}
var GenericOptionalTypes = Schema.TypeRefs.Concat(Schema.Types).Where(t => t.NameMatches("Optional")).ToList();
if (GenericOptionalTypes.Count > 0)
{
var GenericOptionalType = new TaggedUnionDef
{
Name = new List <String> {
"Optional"
},
Version = "",
GenericParameters = new List <VariableDef> {
new VariableDef {
Name = "T", Type = TypeSpec.CreateTypeRef(new TypeRef {
Name = new List <String> {
"Type"
}, Version = ""
}), Attributes = new List <KeyValuePair <String, List <String> > > {
}, Description = ""
}
},
Alternatives = new List <VariableDef>
{
new VariableDef {
Name = "None", Type = TypeSpec.CreateTypeRef(new TypeRef {
Name = new List <String> {
"Unit"
}, Version = ""
}), Attributes = new List <KeyValuePair <String, List <String> > > {
}, Description = ""
},
new VariableDef {
Name = "Some", Type = TypeSpec.CreateGenericParameterRef("T"), Attributes = new List <KeyValuePair <String, List <String> > > {
}, Description = ""
}
},
Attributes = new List <KeyValuePair <String, List <String> > > {
},
Description = ""
};
{
var TagName = GetSuffixedTypeName(GenericOptionalType.Name, GenericOptionalType.Version, "Tag", GenericOptionalType.NamespaceName());
AddClass(NamespaceName, TagName, TaggedUnionTag(GenericOptionalType));
}
foreach (var gts in GenericTypeSpecs)
{
if (gts.GenericTypeSpec.TypeSpec.OnTypeRef && gts.GenericTypeSpec.TypeSpec.TypeRef.NameMatches("Optional") && gts.GenericTypeSpec.ParameterValues.Count == 1)
{
var ElementType = gts.GenericTypeSpec.ParameterValues.Single();
var Name = "Opt" + ElementType.SimpleName(NamespaceName);
var Alternatives = GenericOptionalType.Alternatives.Select(a => new VariableDef {
Name = a.Name, Type = a.Type.OnGenericParameterRef ? ElementType : a.Type, Attributes = a.Attributes, Description = a.Description
}).ToList();
var tu = new TaggedUnionDef {
Name = new List <String> {
Name
}, Version = "", GenericParameters = new List <VariableDef> {
}, Alternatives = Alternatives, Attributes = GenericOptionalType.Attributes, Description = GenericOptionalType.Description
};
AddClass(NamespaceName, Name, TaggedUnion(tu, "OptionalTag"));
}
}
}
return(NamespaceToClasses.SelectMany(p => p.Value.Select(v => new KeyValuePair <String, IEnumerable <String> >(String.Join("/", p.Key.Split('.').Where(NamespacePart => NamespacePart != "").Select(NamespacePart => LowercaseCamelize(NamespacePart)).Concat(new String[] { v.Key })), WrapModule(p.Key, Schema.Imports, v.Value)))).ToDictionary(p => p.Key, p => p.Value));
}
