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); }
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; }