public void Begin(MagicNumber tagClass, StringId classStringId, TagLayoutGuess layout)
{
if (_writer != null)
throw new InvalidOperationException("Cannot begin a new tag while another is still in progress");
// Convert the class name to a pascal case string and use that as the file name
var name = _stringIds.GetString(classStringId);
if (string.IsNullOrEmpty(name))
throw new InvalidOperationException("Unable to look up the tag class name");
name = ConvertToPascalCase(name);
var path = Path.Combine(_outDir, name + ".cs");
_writer = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write));
// Write the C# header
_writer.WriteLine("using System;");
_writer.WriteLine("using System.Collections.Generic;");
_writer.WriteLine("using System.Linq;");
_writer.WriteLine("using System.Text;");
_writer.WriteLine("using System.Threading.Tasks;");
_writer.WriteLine("using HaloOnlineTagTool.Serialization;");
_writer.WriteLine();
_writer.WriteLine("namespace HaloOnlineTagTool.TagStructures");
_writer.WriteLine("{");
_builder = new ClassBuilder(_writer, 1, name);
_builder.Begin(tagClass, classStringId, layout);
}
public static void WritePrivateConstructor(string className, ClassBuilder cb)
{
using (cb.BeginNest("private " + className + "Metadata()"))
{
cb.AppendLine("// Metadata classes are not meant to be instantiated.");
}
}
public void Validate()
{
var metaPopulation = new MetaPopulation();
var domain = new Domain(metaPopulation, Guid.NewGuid()) { Name = "Domain" };
var c1 = new ClassBuilder(domain, Guid.NewGuid()).WithSingularName("C1").WithPluralName("C1s").Build();
var i1 = new InterfaceBuilder(domain, Guid.NewGuid()).WithSingularName("I1").WithPluralName("I1s").Build();
var i2 = new InterfaceBuilder(domain, Guid.NewGuid()).WithSingularName("I2").WithPluralName("I2s").Build();
Assert.IsTrue(metaPopulation.IsValid);
// class with interface
new InheritanceBuilder(domain, Guid.NewGuid()).WithSubtype(c1).WithSupertype(i1).Build();
var validation = metaPopulation.Validate();
Assert.IsFalse(validation.ContainsErrors);
// interface with interface
new InheritanceBuilder(domain, Guid.NewGuid()).WithSubtype(i1).WithSupertype(i2).Build();
validation = metaPopulation.Validate();
Assert.IsFalse(validation.ContainsErrors);
// Cyclic
var cycle = new InheritanceBuilder(domain, Guid.NewGuid()).WithSubtype(i2).WithSupertype(i1).Build();
validation = metaPopulation.Validate();
Assert.IsTrue(validation.ContainsErrors);
Assert.AreEqual(i1, validation.Errors[0].Source);
Assert.AreEqual(1, validation.Errors[0].Members.Length);
Assert.AreEqual("IComposite.Supertypes", validation.Errors[0].Members[0]);
Assert.AreEqual(ValidationKind.Cyclic, validation.Errors[0].Kind);
}
public void Composites()
{
var metaPopulation = new MetaPopulation();
var domain = new Domain(metaPopulation, Guid.NewGuid());
var superdomain = new Domain(metaPopulation, Guid.NewGuid());
domain.AddDirectSuperdomain(superdomain);
Assert.AreEqual(0, metaPopulation.Composites.Count());
var @class = new ClassBuilder(domain, Guid.NewGuid()).WithSingularName("Class").WithPluralName("Classes").Build();
Assert.AreEqual(1, metaPopulation.Composites.Count());
var superclass = new ClassBuilder(superdomain, Guid.NewGuid()).WithSingularName("Superclass").WithPluralName("Superclasses").Build();
Assert.AreEqual(2, metaPopulation.Composites.Count());
var @interface = new InterfaceBuilder(domain, Guid.NewGuid()).WithSingularName("i1").WithPluralName("i1s").Build();
Assert.AreEqual(3, metaPopulation.Composites.Count());
var superinterface = new InterfaceBuilder(superdomain, Guid.NewGuid()).WithSingularName("i2").WithPluralName("i2s").Build();
Assert.AreEqual(4, metaPopulation.Composites.Count());
var unit = new UnitBuilder(domain, UnitIds.StringId).WithSingularName("AllorsString").WithPluralName("AllorsStrings").WithUnitTag(UnitTags.AllorsString).Build();
Assert.AreEqual(4, metaPopulation.Composites.Count());
var superunit = new UnitBuilder(domain, UnitIds.IntegerId).WithSingularName("AllorsInteger").WithPluralName("AllorsIntegers").WithUnitTag(UnitTags.AllorsString).Build();
Assert.AreEqual(4, metaPopulation.Composites.Count());
}
public SprocWriter(DatabaseStoredProcedure storedProcedure, string ns)
{
_namespace = ns;
_storedProcedure = storedProcedure;
_logic = new SprocLogic(_storedProcedure);
_sprocResultType = _logic.ResultType;
_cb = new ClassBuilder();
}
internal SprocResultWriter(DatabaseStoredProcedure storedProcedure, string ns, ClassBuilder classBuilder)
{
_namespace = ns;
_storedProcedure = storedProcedure;
_logic = new SprocLogic(_storedProcedure);
_resultClassName = _logic.ResultClassName;
_cb = classBuilder;
}
public void ClassBuilderCanGenerateObservableCollectionProperty()
{
var builder = new ClassBuilder(
new[] { typeof(ClassWithCollection) },
"Test"
);
Debug.Write(builder.ToString());
}
public FluentMappingWriter(DatabaseTable table, CodeWriterSettings codeWriterSettings, MappingNamer mappingNamer)
{
if (table == null) throw new ArgumentNullException("table");
if (mappingNamer == null) throw new ArgumentNullException("mappingNamer");
_codeWriterSettings = codeWriterSettings;
_mappingNamer = mappingNamer;
_table = table;
_cb = new ClassBuilder();
}
public override void WriteLayout(TagLayout layout, TextWriter writer)
{
WriteHeader(writer);
var name = NamingConvention.ToPascalCase(layout.Name);
var builder = new ClassBuilder(writer, 1);
builder.Begin(name, layout.Size, 0, layout.GroupTag);
layout.Accept(builder);
builder.End();
WriteFooter(writer);
}
public void PluralName()
{
var company = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Company").WithPluralName("Companies").Build();
var person = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Person").WithPluralName("Persons").Build();
var companyPerson = new RelationTypeBuilder(this.Domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid())
.WithObjectTypes(company, person)
.WithMultiplicity(Multiplicity.ManyToOne)
.Build();
Assert.AreEqual("Companies", companyPerson.AssociationType.PluralName);
}
public void Supertypes()
{
var c1 = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("c1").WithPluralName("c1s").Build();
var c2 = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("c1").WithPluralName("c1s").Build();
var i1 = new InterfaceBuilder(this.Domain, Guid.NewGuid()).WithSingularName("i1").WithPluralName("i1s").Build();
var i2 = new InterfaceBuilder(this.Domain, Guid.NewGuid()).WithSingularName("i2").WithPluralName("i2s").Build();
var i12 = new InterfaceBuilder(this.Domain, Guid.NewGuid()).WithSingularName("i1").WithPluralName("i1s").Build();
Assert.AreEqual(0, c1.Supertypes.Count());
Assert.AreEqual(0, c2.Supertypes.Count());
Assert.AreEqual(0, i1.Supertypes.Count());
Assert.AreEqual(0, i2.Supertypes.Count());
Assert.AreEqual(0, i12.Supertypes.Count());
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c1).WithSupertype(i1).Build();
Assert.AreEqual(1, c1.Supertypes.Count());
Assert.Contains(i1, c1.Supertypes.ToList());
Assert.AreEqual(0, c2.Supertypes.Count());
Assert.AreEqual(0, i1.Supertypes.Count());
Assert.AreEqual(0, i2.Supertypes.Count());
Assert.AreEqual(0, i12.Supertypes.Count());
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(i1).WithSupertype(i12).Build();
Assert.AreEqual(2, c1.Supertypes.Count());
Assert.Contains(i1, c1.Supertypes.ToList());
Assert.Contains(i12, c1.Supertypes.ToList());
Assert.AreEqual(0, c2.Supertypes.Count());
Assert.AreEqual(1, i1.Supertypes.Count());
Assert.Contains(i12, i1.Supertypes.ToList());
Assert.AreEqual(0, i2.Supertypes.Count());
Assert.AreEqual(0, i12.Supertypes.Count());
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(i2).WithSupertype(i12).Build();
Assert.AreEqual(2, c1.Supertypes.Count());
Assert.Contains(i1, c1.Supertypes.ToList());
Assert.Contains(i12, c1.Supertypes.ToList());
Assert.AreEqual(0, c2.Supertypes.Count());
Assert.AreEqual(1, i1.Supertypes.Count());
Assert.Contains(i12, i1.Supertypes.ToList());
Assert.AreEqual(1, i2.Supertypes.Count());
Assert.Contains(i12, i2.Supertypes.ToList());
Assert.AreEqual(0, i12.Supertypes.Count());
}
public void ExclusiveLeafClass()
{
var c1 = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("c1").WithPluralName("c1s").Build();
var c2 = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("c2").WithPluralName("c2s").Build();
var i1 = new InterfaceBuilder(this.Domain, Guid.NewGuid()).WithSingularName("i1").WithPluralName("i1s").Build();
var i2 = new InterfaceBuilder(this.Domain, Guid.NewGuid()).WithSingularName("i2").WithPluralName("i2s").Build();
Assert.AreEqual(c1, c1.ExclusiveLeafClass);
Assert.AreEqual(c2, c2.ExclusiveLeafClass);
Assert.IsNull(i1.ExclusiveLeafClass);
Assert.IsNull(i2.ExclusiveLeafClass);
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c1).WithSupertype(i1).Build();
Assert.AreEqual(c1, c1.ExclusiveLeafClass);
Assert.AreEqual(c2, c2.ExclusiveLeafClass);
Assert.AreEqual(c1, i1.ExclusiveLeafClass);
Assert.IsNull(i2.ExclusiveLeafClass);
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c2).WithSupertype(i2).Build();
Assert.AreEqual(c1, c1.ExclusiveLeafClass);
Assert.AreEqual(c2, c2.ExclusiveLeafClass);
Assert.AreEqual(c1, i1.ExclusiveLeafClass);
Assert.AreEqual(c2, i2.ExclusiveLeafClass);
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c1).WithSupertype(i2).Build();
Assert.AreEqual(c1, c1.ExclusiveLeafClass);
Assert.AreEqual(c2, c2.ExclusiveLeafClass);
Assert.AreEqual(c1, i1.ExclusiveLeafClass);
Assert.IsNull(i2.ExclusiveLeafClass);
}
public void Defaults()
{
this.Populate();
var thisType = new ClassBuilder(this.Domain, Guid.NewGuid()).Build();
thisType.SingularName = "ThisType";
thisType.PluralName = "TheseTypes";
var thatType = new ClassBuilder(this.Domain, Guid.NewGuid()).Build();
thatType.SingularName = "ThatType";
thatType.PluralName = "ThatTypes";
var supertype = new InterfaceBuilder(this.Domain, Guid.NewGuid()).Build();
supertype.SingularName = "Supertype";
supertype.PluralName = "Supertypes";
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(thisType).WithSupertype(supertype).Build();
var relationTypeWhereAssociation = new RelationTypeBuilder(this.Domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()).Build();
relationTypeWhereAssociation.AssociationType.ObjectType = thisType;
relationTypeWhereAssociation.RoleType.ObjectType = thatType;
var relationTypeWhereRole = new RelationTypeBuilder(this.Domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()).Build();
relationTypeWhereRole.AssociationType.ObjectType = thatType;
relationTypeWhereRole.RoleType.ObjectType = thisType;
relationTypeWhereRole.RoleType.AssignedSingularName = "to";
relationTypeWhereRole.RoleType.AssignedPluralName = "tos";
Assert.IsTrue(this.MetaPopulation.IsValid);
}
public void SingularPropertyName()
{
var company = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Company").WithPluralName("Companies").Build();
var person = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Person").WithPluralName("Persons").Build();
var companyPerson = new RelationTypeBuilder(this.Domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid())
.WithObjectTypes(company, person)
.Build();
Assert.AreEqual("Person", companyPerson.RoleType.SingularPropertyName);
companyPerson.RoleType.AssignedPluralName = "Personen";
Assert.AreEqual("Person", companyPerson.RoleType.SingularPropertyName);
companyPerson.RoleType.AssignedSingularName = "Persoon";
Assert.AreEqual("Persoon", companyPerson.RoleType.SingularPropertyName);
var @interfaceWithoutLeafClass = new InterfaceBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Interface").WithPluralName("Interfaces").Build();
var interfaceWithoutLeafClassPerson = new RelationTypeBuilder(this.Domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid())
.WithObjectTypes(@interfaceWithoutLeafClass, person)
.Build();
Assert.AreEqual("Person", interfaceWithoutLeafClassPerson.RoleType.SingularPropertyName);
interfaceWithoutLeafClassPerson.RoleType.AssignedPluralName = "Personen";
Assert.AreEqual("Person", interfaceWithoutLeafClassPerson.RoleType.SingularPropertyName);
interfaceWithoutLeafClassPerson.RoleType.AssignedSingularName = "Persoon";
Assert.AreEqual("Persoon", interfaceWithoutLeafClassPerson.RoleType.SingularPropertyName);
}
public void Visit(TagBlockTagLayoutField field)
{
string className;
if (field.ElementLayout.Name != field.Name)
className = MakeName(field.ElementLayout.Name);
else
className = MakeName(field.ElementLayout.Name + " Block");
using (var blockWriter = new StringWriter())
{
var blockBuilder = new ClassBuilder(blockWriter, _indentLevel);
blockBuilder.Begin(className, field.ElementLayout.Size, field.DataAlign, field.ElementLayout.GroupTag);
field.ElementLayout.Accept(blockBuilder);
blockBuilder.End();
_subBlocks.Enqueue(blockWriter.ToString());
}
var blockType = string.Format("List<{0}>", className);
AddElement(blockType, field.Name);
}
public void Visit(TagBlockTagLayoutField field)
{
var className = MakeName(field.ElementLayout.Name);
_writer.WriteLine("{0}struct {1};", _indent, className);
using (var blockWriter = new StringWriter())
{
var blockBuilder = new ClassBuilder(blockWriter, _indentLevel);
blockBuilder.Begin(className, field.ElementLayout.Size, field.ElementLayout.GroupTag);
field.ElementLayout.Accept(blockBuilder);
blockBuilder.End();
_subBlocks.Enqueue(blockWriter.ToString());
}
var type = string.Format("TagBlock<{0}>", className);
AddElement(type, field.Name);
}
protected override void BuildClasses(ClassBuilder builder)
{
builder.Append("snackbar-body");
base.BuildClasses(builder);
}
public TypeProcessor(ClassBuilder builder, INamedTypeSymbol type, string access)
{
_builder = builder;
_type = type ?? throw new ArgumentNullException(nameof(type));
_access = access;
}
public void 完整的测试()
{
ClassBuilder builder = CodeSyntax.CreateClass("Test")
.WithAccess(NamespaceAccess.Public)
.WithGeneric(b =>
{
b.WithCreate("T1").WithStruct()
.WithCreate("T2").WithClass()
.WithCreate("T3").WithNotnull()
.WithCreate("T4").WithUnmanaged()
.WithCreate("T5").WithNotnull()
.WithCreate("T6").WithBase("Enum")
.WithCreate("T7").WithBase("IEnumerable<int>")
.WithCreate("T8").WithTo("T2")
.WithCreate("T9").WithClass().WithNew()
.WithCreate("T10").WithInterface("IEnumerator<int>", "IEnumerable<int>").WithNew();
})
.WithField("str", b =>
{
b.WithAccess(MemberAccess.Public)
.WithKeyword(FieldKeyword.Readonly)
.WithType("string");
})
.WithProperty("Get", b =>
{
b.WithAccess(MemberAccess.Public)
.WithType("string")
.WithGetSet("get { return str; }", string.Empty);
})
.WithMethod("Method", b =>
{
b.WithAccess(MemberAccess.Public)
.WithReturnType("string")
.WithBlock(@"return """";");
});
var result = builder.ToFormatCode();
#if Log
_tempOutput.WriteLine(result.WithUnixEOL());
#endif
Assert.Equal(@"public class Test<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
where T1 : struct where T2 : class where T3 : notnull where T4 : unmanaged where T5 : notnull where T6 : Enum where T7 : IEnumerable<int> where T8 : T2 where T9 : class, new()
where T10 : IEnumerator<int>, IEnumerable<int>, new()
{
public readonly string str;
public string Get
{
get
{
return str;
}
}
public string Method()
{
return """";
}
}", result.WithUnixEOL());
}
public override void Build(RuntimeState state, ClassBuilder builder)
{
builder.AddField(name.name);
}
protected override void BuildClasses(ClassBuilder builder)
{
builder.Append(ClassProvider.FieldJustifyContent(JustifyContent.Between));
base.BuildClasses(builder);
}
static void Main(string[] args)
{
/*
* 在此之前，你需要右键，选择工程文件，在你的.csproj里面
*
* 写上这样一句浪漫的话：
*
* <PreserveCompilationContext>true</PreserveCompilationContext>
*/
var delegateAction = MethodBuilder.NewMethod
.Using(typeof(Console))
.Param <string>("str1")
.Param <string>("str2")
.Body(@"
string result = str1 +"" ""+ str2;
Console.WriteLine(result);
")
.Return()
.Create();
((Action <string, string>)delegateAction)("Hello", "World!");
var delegateAction2 = MethodBuilder.NewMethod
.Using(typeof(Console))
.Param <string>("str1")
.Param <string>("str2")
.Body(@"
string result = str1 +"" ""+ str2;
Console.WriteLine(result);
")
.Return()
.Create <Action <string, string> >();
delegateAction2("Hello", "World!");
string text = @"using System;
using System.Collections;
using System.Linq;
using System.Text;
namespace HelloWorld
{
public class Test
{
public Test(){
Name=""111"";
}
public string Name;
public int Age{get;set;}
}
}";
//根据脚本创建动态类
Type type = ClassBuilder.GetType(text);
//创建动态类实例代理
DynamicInstance instance = new DynamicInstance(type);
if (instance["Name"].StringValue == "111")
{
//调用动态委托赋值
instance["Name"].StringValue = "222";
}
//调用动态类
Console.WriteLine(instance["Name"].StringValue);
//创建动态类实例代理
DynamicInstance <TestB> instance2 = new DynamicInstance <TestB>();
if (instance2["Name"].StringValue == "111")
{
//调用动态委托赋值
instance2["Name"].StringValue = "222";
}
//调用动态类
Console.WriteLine(instance2["Name"].StringValue);
Console.ReadKey();
}
public void ValidateDuplicateSingularName()
{
this.Populate();
var type = new ClassBuilder(this.Domain,Guid.NewGuid()).Build();
type.SingularName = "Type1";
type.PluralName = "XXX";
var anotherType = new ClassBuilder(this.Domain, Guid.NewGuid()).Build();
anotherType.SingularName = "Type1";
anotherType.PluralName = "YYY";
Assert.IsFalse(this.MetaPopulation.IsValid);
}
protected override void Generate(
CodeWriter writer,
ITypeDescriptor typeDescriptor,
out string fileName,
out string?path)
{
ComplexTypeDescriptor descriptor =
typeDescriptor as ComplexTypeDescriptor ??
throw new InvalidOperationException(
"A result data factory can only be generated for complex types");
fileName = CreateResultFactoryName(descriptor.RuntimeType.Name);
path = State;
ClassBuilder classBuilder =
ClassBuilder
.New()
.SetName(fileName)
.AddImplements(
TypeNames.IOperationResultDataFactory.WithGeneric(descriptor.RuntimeType));
ConstructorBuilder constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(descriptor.Name);
AddConstructorAssignedField(
TypeNames.IEntityStore,
_entityStore,
classBuilder,
constructorBuilder);
MethodCallBuilder returnStatement = MethodCallBuilder
.New()
.SetReturn()
.SetNew()
.SetMethodName(descriptor.RuntimeType.Name);
foreach (PropertyDescriptor property in descriptor.Properties)
{
returnStatement
.AddArgument(BuildMapMethodCall(_info, property));
}
IfBuilder ifHasCorrectType = IfBuilder
.New()
.SetCondition(
$"{_dataInfo} is {CreateResultInfoName(descriptor.RuntimeType.Name)} {_info}")
.AddCode(returnStatement);
classBuilder
.AddMethod("Create")
.SetAccessModifier(AccessModifier.Public)
.SetReturnType(descriptor.RuntimeType.Name)
.AddParameter(_dataInfo, b => b.SetType(TypeNames.IOperationResultDataInfo))
.AddParameter(
_snapshot,
b => b.SetDefault("null")
.SetType(TypeNames.IEntityStoreSnapshot.MakeNullable()))
.AddCode(
IfBuilder.New()
.SetCondition($"{_snapshot} is null")
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide(_snapshot)
.SetRighthandSide($"{_entityStore}.CurrentSnapshot")))
.AddEmptyLine()
.AddCode(ifHasCorrectType)
.AddEmptyLine()
.AddCode(
ExceptionBuilder
.New(TypeNames.ArgumentException)
.AddArgument(
$"\"{CreateResultInfoName(descriptor.RuntimeType.Name)} expected.\""));
var processed = new HashSet <string>();
AddRequiredMapMethods(
_info,
descriptor,
classBuilder,
constructorBuilder,
processed,
true);
classBuilder
.AddProperty("ResultType")
.SetType(TypeNames.Type)
.AsLambda($"typeof({descriptor.RuntimeType.Namespace}.{ descriptor.Implements[0]})")
.SetInterface(TypeNames.IOperationResultDataFactory);
classBuilder
.AddMethod("Create")
.SetInterface(TypeNames.IOperationResultDataFactory)
.SetReturnType(TypeNames.Object)
.AddParameter(_dataInfo, b => b.SetType(TypeNames.IOperationResultDataInfo))
.AddParameter(
_snapshot,
b => b.SetType(TypeNames.IEntityStoreSnapshot.MakeNullable()))
.AddCode(
MethodCallBuilder
.New()
.SetReturn()
.SetMethodName("Create")
.AddArgument(_dataInfo)
.AddArgument(_snapshot));
CodeFileBuilder
.New()
.SetNamespace(CreateStateNamespace(descriptor.RuntimeType.NamespaceWithoutGlobal))
.AddType(classBuilder)
.Build(writer);
}
protected virtual void BuildContainerClasses(ClassBuilder builder)
{
builder.Append("step-container");
}
public FieldBody()
{
containerClassBuilder = new ClassBuilder(BuildContainerClasses);
}
void ITagElementGuessVisitor.Visit(uint offset, TagBlockGuess guess)
{
var className = string.Format("TagBlock{0}", _nextUnknownBlock++);
using (var blockWriter = new StringWriter())
{
var blockBuilder = new ClassBuilder(blockWriter, _indentLevel, className);
blockBuilder._nextUnknownBlock = _nextUnknownBlock;
LayoutGuessWriter.Write(null, guess.ElementLayout, blockBuilder);
_subBlocks.Enqueue(blockWriter.ToString());
_nextUnknownBlock = blockBuilder._nextUnknownBlock;
}
AddUnknown(offset, string.Format("List<{0}>", className));
}
protected void AddSource(ClassBuilder builder)
{
_context.ReportDiagnostic(Diagnostic.Create(Descriptors.CreatedClass, null, builder.FullyQualifiedName));
_context.AddSource(builder.FullyQualifiedName, builder.Build());
}
protected override void RegisterComponentClasses()
{
ClassBuilder.Register(GetClassSize);
ClassBuilder.Register(GetClassLabelPosition);
}
protected override void BuildClasses(ClassBuilder builder)
{
base.BuildClasses(builder);
}
public static void Parse(XElement props, ClassBuilder builder)
{
if (props == null || builder == null)
{
return;
}
var useSetQuantity = bool.Parse(props?.Element("UseSetNumItems")?.Value ?? "false");
var useEnabled = bool.Parse(props?.Element("UseEnabledItems")?.Value ?? "false");
var useVisible = bool.Parse(props?.Element("UseVisibleItems")?.Value ?? "false");
_ = ushort.TryParse(props?.Element("DigitalJoinIncrement")?.Value ?? "0", out var digitalIncrement);
_ = ushort.TryParse(props?.Element("AnalogJoinIncrement")?.Value ?? "0", out var analogIncrement);
_ = ushort.TryParse(props?.Element("SerialJoinIncrement")?.Value ?? "0", out var serialIncrement);
_ = ushort.TryParse(props?.Element("NumSubpageReferences")?.Value ?? "0", out var pageQuantity);
_ = ushort.TryParse(props?.Element("ItemEnableJoinGroup")?.Element("StartJoinNumber")?.Value ?? "0", out var enableStart);
_ = ushort.TryParse(props?.Element("ItemVisibilityJoinGroup")?.Element("StartJoinNumber")?.Value ?? "0", out var visStart);
_ = ushort.TryParse(props?.Element("DigitalTriListJoinGroup")?.Element("StartJoinNumber")?.Value ?? "0", out var digStart);
_ = ushort.TryParse(props?.Element("AnalogTriListJoinGroup")?.Element("StartJoinNumber")?.Value ?? "0", out var analogStart);
_ = ushort.TryParse(props?.Element("SerialTriListJoinGroup")?.Element("StartJoinNumber")?.Value ?? "0", out var serialStart);
var pageReference = props?.Element("Subpage")?.Element("PageID").Value ?? "0";
if (pageReference == "0")
{
return;
}
if (useSetQuantity)
{
if (ushort.TryParse(props?.Element("AnalogNumberOfItemsJoin")?.Element("JoinNumber")?.Value ?? "0", out var quantityJoin) && quantityJoin > 0)
{
builder.AddJoin(new JoinBuilder(quantityJoin, builder.SmartJoin, "ItemQuantity", JoinType.Analog, JoinDirection.ToPanel));
}
}
if (ushort.TryParse(props?.Element("AnalogSelectJoin")?.Element("JoinNumber")?.Value ?? "0", out var selectJoin) && selectJoin > 0)
{
builder.AddJoin(new JoinBuilder(selectJoin, builder.SmartJoin, "ItemSelection", JoinType.Analog, JoinDirection.FromPanel));
}
if (ushort.TryParse(props?.Element("AnalogScrollJoin")?.Element("JoinNumber")?.Value ?? "0", out var scrollJoin) && selectJoin > 0)
{
builder.AddJoin(new JoinBuilder(scrollJoin, builder.SmartJoin, "ScrollToItem", JoinType.AnalogSet, JoinDirection.ToPanel));
}
var subpage = props?.Document?.Root?.Element("Properties")?.Element("Pages")?.Elements()?.Where(e => e.Name.LocalName.ToUpperInvariant() == "PAGE" && e.Element("ControlName")?.Value.ToUpperInvariant() == "SUBPAGE" && e.Attribute("uid")?.Value == pageReference)?.FirstOrDefault() ?? null;
if (subpage == null)
{
return;
}
var subBuilder = new ClassBuilder(ClassType.SrlElement)
{
ClassName = $"{builder.ClassName}Item", //$"Item", //$"{(subpage?.Element("ObjectName")?.Value ?? "Subpage")}",
Namespace = builder.Namespace,
//DigitalOffset = (ushort)(digStart - 1),
//AnalogOffset = (ushort)(analogStart - 1),
//SerialOffset = (ushort)(serialStart - 1),
SmartJoin = builder.SmartJoin
};
foreach (var c in subpage?.Element("Properties")?.Element("Children")?.Elements()?.
Where(e => e.Name.LocalName != "Subpage") ?? System.Array.Empty <XElement>())
{
GenericParser.ParseChildElement(c, subBuilder);
}
if (useVisible)
{
subBuilder.AddJoin(new JoinBuilder(1, subBuilder.SmartJoin, "IsVisible", JoinType.SrlVisibility, JoinDirection.ToPanel));
}
if (useEnabled)
{
subBuilder.AddJoin(new JoinBuilder(1, subBuilder.SmartJoin, "IsEnabled", JoinType.SrlEnable, JoinDirection.ToPanel));
}
subBuilder.DigitalOffset = (ushort)(digStart - 1);
subBuilder.AnalogOffset = (ushort)(analogStart - 1);
subBuilder.SerialOffset = (ushort)(serialStart - 1);
var list = new ListBuilder(subBuilder, pageQuantity, digitalIncrement, analogIncrement, serialIncrement)
{
Name = props?.Parent?.Element("ObjectName")?.Value ?? ""
};
builder.AddList(list);
}
protected override void BuildClasses(ClassBuilder builder)
{
builder.Append(ClassProvider.Chart());
base.BuildClasses(builder);
}
public void SingularPropertyNameWithInheritance()
{
var company = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Company").WithPluralName("Companies").Build();
var person = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Person").WithPluralName("Persons").Build();
var companyPerson = new RelationTypeBuilder(this.Domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid())
.WithObjectTypes(company, person)
.Build();
var super = new InterfaceBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Company").WithPluralName("Companies").Build();
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(company).WithSupertype(super).Build();
var superPerson = new RelationTypeBuilder(this.Domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid())
.WithObjectTypes(super, person)
.Build();
Assert.AreEqual("CompanyPerson", companyPerson.RoleType.SingularPropertyName);
Assert.AreEqual("CompanyPerson", superPerson.RoleType.SingularPropertyName);
companyPerson.RoleType.AssignedPluralName = "Personen";
Assert.AreEqual("CompanyPerson", companyPerson.RoleType.SingularPropertyName);
Assert.AreEqual("CompanyPerson", superPerson.RoleType.SingularPropertyName);
companyPerson.RoleType.AssignedSingularName = "Persoon";
Assert.AreEqual("Persoon", companyPerson.RoleType.SingularPropertyName);
Assert.AreEqual("Person", superPerson.RoleType.SingularPropertyName);
}
protected override void Generate(OperationDescriptor descriptor,
CSharpSyntaxGeneratorSettings settings,
CodeWriter writer,
out string fileName,
out string?path,
out string ns)
{
var documentName = CreateDocumentTypeName(descriptor.RuntimeType.Name);
fileName = documentName;
path = null;
ns = descriptor.RuntimeType.NamespaceWithoutGlobal;
string operationKind = descriptor switch
{
MutationOperationDescriptor => "Mutation",
QueryOperationDescriptor => "Query",
SubscriptionOperationDescriptor => "Subscription",
_ => throw new ArgumentOutOfRangeException(nameof(descriptor))
};
ClassBuilder classBuilder = ClassBuilder
.New()
.SetName(fileName)
.AddImplements(TypeNames.IDocument)
.SetComment(
XmlCommentBuilder
.New()
.SetSummary(
string.Format(
CodeGenerationResources.OperationServiceDescriptor_Description,
descriptor.Name))
.AddCode(descriptor.BodyString));
classBuilder
.AddConstructor()
.SetPrivate();
classBuilder
.AddProperty("Instance")
.SetStatic()
.SetType(documentName)
.SetValue($"new {documentName}()");
classBuilder
.AddProperty("Kind")
.SetType(TypeNames.OperationKind)
.AsLambda($"{TypeNames.OperationKind}.{operationKind}");
if (descriptor.Strategy == RequestStrategy.PersistedQuery)
{
classBuilder
.AddProperty("Body")
.SetType(TypeNames.IReadOnlySpan.WithGeneric(TypeNames.Byte))
.AsLambda($"new {TypeNames.Byte}[0]");
}
else
{
classBuilder
.AddProperty("Body")
.SetType(TypeNames.IReadOnlySpan.WithGeneric(TypeNames.Byte))
.AsLambda(GetByteArray(descriptor.Body));
}
classBuilder
.AddProperty("Hash")
.SetType(TypeNames.DocumentHash)
.SetValue(
$@"new {TypeNames.DocumentHash}(" +
$@"""{descriptor.HashAlgorithm}"", " +
$@"""{descriptor.HashValue}"")");
classBuilder
.AddMethod("ToString")
.SetPublic()
.SetOverride()
.SetReturnType(TypeNames.String)
.AddCode("#if NETSTANDARD2_0")
.AddCode(MethodCallBuilder
.New()
.SetReturn()
.SetMethodName(TypeNames.EncodingUtf8, nameof(Encoding.UTF8.GetString))
.AddArgument("Body.ToArray()"))
.AddCode("#else")
.AddCode(MethodCallBuilder
.New()
.SetReturn()
.SetMethodName(TypeNames.EncodingUtf8, nameof(Encoding.UTF8.GetString))
.AddArgument("Body"))
.AddCode("#endif");
classBuilder.Build(writer);
}
public void DirectSupertypes()
{
var c1 = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("c1").WithPluralName("c1s").Build();
var c2 = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("c2").WithPluralName("c2s").Build();
var i1 = new InterfaceBuilder(this.Domain, Guid.NewGuid()).WithSingularName("i1").WithPluralName("i1s").Build();
var i2 = new InterfaceBuilder(this.Domain, Guid.NewGuid()).WithSingularName("i2").WithPluralName("i2s").Build();
Assert.AreEqual(0, c1.DirectSupertypes.Count());
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c1).WithSupertype(i1).Build();
Assert.AreEqual(1, c1.DirectSupertypes.Count());
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c1).WithSupertype(i2).Build();
Assert.AreEqual(2, c1.DirectSupertypes.Count());
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c2).WithSupertype(i1).Build();
Assert.AreEqual(2, c1.DirectSupertypes.Count());
}
protected override void BuildClasses(ClassBuilder builder)
{
builder.Append("sidebar-label");
base.BuildClasses(builder);
}
public void Id()
{
this.Populate();
var thisType = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("c1").WithPluralName("c1s").Build();
thisType.SingularName = "ThisType";
thisType.PluralName = "TheseTypes";
Assert.IsTrue(this.MetaPopulation.IsValid);
foreach (var objectType in this.MetaPopulation.Classes)
{
Assert.IsTrue(objectType.Id != Guid.Empty);
}
}
protected override void BuildClasses(ClassBuilder builder)
{
builder.Append(ClassProvider.ProgressBarSize(ParentProgress.Size), ParentProgress != null && ParentProgress.Size != Size.None);
base.BuildClasses(builder);
}
public void Validate()
{
var type = new ClassBuilder(this.Domain, Guid.NewGuid()).Build();
var validationReport = this.MetaPopulation.Validate();
Assert.IsTrue(validationReport.ContainsErrors);
var errors = validationReport.Errors;
Assert.AreEqual(2, errors.Length);
foreach (var error in errors)
{
Assert.AreEqual(1, error.Members.Length);
var member = error.Members[0];
Assert.IsTrue(member.StartsWith("IObjectType."));
if (member.Equals("IObjectType.SingularName"))
{
Assert.AreEqual(ValidationKind.Required, error.Kind);
}
else if (member.Equals("IObjectType.PluralName"))
{
Assert.AreEqual(ValidationKind.Required, error.Kind);
}
}
// SingularName
type.SingularName = string.Empty;
type.PluralName = "Plural";
validationReport = this.MetaPopulation.Validate();
Assert.IsTrue(validationReport.ContainsErrors);
Assert.AreEqual(1, validationReport.Errors.Length);
Assert.AreEqual(type, validationReport.Errors[0].Source);
Assert.AreEqual(1, validationReport.Errors[0].Members.Length);
Assert.AreEqual("IObjectType.SingularName", validationReport.Errors[0].Members[0]);
Assert.AreEqual(ValidationKind.Required, validationReport.Errors[0].Kind);
type.SingularName = "_a";
validationReport = this.MetaPopulation.Validate();
Assert.IsTrue(validationReport.ContainsErrors);
Assert.AreEqual(1, validationReport.Errors.Length);
Assert.AreEqual(type, validationReport.Errors[0].Source);
Assert.AreEqual(1, validationReport.Errors[0].Members.Length);
Assert.AreEqual("IObjectType.SingularName", validationReport.Errors[0].Members[0]);
Assert.AreEqual(ValidationKind.Format, validationReport.Errors[0].Kind);
type.SingularName = "a_";
validationReport = this.MetaPopulation.Validate();
Assert.IsTrue(validationReport.ContainsErrors);
Assert.AreEqual(1, validationReport.Errors.Length);
Assert.AreEqual(type, validationReport.Errors[0].Source);
Assert.AreEqual(1, validationReport.Errors[0].Members.Length);
Assert.AreEqual("IObjectType.SingularName", validationReport.Errors[0].Members[0]);
Assert.AreEqual(ValidationKind.Format, validationReport.Errors[0].Kind);
type.SingularName = "11";
validationReport = this.MetaPopulation.Validate();
Assert.IsTrue(validationReport.ContainsErrors);
Assert.AreEqual(1, validationReport.Errors.Length);
Assert.AreEqual(type, validationReport.Errors[0].Source);
Assert.AreEqual(1, validationReport.Errors[0].Members.Length);
Assert.AreEqual("IObjectType.SingularName", validationReport.Errors[0].Members[0]);
Assert.AreEqual(ValidationKind.Format, validationReport.Errors[0].Kind);
type.SingularName = "a1";
validationReport = this.MetaPopulation.Validate();
Assert.IsFalse(validationReport.ContainsErrors);
Assert.AreEqual(0, validationReport.Errors.Length);
type.SingularName = "aa";
validationReport = this.MetaPopulation.Validate();
Assert.IsFalse(validationReport.ContainsErrors);
Assert.AreEqual(0, validationReport.Errors.Length);
// PluralName
type.SingularName = "SingularName";
type.PluralName = null;
validationReport = this.MetaPopulation.Validate();
Assert.IsTrue(validationReport.ContainsErrors);
Assert.AreEqual(1, validationReport.Errors.Length);
Assert.AreEqual(type, validationReport.Errors[0].Source);
Assert.AreEqual(1, validationReport.Errors[0].Members.Length);
Assert.AreEqual("IObjectType.PluralName", validationReport.Errors[0].Members[0]);
Assert.AreEqual(ValidationKind.Required, validationReport.Errors[0].Kind);
type.PluralName = "_a";
validationReport = this.MetaPopulation.Validate();
Assert.IsTrue(validationReport.ContainsErrors);
Assert.AreEqual(1, validationReport.Errors.Length);
Assert.AreEqual(type, validationReport.Errors[0].Source);
Assert.AreEqual(1, validationReport.Errors[0].Members.Length);
Assert.AreEqual("IObjectType.PluralName", validationReport.Errors[0].Members[0]);
Assert.AreEqual(ValidationKind.Format, validationReport.Errors[0].Kind);
type.PluralName = "a_";
validationReport = this.MetaPopulation.Validate();
Assert.IsTrue(validationReport.ContainsErrors);
Assert.AreEqual(1, validationReport.Errors.Length);
Assert.AreEqual(type, validationReport.Errors[0].Source);
Assert.AreEqual(1, validationReport.Errors[0].Members.Length);
Assert.AreEqual("IObjectType.PluralName", validationReport.Errors[0].Members[0]);
Assert.AreEqual(ValidationKind.Format, validationReport.Errors[0].Kind);
type.PluralName = "11";
validationReport = this.MetaPopulation.Validate();
Assert.IsTrue(validationReport.ContainsErrors);
Assert.AreEqual(1, validationReport.Errors.Length);
Assert.AreEqual(type, validationReport.Errors[0].Source);
Assert.AreEqual(1, validationReport.Errors[0].Members.Length);
Assert.AreEqual("IObjectType.PluralName", validationReport.Errors[0].Members[0]);
Assert.AreEqual(ValidationKind.Format, validationReport.Errors[0].Kind);
type.PluralName = "a1";
validationReport = this.MetaPopulation.Validate();
Assert.IsFalse(validationReport.ContainsErrors);
Assert.AreEqual(0, validationReport.Errors.Length);
type.PluralName = "aa";
validationReport = this.MetaPopulation.Validate();
Assert.IsFalse(validationReport.ContainsErrors);
Assert.AreEqual(0, validationReport.Errors.Length);
}
private FlowFormField FieldFor <TProperty>(Expression <Func <TModel, TProperty> > expression, bool containsSection, FieldConfiguration fieldConfiguration = null)
{
/*
* Renders a field for a non-boolean property of the model
*/
fieldConfiguration = fieldConfiguration ?? new FieldConfiguration();
if (fieldConfiguration.HideIfNull && fieldConfiguration.ReadOnly && GetValue(expression) == null)
{
return(null);
}
var htmlAttrs = Helper.ObjectToDictionary(fieldConfiguration.HtmlAttributes);
var type = ElementType.Text;
var grid = default(Grid);
var selectList = default(MultiSelectList);
var metadata = ModelMetadata.FromLambdaExpression(expression, _htmlHelper.ViewData);
// Label
var labelHtml = LabelHtml(expression, fieldConfiguration);
if (fieldConfiguration.ReadOnly)
{
labelHtml = labelHtml.ReReplace(@"</?label.*?>", "", RegexOptions.IgnoreCase);
}
if (fieldConfiguration.ReadOnly && expression.ReturnType.Name != "Grid`1")
{
var value = (GetValue(expression) ?? "?");
var fi = value.GetType().GetField(value.ToString());
var attributes = fi != null ? (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false) : new DescriptionAttribute[] { };
var stringValue = (attributes.Length > 0) ? attributes[0].Description : value.ToString();
return(new FlowFormField(_writer, containsSection, labelHtml, (new HtmlString(stringValue)).ToString(), parentClass: fieldConfiguration.ParentClass));
}
var validators = metadata.GetValidators(_htmlHelper.ViewContext.Controller.ControllerContext);
var classes = new ClassBuilder();
if (htmlAttrs.ContainsKey("class"))
{
classes.Add((string)htmlAttrs["class"]);
}
if (metadata.IsRequired && (!metadata.ModelType.IsEnum || fieldConfiguration.Exclude == null || fieldConfiguration.Exclude.Length == 0))
{
classes.Add("required");
}
else
{
labelHtml = labelHtml.Replace("</label>", " <em>(Optional)</em></label>");
}
switch (metadata.DataTypeName)
{
case "Digits":
case "CreditCard":
classes.Add(metadata.DataTypeName.Replace("-", "").ToLower());
break;
case "IPAddress":
classes.Add("ip-address");
break;
case "MultilineText":
type = ElementType.TextArea;
break;
}
switch (metadata.ModelType.Name)
{
case "Double":
classes.Add("number");
break;
case "Int32":
classes.Add("integer");
break;
case "Email":
classes.Add("email");
break;
case "Password":
type = ElementType.Password;
break;
case "Date":
classes.Add("date");
break;
case "HttpPostedFileBase":
htmlAttrs["type"] = "file";
break;
}
if (metadata.ModelType.IsEnum && metadata.ModelType.IsDefined(typeof(FlagsAttribute), false))
{
type = ElementType.Select;
var list = (IEnumerable <object>)EnumInfo.CreateList(metadata.ModelType, fieldConfiguration.Exclude);
var selectedValues = GetSelectedEnums((Enum)metadata.Model, fieldConfiguration.Exclude).ToList();
selectList = new MultiSelectList(list, "Value", "Display", selectedValues);
}
else if (metadata.ModelType.IsEnum || (
metadata.ModelType.IsGenericType &&
metadata.ModelType.GetGenericTypeDefinition().FullName == "System.Nullable`1" &&
metadata.ModelType.GetGenericArguments()[0].IsEnum
) || (
typeof(IEnumerable).IsAssignableFrom(metadata.ModelType) &&
!typeof(string).IsAssignableFrom(metadata.ModelType) &&
metadata.ModelType.GetGenericArguments()[0].IsEnum
)
)
{
type = ElementType.Select;
var list = (IEnumerable <object>)EnumInfo.CreateList(metadata.ModelType.IsGenericType ? metadata.ModelType.GetGenericArguments()[0] : metadata.ModelType, fieldConfiguration.Exclude);
var selectedValues = GetSelected(metadata.Model);
selectList = new MultiSelectList(list, "Value", "Display", selectedValues);
}
foreach (var rule in validators.SelectMany(v => v.GetClientValidationRules()))
{
switch (rule.ValidationType)
{
case "range":
classes.Add(string.Format("range([{0},{1}])", rule.ValidationParameters["min"], rule.ValidationParameters["max"]));
break;
case "min":
classes.Add(string.Format("min({0})", rule.ValidationParameters["min"]));
break;
case "max":
classes.Add(string.Format("max({0})", rule.ValidationParameters["max"]));
break;
case "regex":
classes.Add(string.Format("match(/{0}/)", rule.ValidationParameters["pattern"]));
break;
case "length":
case "maxlength":
if (type == ElementType.Text || type == ElementType.Password)
{
htmlAttrs["maxlength"] = rule.ValidationParameters["max"];
}
else
{
classes.Add(string.Format("maxlength({0})", rule.ValidationParameters["max"]));
}
break;
case "minlength":
classes.Add(string.Format("minlength({0})", rule.ValidationParameters["min"]));
break;
case "rangelength":
classes.Add(string.Format("rangelength([{0},{1}])", rule.ValidationParameters["min"], rule.ValidationParameters["max"]));
break;
case "equalto":
classes.Add(string.Format("equalTo('#{0}')", rule.ValidationParameters["other"].ToString().Split('.')[1]));
labelHtml = labelHtml.Replace(" <em>(Optional)</em>", "");
break;
case "existsin":
type = ElementType.Select;
selectList = GetSelectListFromCollection(expression, metadata, rule);
break;
case "grid":
grid = GetGrid(expression, metadata, rule);
break;
case "notrequired":
labelHtml = labelHtml.Replace(" <em>(Optional)</em>", "");
break;
case "filetype":
classes.Add(string.Format("accept('{0}')", rule.ValidationParameters["extension"]));
fieldConfiguration.Tip = fieldConfiguration.Tip ?? string.Format("Filetype must be: {0}", rule.ValidationParameters["pretty-extension"]);
break;
}
}
if (classes.ToString().Trim() != "")
{
htmlAttrs["class"] = classes.ToString();
}
if (fieldConfiguration.As.HasValue)
{
var validOverride = false;
var overrideErrorMessage = "";
switch (type)
{
case ElementType.Select:
switch (fieldConfiguration.As.Value)
{
case ElementType.Checkboxes:
case ElementType.RadioButtons:
case ElementType.Text:
type = fieldConfiguration.As.Value;
validOverride = true;
break;
}
break;
case ElementType.Text:
switch (fieldConfiguration.As.Value)
{
case ElementType.Checkboxes:
case ElementType.RadioButtons:
case ElementType.Select:
if (fieldConfiguration.PossibleValues != null)
{
selectList = fieldConfiguration.PossibleValues;
type = fieldConfiguration.As.Value;
validOverride = true;
}
else
{
overrideErrorMessage = "I was expecting a list.";
}
break;
}
break;
}
if (!validOverride)
{
throw new ApplicationException(string.Format("FieldConfiguration{{ As = {0} }} not valid for field: {1} (which defaults to {2}). {3}",
fieldConfiguration.As.Value, expression, type, overrideErrorMessage));
}
}
var elementHtml = string.Empty;
var errorHtml = string.Empty;
var isValid = true;
if (grid != null)
{
elementHtml = RenderGrid(grid, fieldConfiguration.ReadOnly);
isValid = GetErrors(expression, out errorHtml);
}
else
{
switch (type)
{
case ElementType.Text:
elementHtml = _htmlHelper.TextBoxFor(expression, htmlAttrs).ToHtmlString();
break;
case ElementType.Password:
elementHtml = _htmlHelper.PasswordFor(expression, htmlAttrs).ToHtmlString();
break;
case ElementType.TextArea:
elementHtml = _htmlHelper.TextAreaFor(expression, htmlAttrs).ToHtmlString();
break;
case ElementType.Select:
if (typeof(IEnumerable).IsAssignableFrom(metadata.ModelType) &&
!typeof(string).IsAssignableFrom(metadata.ModelType))
{
elementHtml = _htmlHelper.ListBoxFor(expression, selectList, htmlAttrs).ToHtmlString();
}
else
{
elementHtml = _htmlHelper.DropDownListFor(expression, selectList, fieldConfiguration.Label, htmlAttrs).ToHtmlString();
}
break;
case ElementType.Checkboxes:
case ElementType.RadioButtons:
// TODO: Use HTML Attributes
var typeString = type == ElementType.Checkboxes ? "checkbox" : "radio";
elementHtml += HelperDefinitions.BeginInputList(typeString);
elementHtml += string.Join("", selectList.Select(i => HelperDefinitions.InputListItem(typeString, expression.GetFieldName(), i.Value, i.Text, i.Selected).ToString()));
elementHtml += HelperDefinitions.EndInputList();
break;
}
isValid = GetErrors(expression, out errorHtml);
}
elementHtml = (fieldConfiguration.Before ?? "") + elementHtml + (fieldConfiguration.After ?? "");
return(new FlowFormField(_writer, containsSection, labelHtml, elementHtml, errorHtml, isValid, fieldConfiguration.Hint, fieldConfiguration.Tip, fieldConfiguration.HideTip, fieldConfiguration.HintClass, fieldConfiguration.ParentClass, fieldConfiguration.DisplayFieldName));
}
public void ValidateNameMinimumLength()
{
var type = new ClassBuilder(this.Domain, Guid.NewGuid()).Build();
type.SingularName = "A";
type.PluralName = "CD";
Assert.IsFalse(this.MetaPopulation.IsValid);
type.SingularName = "AB";
Assert.IsTrue(this.MetaPopulation.IsValid);
type.PluralName = "C";
Assert.IsFalse(this.MetaPopulation.IsValid);
type.PluralName = "CD";
Assert.IsTrue(this.MetaPopulation.IsValid);
}
private void AddBuildDataMethod(
CSharpSyntaxGeneratorSettings settings,
InterfaceTypeDescriptor resultNamedType,
ClassBuilder classBuilder)
{
var concreteType =
CreateResultInfoName(
resultNamedType.ImplementedBy.First().RuntimeType.Name);
MethodBuilder buildDataMethod = classBuilder
.AddMethod()
.SetPrivate()
.SetName("BuildData")
.SetReturnType($"({resultNamedType.RuntimeType.Name}, {concreteType})")
.AddParameter(_obj, x => x.SetType(TypeNames.JsonElement));
if (settings.IsStoreEnabled())
{
buildDataMethod.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"var {_entityIds}")
.SetRighthandSide(MethodCallBuilder
.Inline()
.SetNew()
.SetMethodName(TypeNames.HashSet)
.AddGeneric(TypeNames.EntityId)))
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"{TypeNames.IEntityStoreSnapshot} {_snapshot}")
.SetRighthandSide("default!"));
}
buildDataMethod.AddEmptyLine();
CodeBlockBuilder storeUpdateBody = CodeBlockBuilder.New();
if (settings.IsStoreEnabled())
{
foreach (PropertyDescriptor property in
resultNamedType.Properties.Where(prop => prop.Type.IsOrContainsEntityType()))
{
var variableName = $"{GetParameterName(property.Name)}Id";
buildDataMethod
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(CodeBlockBuilder
.New()
.AddCode(property.Type.ToStateTypeReference())
.AddCode(variableName))
.SetRighthandSide("default!"));
storeUpdateBody
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(variableName)
.SetRighthandSide(BuildUpdateMethodCall(property)));
}
storeUpdateBody
.AddEmptyLine()
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(_snapshot)
.SetRighthandSide($"{_session}.CurrentSnapshot"));
buildDataMethod
.AddCode(MethodCallBuilder
.New()
.SetMethodName(_entityStore, "Update")
.AddArgument(LambdaBuilder
.New()
.AddArgument(_session)
.SetBlock(true)
.SetCode(storeUpdateBody)));
}
buildDataMethod
.AddEmptyLine()
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide($"var {_resultInfo}")
.SetRighthandSide(
CreateResultInfoMethodCall(settings, resultNamedType, concreteType)))
.AddEmptyLine()
.AddCode(
TupleBuilder
.Inline()
.SetDetermineStatement(true)
.SetReturn()
.AddMember(MethodCallBuilder
.Inline()
.SetMethodName(_resultDataFactory, "Create")
.AddArgument(_resultInfo))
.AddMember(_resultInfo));
}
public void SingularPropertyName()
{
var company = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Company").WithPluralName("Companies").Build();
var person = new ClassBuilder(this.Domain, Guid.NewGuid()).WithSingularName("Person").WithPluralName("Persons").Build();
var companyPerson = new RelationTypeBuilder(this.Domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid())
.WithObjectTypes(company, person)
.Build();
var associationType = companyPerson.AssociationType;
Assert.AreEqual("CompanyWherePerson", associationType.SingularPropertyName);
}
/// <summary>
/// Generates mappings for all data model functions and procedures.
/// </summary>
/// <param name="dataContextClass">Data context class builder.</param>
/// <param name="contextIsDataConnection">Indicate wether data context is based on <see cref="DataConnection"/>.</param>
/// <param name="getExtensionsClass">Extensions class builder provider.</param>
private void BuildAllFunctions(
ClassBuilder dataContextClass,
bool contextIsDataConnection,
Func <ClassBuilder> getExtensionsClass)
{
// regions in extensions class for specific function types
RegionGroup?proceduresRegion = null;
RegionGroup?aggregatesRegion = null;
RegionGroup?scalarFunctionRegion = null;
// mapping schema initialization method body
// (some functions require additional mapping configuration on mapping schema level)
BlockBuilder?schemaInitializer = null;
// mapping schema property accessor for schema initializer
CodeReference?schemaProperty = null;
// TODO: requires linq2db refactoring
// currently stored procedures API requires DataConnection-based context
// so we cannot use generated data context type for parameter if it is not inherited from DataConnection
var spContextParameterType = contextIsDataConnection
? dataContextClass.Type.Type
: WellKnownTypes.LinqToDB.Data.DataConnection;
// build functions for main context
BuildFunctions(
dataContextClass.Type,
_dataModel.DataContext,
spContextParameterType,
() => proceduresRegion ??= getExtensionsClass().Regions().New(EXTENSIONS_STORED_PROCEDURES_REGION).Regions(),
() => aggregatesRegion ??= getExtensionsClass().Regions().New(EXTENSIONS_AGGREGATES_REGION).Regions(),
() => scalarFunctionRegion ??= getExtensionsClass().Regions().New(EXTENSIONS_SCALAR_FUNCTIONS_REGION).Regions(),
dataContextClass.Regions().New(CONTEXT_TABLE_FUNCTIONS_REGION).Regions(),
getSchemaInitializer);
// build functions for additional schemas
foreach (var schema in _dataModel.DataContext.AdditionalSchemas.Values)
{
var(wrapper, schemaContext) = _schemaClasses[schema];
BuildFunctions(
dataContextClass.Type,
schema,
spContextParameterType,
() => wrapper.Regions().New(EXTENSIONS_STORED_PROCEDURES_REGION).Regions(),
() => wrapper.Regions().New(EXTENSIONS_AGGREGATES_REGION).Regions(),
() => wrapper.Regions().New(EXTENSIONS_SCALAR_FUNCTIONS_REGION).Regions(),
schemaContext.Regions().New(CONTEXT_TABLE_FUNCTIONS_REGION).Regions(),
getSchemaInitializer);
}
// helper function to define custom mapping schema initializer only when needed (on request)
(BlockBuilder initializer, CodeReference schemaProperty) getSchemaInitializer()
{
// schema initializer (and schema) are static to avoid:
// - schema initialization on each context creation
// - non-static schema will render query caching almost useless
if (schemaInitializer == null)
{
// declare static mapping schema property
var schemaProp = dataContextClass
.Properties(true)
.New(AST.Name(CONTEXT_SCHEMA_PROPERTY), WellKnownTypes.LinqToDB.Mapping.MappingSchema)
.SetModifiers(Modifiers.Public | Modifiers.Static)
.Default(false)
.SetInitializer(AST.New(WellKnownTypes.LinqToDB.Mapping.MappingSchema));
schemaProperty = schemaProp.Property.Reference;
// declare static constructor, where we will add custom schema initialization logic
schemaInitializer = dataContextClass.TypeInitializer().Body();
}
return(schemaInitializer, schemaProperty !);
}
}
public ClassCloner()
{
IList<string> namespaces = new List<string>();
namespaces.Add("System.Collections.Generic");
this._classBuilder = new ClassBuilder(namespaces);
}
public void Inheritances()
{
var domain = this.Domain;
var superdomain = new Domain(this.MetaPopulation, Guid.NewGuid());
domain.AddDirectSuperdomain(superdomain);
var c1 = new ClassBuilder(domain, Guid.NewGuid()).WithSingularName("c1").WithPluralName("c1s").Build();
var c2 = new ClassBuilder(superdomain, Guid.NewGuid()).WithSingularName("c2").WithPluralName("c2s").Build();
var i1 = new InterfaceBuilder(domain, Guid.NewGuid()).WithSingularName("i1").WithPluralName("i1s").Build();
var i2 = new InterfaceBuilder(superdomain, Guid.NewGuid()).WithSingularName("i2").WithPluralName("i2s").Build();
Assert.AreEqual(0, this.MetaPopulation.Inheritances.Count());
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c1).WithSupertype(i1).Build();
Assert.AreEqual(1, this.MetaPopulation.Inheritances.Count());
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c2).WithSupertype(i2).Build();
Assert.AreEqual(2, this.MetaPopulation.Inheritances.Count());
new InheritanceBuilder(this.Domain, Guid.NewGuid()).WithSubtype(c1).WithSupertype(i2).Build();
Assert.AreEqual(3, this.MetaPopulation.Inheritances.Count());
}
protected override void Generate(OperationDescriptor descriptor,
CSharpSyntaxGeneratorSettings settings,
CodeWriter writer,
out string fileName,
out string?path,
out string ns)
{
fileName = descriptor.RuntimeType.Name;
path = null;
ns = descriptor.RuntimeType.NamespaceWithoutGlobal;
ClassBuilder classBuilder = ClassBuilder
.New()
.SetComment(
XmlCommentBuilder
.New()
.SetSummary(
string.Format(
CodeGenerationResources.OperationServiceDescriptor_Description,
descriptor.Name))
.AddCode(descriptor.BodyString))
.AddImplements(descriptor.InterfaceType.ToString())
.SetName(fileName);
ConstructorBuilder constructorBuilder = classBuilder
.AddConstructor()
.SetTypeName(fileName);
var runtimeTypeName =
descriptor.ResultTypeReference.GetRuntimeType().Name;
AddConstructorAssignedField(
TypeNames.IOperationExecutor.WithGeneric(runtimeTypeName),
_operationExecutor,
operationExecutor,
classBuilder,
constructorBuilder);
AddInjectedSerializers(descriptor, constructorBuilder, classBuilder);
if (descriptor is not SubscriptionOperationDescriptor)
{
classBuilder.AddMethod(CreateExecuteMethod(descriptor, runtimeTypeName));
}
classBuilder.AddMethod(CreateWatchMethod(descriptor, runtimeTypeName));
classBuilder.AddMethod(CreateRequestMethod(descriptor));
classBuilder.AddMethod(CreateRequestVariablesMethod(descriptor));
AddFormatMethods(descriptor, classBuilder);
classBuilder
.AddProperty("ResultType")
.SetType(TypeNames.Type)
.AsLambda($"typeof({runtimeTypeName})")
.SetInterface(TypeNames.IOperationRequestFactory);
MethodCallBuilder createRequestCall = MethodCallBuilder
.New()
.SetReturn()
.SetMethodName(_createRequest);
if (descriptor.Arguments.Count > 0)
{
createRequestCall.AddArgument($"{_variables}!");
}
classBuilder
.AddMethod("Create")
.SetReturnType(TypeNames.OperationRequest)
.SetInterface(TypeNames.IOperationRequestFactory)
.AddParameter(
_variables,
x => x.SetType(
TypeNames.IReadOnlyDictionary
.WithGeneric(TypeNames.String, TypeNames.Object.MakeNullable())
.MakeNullable()))
.AddCode(createRequestCall);
classBuilder.Build(writer);
}
public void ValidateDuplicateReverseRelationAndType()
{
var metaPopulation = new MetaPopulation();
var domain = new Domain(metaPopulation, Guid.NewGuid()) { Name = "Domain" };
var c1 = new ClassBuilder(domain, Guid.NewGuid()).WithSingularName("C1").WithPluralName("C1s").Build();
var c2 = new ClassBuilder(domain, Guid.NewGuid()).WithSingularName("C2").WithPluralName("C2s").Build();
var relationType = new RelationTypeBuilder(domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()).Build();
relationType.AssociationType.ObjectType = c1;
relationType.RoleType.ObjectType = c2;
relationType.RoleType.AssignedSingularName = "bb";
relationType.RoleType.AssignedPluralName = "bbs";
Assert.IsTrue(metaPopulation.IsValid);
var c1bb = new ClassBuilder(domain, Guid.NewGuid()).WithSingularName("bbC1").WithPluralName("YYY").Build();
Assert.IsFalse(metaPopulation.IsValid);
c1bb.SingularName = "XXX";
Assert.IsTrue(metaPopulation.IsValid);
c1bb.PluralName = "bbsC1";
}
public CodeFirstContextWriter(CodeWriterSettings codeWriterSettings)
{
_codeWriterSettings = codeWriterSettings;
_cb = new ClassBuilder();
_contextName = CreateContextName();
}
private void BuildDialogClasses(ClassBuilder builder)
{
builder.Append("b-numeric");
builder.Append(ClassProvider.NumericEditValidation(ParentValidation?.Status ?? ValidationStatus.None), ParentValidation?.Status != ValidationStatus.None);
}
private string?GetBodyCellDivClass()
{
return(ClassBuilder.Create("tv-cell-inner")
.Build());
}
protected override void Generate(EntityIdFactoryDescriptor descriptor,
CSharpSyntaxGeneratorSettings settings,
CodeWriter writer,
out string fileName,
out string?path,
out string ns)
{
fileName = descriptor.Name;
path = State;
ns = descriptor.Namespace;
ClassBuilder classBuilder = ClassBuilder
.New()
.SetAccessModifier(AccessModifier.Public)
.AddImplements(TypeNames.IEntityIdSerializer)
.SetName(fileName);
classBuilder
.AddField(_options)
.SetStatic()
.SetReadOnly()
.SetType(TypeNames.JsonWriterOptions)
.SetValue(CodeBlockBuilder
.New()
.AddCode(MethodCallBuilder
.Inline()
.SetNew()
.SetMethodName(TypeNames.JsonWriterOptions))
.AddCode(CodeInlineBuilder.From("{ Indented = false }")));
classBuilder
.AddMethod("Parse")
.SetAccessModifier(AccessModifier.Public)
.SetReturnType(TypeNames.EntityId)
.AddParameter(_obj, x => x.SetType(TypeNames.JsonElement))
.AddCode(ParseEntityIdBody(descriptor));
classBuilder
.AddMethod("Format")
.SetAccessModifier(AccessModifier.Public)
.SetReturnType(TypeNames.String)
.AddParameter(_entityId, x => x.SetType(TypeNames.EntityId))
.AddCode(FormatEntityIdBody(descriptor));
foreach (var entity in descriptor.Entities)
{
classBuilder
.AddMethod($"Parse{entity.Name}EntityId")
.SetAccessModifier(AccessModifier.Private)
.SetReturnType(TypeNames.EntityId)
.AddParameter(_obj, x => x.SetType(TypeNames.JsonElement))
.AddParameter(_type, x => x.SetType(TypeNames.String))
.AddCode(ParseSpecificEntityIdBody(entity));
classBuilder
.AddMethod($"Format{entity.Name}EntityId")
.SetAccessModifier(AccessModifier.Private)
.SetReturnType(TypeNames.String)
.AddParameter(_entityId, x => x.SetType(TypeNames.EntityId))
.AddCode(FormatSpecificEntityIdBody(entity));
}
classBuilder.Build(writer);
}
public CodeFirstContextWriter(CodeWriterSettings codeWriterSettings)
{
_codeWriterSettings = codeWriterSettings;
_cb = new ClassBuilder();
_contextName = CreateContextName();
}
private string?GetTextClasses()
{
return(ClassBuilder.Create("d-block my-auto " + ClassNames.FontWeightSemibold)
.Add("indented", Icon == null)
.Build());
}
public override void WriteNamespaces(DatabaseTable table, ClassBuilder classBuilder)
{
classBuilder.AppendLine("using System.ComponentModel.DataAnnotations.Schema");
}
public override void WriteTableAnnotations(DatabaseTable table, ClassBuilder classBuilder)
{
classBuilder.AppendFormat("[Table(\"{0}\")]", table.Name);
}
public void RelationTypes()
{
var metaPopulation = new MetaPopulation();
var domain = new Domain(metaPopulation, Guid.NewGuid());
var superdomain = new Domain(metaPopulation, Guid.NewGuid());
domain.AddDirectSuperdomain(superdomain);
var c1 = new ClassBuilder(domain, Guid.NewGuid()).WithSingularName("c1").WithPluralName("c1s").Build();
var c2 = new ClassBuilder(superdomain, Guid.NewGuid()).WithSingularName("c2").WithPluralName("c2s").Build();
var i1 = new InterfaceBuilder(domain, Guid.NewGuid()).WithSingularName("i1").WithPluralName("i1s").Build();
var i2 = new InterfaceBuilder(superdomain, Guid.NewGuid()).WithSingularName("i2").WithPluralName("i2s").Build();
Assert.AreEqual(0, metaPopulation.RelationTypes.Count());
new RelationTypeBuilder(domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()).WithObjectTypes(c1, i1).Build();
Assert.AreEqual(1, metaPopulation.RelationTypes.Count());
new RelationTypeBuilder(superdomain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()).WithObjectTypes(c1, i2).Build();
Assert.AreEqual(2, metaPopulation.RelationTypes.Count());
new RelationTypeBuilder(domain, Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid()).WithObjectTypes(c1, c2).Build();
Assert.AreEqual(3, metaPopulation.RelationTypes.Count());
new MethodTypeBuilder(domain, Guid.NewGuid()).WithName("Method1").Build();
Assert.AreEqual(3, metaPopulation.RelationTypes.Count());
new MethodTypeBuilder(superdomain, Guid.NewGuid()).WithName("Method2").Build();
Assert.AreEqual(3, metaPopulation.RelationTypes.Count());
}
public override void WriteColumnAnnotations(DatabaseTable table, DatabaseColumn column, ClassBuilder classBuilder)
{
classBuilder.AppendFormat("[Column(\"{0}\")]", column.Name);
}
public void Find()
{
var metapopulation = new MetaPopulation();
var domain = new Domain(metapopulation, Guid.NewGuid());
var superdomain = new Domain(metapopulation, Guid.NewGuid());
domain.AddDirectSuperdomain(superdomain);
var unitId = UnitIds.StringId;
var interfaceId = Guid.NewGuid();
var classId = Guid.NewGuid();
var inheritanceId = Guid.NewGuid();
var relationTypeId = Guid.NewGuid();
var associationTypeId = Guid.NewGuid();
var roleTypeId = Guid.NewGuid();
var superunitId = UnitIds.IntegerId;
var superinterfaceId = Guid.NewGuid();
var superclassId = Guid.NewGuid();
var superinheritanceId = Guid.NewGuid();
var superrelationTypeId = Guid.NewGuid();
var superassociationTypeId = Guid.NewGuid();
var superroleTypeId = Guid.NewGuid();
Assert.IsNull(metapopulation.Find(unitId));
Assert.IsNull(metapopulation.Find(interfaceId));
Assert.IsNull(metapopulation.Find(classId));
Assert.IsNull(metapopulation.Find(inheritanceId));
Assert.IsNull(metapopulation.Find(relationTypeId));
Assert.IsNull(metapopulation.Find(associationTypeId));
Assert.IsNull(metapopulation.Find(roleTypeId));
Assert.IsNull(metapopulation.Find(superunitId));
Assert.IsNull(metapopulation.Find(superinterfaceId));
Assert.IsNull(metapopulation.Find(superclassId));
Assert.IsNull(metapopulation.Find(superinheritanceId));
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
new UnitBuilder(domain, unitId).WithSingularName("AllorsString").WithPluralName("AllorsStrings").WithUnitTag(UnitTags.AllorsString).Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNull(metapopulation.Find(interfaceId));
Assert.IsNull(metapopulation.Find(classId));
Assert.IsNull(metapopulation.Find(inheritanceId));
Assert.IsNull(metapopulation.Find(relationTypeId));
Assert.IsNull(metapopulation.Find(associationTypeId));
Assert.IsNull(metapopulation.Find(roleTypeId));
Assert.IsNull(metapopulation.Find(superunitId));
Assert.IsNull(metapopulation.Find(superinterfaceId));
Assert.IsNull(metapopulation.Find(superclassId));
Assert.IsNull(metapopulation.Find(superinheritanceId));
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
var @interface = new InterfaceBuilder(domain, interfaceId).WithSingularName("Interface").WithPluralName("Interfaces").Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNotNull(metapopulation.Find(interfaceId) as Interface);
Assert.IsNull(metapopulation.Find(classId));
Assert.IsNull(metapopulation.Find(inheritanceId));
Assert.IsNull(metapopulation.Find(relationTypeId));
Assert.IsNull(metapopulation.Find(associationTypeId));
Assert.IsNull(metapopulation.Find(roleTypeId));
Assert.IsNull(metapopulation.Find(superunitId));
Assert.IsNull(metapopulation.Find(superinterfaceId));
Assert.IsNull(metapopulation.Find(superclassId));
Assert.IsNull(metapopulation.Find(superinheritanceId));
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
var @class = new ClassBuilder(domain, classId).WithSingularName("Class").WithPluralName("Classes").Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNotNull(metapopulation.Find(interfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(classId) as Class);
Assert.IsNull(metapopulation.Find(inheritanceId));
Assert.IsNull(metapopulation.Find(relationTypeId));
Assert.IsNull(metapopulation.Find(associationTypeId));
Assert.IsNull(metapopulation.Find(roleTypeId));
Assert.IsNull(metapopulation.Find(superunitId));
Assert.IsNull(metapopulation.Find(superinterfaceId));
Assert.IsNull(metapopulation.Find(superclassId));
Assert.IsNull(metapopulation.Find(superinheritanceId));
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
new InheritanceBuilder(domain, inheritanceId).WithSubtype(@class).WithSupertype(@interface).Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNotNull(metapopulation.Find(interfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(classId) as Class);
Assert.IsNotNull(metapopulation.Find(inheritanceId) as Inheritance);
Assert.IsNull(metapopulation.Find(relationTypeId));
Assert.IsNull(metapopulation.Find(associationTypeId));
Assert.IsNull(metapopulation.Find(roleTypeId));
Assert.IsNull(metapopulation.Find(superunitId));
Assert.IsNull(metapopulation.Find(superinterfaceId));
Assert.IsNull(metapopulation.Find(superclassId));
Assert.IsNull(metapopulation.Find(superinheritanceId));
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
new RelationTypeBuilder(domain, relationTypeId, associationTypeId, roleTypeId).WithObjectTypes(@class, @interface).Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNotNull(metapopulation.Find(interfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(classId) as Class);
Assert.IsNotNull(metapopulation.Find(inheritanceId) as Inheritance);
Assert.IsNotNull(metapopulation.Find(relationTypeId) as RelationType);
Assert.IsNotNull(metapopulation.Find(associationTypeId) as AssociationType);
Assert.IsNotNull(metapopulation.Find(roleTypeId) as RoleType);
Assert.IsNull(metapopulation.Find(superunitId));
Assert.IsNull(metapopulation.Find(superinterfaceId));
Assert.IsNull(metapopulation.Find(superclassId));
Assert.IsNull(metapopulation.Find(superinheritanceId));
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
new UnitBuilder(superdomain, superunitId).WithSingularName("AllorsInteger").WithPluralName("AllorsIntegers").WithUnitTag(UnitTags.AllorsInteger).Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNotNull(metapopulation.Find(interfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(classId) as Class);
Assert.IsNotNull(metapopulation.Find(inheritanceId) as Inheritance);
Assert.IsNotNull(metapopulation.Find(relationTypeId) as RelationType);
Assert.IsNotNull(metapopulation.Find(associationTypeId) as AssociationType);
Assert.IsNotNull(metapopulation.Find(roleTypeId) as RoleType);
Assert.IsNotNull(metapopulation.Find(superunitId) as Unit);
Assert.IsNull(metapopulation.Find(superinterfaceId));
Assert.IsNull(metapopulation.Find(superclassId));
Assert.IsNull(metapopulation.Find(superinheritanceId));
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
var @superinterface = new InterfaceBuilder(superdomain, superinterfaceId).WithSingularName("SuperInterface").WithPluralName("SuperInterfaces").Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNotNull(metapopulation.Find(interfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(classId) as Class);
Assert.IsNotNull(metapopulation.Find(inheritanceId) as Inheritance);
Assert.IsNotNull(metapopulation.Find(relationTypeId) as RelationType);
Assert.IsNotNull(metapopulation.Find(associationTypeId) as AssociationType);
Assert.IsNotNull(metapopulation.Find(roleTypeId) as RoleType);
Assert.IsNotNull(metapopulation.Find(superunitId) as Unit);
Assert.IsNotNull(metapopulation.Find(superinterfaceId) as Interface);
Assert.IsNull(metapopulation.Find(superclassId));
Assert.IsNull(metapopulation.Find(superinheritanceId));
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
var @superclass = new ClassBuilder(superdomain, superclassId).WithSingularName("SuperClass").WithPluralName("SuperClasses").Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNotNull(metapopulation.Find(interfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(classId) as Class);
Assert.IsNotNull(metapopulation.Find(inheritanceId) as Inheritance);
Assert.IsNotNull(metapopulation.Find(relationTypeId) as RelationType);
Assert.IsNotNull(metapopulation.Find(associationTypeId) as AssociationType);
Assert.IsNotNull(metapopulation.Find(roleTypeId) as RoleType);
Assert.IsNotNull(metapopulation.Find(superunitId) as Unit);
Assert.IsNotNull(metapopulation.Find(superinterfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(superclassId) as Class);
Assert.IsNull(metapopulation.Find(superinheritanceId));
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
new InheritanceBuilder(superdomain, superinheritanceId).WithSubtype(@superclass).WithSupertype(@superinterface).Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNotNull(metapopulation.Find(interfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(classId) as Class);
Assert.IsNotNull(metapopulation.Find(inheritanceId) as Inheritance);
Assert.IsNotNull(metapopulation.Find(relationTypeId) as RelationType);
Assert.IsNotNull(metapopulation.Find(associationTypeId) as AssociationType);
Assert.IsNotNull(metapopulation.Find(roleTypeId) as RoleType);
Assert.IsNotNull(metapopulation.Find(superunitId) as Unit);
Assert.IsNotNull(metapopulation.Find(superinterfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(superclassId) as Class);
Assert.IsNotNull(metapopulation.Find(superinheritanceId) as Inheritance);
Assert.IsNull(metapopulation.Find(superrelationTypeId));
Assert.IsNull(metapopulation.Find(superassociationTypeId));
Assert.IsNull(metapopulation.Find(superroleTypeId));
new RelationTypeBuilder(superdomain, superrelationTypeId, superassociationTypeId, superroleTypeId).WithObjectTypes(@superclass, @superinterface).Build();
Assert.IsNotNull(metapopulation.Find(unitId) as Unit);
Assert.IsNotNull(metapopulation.Find(interfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(classId) as Class);
Assert.IsNotNull(metapopulation.Find(inheritanceId) as Inheritance);
Assert.IsNotNull(metapopulation.Find(relationTypeId) as RelationType);
Assert.IsNotNull(metapopulation.Find(associationTypeId) as AssociationType);
Assert.IsNotNull(metapopulation.Find(roleTypeId) as RoleType);
Assert.IsNotNull(metapopulation.Find(superunitId) as Unit);
Assert.IsNotNull(metapopulation.Find(superinterfaceId) as Interface);
Assert.IsNotNull(metapopulation.Find(superclassId) as Class);
Assert.IsNotNull(metapopulation.Find(superinheritanceId) as Inheritance);
Assert.IsNotNull(metapopulation.Find(superrelationTypeId) as RelationType);
Assert.IsNotNull(metapopulation.Find(superassociationTypeId) as AssociationType);
Assert.IsNotNull(metapopulation.Find(superroleTypeId) as RoleType);
}
internal ModuleScope(EmitContext emitContext, ClassBuilder classBuilder)
: base(emitContext)
{
ClassBuilder = classBuilder;
}
