public NamespaceDecorator(PropertyTypeNode container, StringBuffer sb) { _sb = sb; _container = container; GenerateHeader(); }
private static string GenerateInitializerFromProperty( PropertyTypeNode.TypeTag containerTypeTag, PropertyTypeNode propertyType) { // No initializer for structs if (containerTypeTag == PropertyTypeNode.TypeTag.Struct) { return(string.Empty); } var type = TypeDeclarationStringForProperty(propertyType); if (PropertyTypeNode.IsEnumerableType(propertyType.Tag) || propertyType.Tag == PropertyTypeNode.TypeTag.Struct) { // TODO value type etc. return($"new {type} {{}}"); } if (propertyType.Tag == PropertyTypeNode.TypeTag.Class) { return($"new {type} ()"); } return(!string.IsNullOrEmpty(propertyType.DefaultValue) ? propertyType.DefaultValue : string.Empty); }
private void GeneratePropertyBag(PropertyTypeNode c, List <string> propertyNames, Scope scope) { var gen = scope.Code; gen.Append(' ', Style.Space * 1); gen.Append($"public IPropertyBag PropertyBag => {PropertyBagStaticVarName};"); gen.Append(Environment.NewLine); gen.Append(Environment.NewLine); gen.Append(' ', Style.Space * 1); const AccessModifiers modifiers = AccessModifiers.Private | AccessModifiers.Static | AccessModifiers.Readonly; gen.Append($"{string.Join(" ", ModifiersToStrings(modifiers))} PropertyBag {PropertyBagStaticVarName};"); // TODO should be ordered (after property wrappers creation) var propertyBagInitializers = propertyNames != null ? string.Join(", ", propertyNames) : string.Empty; var initializer = $@"new PropertyBag(new List<IProperty>{{ {propertyBagInitializers} }}.ToArray())"; AddStaticConstructorInStageFragment( ConstructorStage.PropertyInitializationStage, new CSharpGenerationFragmentContext() { Scope = scope, Fragment = $"{PropertyBagStaticVarName} = {initializer};" }) ; gen.Append(Environment.NewLine); gen.Append(Environment.NewLine); }
private static string GeneratePropertyBackingField( string propertyName, PropertyTypeNode propertyType, out string propertyAccessorName) { if (propertyType.IsCustomProperty) { propertyAccessorName = string.Empty; return(string.Empty); } propertyAccessorName = $"m_{propertyName}"; if (string.IsNullOrEmpty(propertyType.PropertyBackingAccessor)) { var modifiers = AccessModifiers.Private; // @TODO // | (PropertyTypeNode.IsCompositeType(propertyType.Tag) ? AccessModifiers.Readonly : AccessModifiers.None); return(GenerateBackingField( TypeDeclarationStringForProperty(propertyType), propertyName, modifiers )); } // TODO check & get by id instead of by name var propertyAccessorDelegate = propertyType.PropertyBackingAccessor; propertyAccessorName = $"{propertyAccessorDelegate}"; return(string.Empty); }
private static string GetPropertyWrapperTypeFor( string containerName, PropertyTypeNode.TypeTag containerTypeTag, PropertyTypeNode propertyType) { // @TODO warning we rely on type definitions here var propertyWrapperTypeStringPrefix = ""; if (containerTypeTag.HasFlag(PropertyTypeNode.TypeTag.Struct)) { propertyWrapperTypeStringPrefix = "Struct"; } switch (propertyType.Tag) { case PropertyTypeNode.TypeTag.Struct: return($"{propertyWrapperTypeStringPrefix}MutableContainerProperty<{containerName}, {propertyType.TypeName}>"); case PropertyTypeNode.TypeTag.Class: return($"{propertyWrapperTypeStringPrefix}ContainerProperty<{containerName}, {propertyType.TypeName}>"); case PropertyTypeNode.TypeTag.Enum: return($"{propertyWrapperTypeStringPrefix}EnumProperty<{containerName}, {propertyType.TypeName}>"); case PropertyTypeNode.TypeTag.List: { var t = TypeStringFromEnumerableProperty(propertyType); switch (propertyType.Of.Tag) { case PropertyTypeNode.TypeTag.Primitive: return($"{propertyWrapperTypeStringPrefix}ListProperty<{containerName}, {t}, {propertyType.Of.TypeName}>"); case PropertyTypeNode.TypeTag.Struct: return($"{propertyWrapperTypeStringPrefix}MutableContainerListProperty<{containerName}, {t}, {propertyType.Of.TypeName}>"); case PropertyTypeNode.TypeTag.Class: return($"{propertyWrapperTypeStringPrefix}ContainerListProperty<{containerName}, {t}, {propertyType.Of.TypeName}>"); case PropertyTypeNode.TypeTag.Enum: return($"{propertyWrapperTypeStringPrefix}EnumListProperty<{containerName}, {t}, {propertyType.Of.TypeName}>"); case PropertyTypeNode.TypeTag.Unknown: case PropertyTypeNode.TypeTag.List: default: throw new Exception($"Invalid property tag of list property name {propertyType.PropertyName}"); } } case PropertyTypeNode.TypeTag.Primitive: return($"{propertyWrapperTypeStringPrefix}Property<{containerName}, {propertyType.TypeName}>"); default: break; } return($"{propertyWrapperTypeStringPrefix}Property<{containerName}, {propertyType.TypeName}>"); }
private void GenerateStaticConstructorFor( PropertyTypeNode c, StringBuffer gen) { var containerTypeName = c.TypeName; gen.Append(' ', Style.Space * 1); gen.Append($"static {containerTypeName} (){Environment.NewLine}"); gen.Append(' ', Style.Space * 1); gen.Append("{"); gen.Append(Environment.NewLine); // Handle property initializers generation stage StaticConstructorStagePrePostFragments stageFragments; if (StaticConstructorInitializerFragments.TryGetValue(ConstructorStage.PropertyInitializationStage, out stageFragments)) { var fragments = stageFragments.InStageFragments; if (fragments.Count != 0) { gen.Append(' ', Style.Space * 2); gen.Append("// Property wrappers initializers"); gen.Append(Environment.NewLine); GenerateFragments(fragments, gen); } // Handle property initializers post generation stage (user hooks etc.) fragments = stageFragments.PostStageFragments; if (fragments.Count != 0) { gen.Append(Environment.NewLine); gen.Append(' ', Style.Space * 2); gen.Append("// User Hooks"); gen.Append(Environment.NewLine); GenerateFragments(fragments, gen); } } gen.Append(Environment.NewLine); gen.Append(' ', Style.Space * 2); gen.Append("// Freeze property bag items"); foreach (var item in PropertyBagItemNames) { gen.Append(Environment.NewLine); gen.Append(' ', Style.Space * 2); gen.Append($"// {item}.Freeze();"); } gen.Append(Environment.NewLine); gen.Append(' ', Style.Space * 1); gen.Append("}"); gen.Append(Environment.NewLine); }
private static string TypeDeclarationStringForProperty(PropertyTypeNode propertyType) { if (PropertyTypeNode.IsEnumerableType(propertyType.Tag)) { return(TypeStringFromEnumerableProperty(propertyType)); } return(propertyType.TypeName); }
private static string GeneratePropertyWrapperInitializers( PropertyTypeNode propertyType, string containerName, PropertyTypeNode.TypeTag containerTypeTag, string propertyWrapperTypeString, string propertyAccessorName, string propertyTypeString, Scope code ) { var initializerParams = new List <string>(); var accessors = GetPropertyWrapperAccessors( propertyType, containerName, containerTypeTag, propertyWrapperTypeString, propertyTypeString, propertyAccessorName); // @TODO shouldn't be done here, and be located in a cleaner place #if ENABLE_CUSTOM_PROPERTY_PARTIALS if (propertyType.IsCustomProperty) { var containerAsAParemeterType = containerTypeTag.HasFlag(PropertyTypeNode.TypeTag.Struct) ? $"ref {containerName}" : $"{containerName}"; code.AddLine(""); if (!string.IsNullOrEmpty(accessors.RefGetter)) { code.AddLine( $"partial void {accessors.RefGetter}({containerAsAParemeterType} value, IPropertyVisitor visitor);"); } code.AddLine($"partial void {accessors.ValueSetter}({containerAsAParemeterType} container, {propertyTypeString} value);"); code.AddLine( $"partial {propertyTypeString} {accessors.ValueGetter}({containerAsAParemeterType} container);"); code.AddLine(""); } #endif initializerParams.Add($"nameof({propertyType.PropertyName})"); initializerParams.Add(accessors.ValueGetter); initializerParams.Add(accessors.ValueSetter); if (!string.IsNullOrEmpty(accessors.RefGetter)) { initializerParams.Add(accessors.RefGetter); } return($@"new { propertyWrapperTypeString }( {string.Join(", ", initializerParams)} )"); }
private static void ParsePropertyContainer( PropertyTypeNode s, Dictionary <string, PropertyTypeNode> symbolsTable) { if (s == null || s.RawNode == null) { return; } var d = s.RawNode; var containerName = s.Name; if (d.ContainsKey(SerializedKeys.ConstructedFromeKey)) { var constructorParams = d[SerializedKeys.ConstructedFromeKey] as IEnumerable; var paramTypes = new List <KeyValuePair <string, string> >(); if (constructorParams != null) { paramTypes.AddRange(from object p in constructorParams select p as IDictionary <string, object> into dp let paramType = dp.ContainsKey(SerializedKeys.PropertyTypeKey) ? (dp[SerializedKeys.PropertyTypeKey] as string) : "" let paramName = dp.ContainsKey(SerializedKeys.PropertyNameKey) ? (dp[SerializedKeys.PropertyNameKey] as string) : "" where !string.IsNullOrEmpty(paramName) && !string.IsNullOrEmpty(paramType) select new KeyValuePair <string, string>(paramType, paramName)); } s.Constructor.ParameterTypes = paramTypes; } if (d.ContainsKey(SerializedKeys.PropertiesListKey)) { // Empty props if not var properties = d[SerializedKeys.PropertiesListKey] as IDictionary <string, object>; if (properties == null) { return; } foreach (var k in properties.Keys) { var propertyName = k; var property = properties[propertyName] as IDictionary <string, object>; s.Children.Add(ParseProperty(propertyName, property, symbolsTable)); } } }
private static string TypeDeclarationStringForProperty(PropertyTypeNode propertyType) { if (PropertyTypeNode.IsEnumerableType(propertyType.Tag)) { if (propertyType.Tag == PropertyTypeNode.TypeTag.Array) { return($"{propertyType.Of.TypeName}[]"); } // TODO value type etc. return(TypeStringFromEnumerableProperty(propertyType)); } return(propertyType.TypeName); }
private static Dictionary <string, object> SerializeTypeTreeToJson(PropertyTypeNode node) { var o = new List <Dictionary <string, object> >(); foreach (var child in node.NestedContainers) { o.Add(SerializeTypeTreeToJson(child)); } var serializedContainer = SerializePropertyContainerToJson(node); serializedContainer[JsonSchema.Keys.NestedTypesKey] = o; return(serializedContainer); }
public void GeneratePropertyContainer( PropertyTypeNode container, Func <string, CSharpGenerationCache.CodeInfo> dependancyLookupFunc = null) { ResetInternalGenerationStates(); StringBuffer gen = new StringBuffer(); using (new NamespaceDecorator(container, DoGenerateNamespace ? gen : null)) { GeneratePropertyContainerFor( container, dependancyLookupFunc, gen); } Code = gen; }
private List <PropertyTypeNode> TypeDefinitionsToPropertyTypes(Dictionary <string, TypeDefinition> definitions) { var roots = new List <PropertyTypeNode>(); foreach (var kv in _typesBeingSerialized) { var typeName = kv.Key; PropertyTypeNode node = null; if (GetOrCreate(typeName, out node)) { Assert.IsNotNull(node); roots.Add(node); } } return(roots); }
public PropertyContainerDataTypeDecorator( PropertyTypeNode containerNode, StringBuffer sb, List <string> baseClasses = null) { _sb = sb; _containerNode = containerNode; if (baseClasses != null) { foreach (var bc in baseClasses) { WithBaseClass(bc); } } GenerateHeader(); }
private static PropertyWrapperAccessors GetPropertyWrapperAccessors( PropertyTypeNode propertyType, string containerName, PropertyTypeNode.TypeTag containerTypeTag, string propertyWrapperTypeString, string propertyTypeString, string propertyAccessorName) { if (propertyType.IsCustomProperty) { return(new PropertyWrapperAccessors() { ValueGetter = $"GetValue_{CleanupNameForMethod(propertyType.PropertyName)}", ValueSetter = $"SetValue_{CleanupNameForMethod(propertyType.PropertyName)}", RefGetter = propertyType.Tag == PropertyTypeNode.TypeTag.Struct ? $"GetRef_{CleanupNameForMethod(propertyType.PropertyName)}" : string.Empty }); } var containerAsAParemeterType = containerTypeTag.HasFlag(PropertyTypeNode.TypeTag.Struct) ? $"ref {containerName}" : $"{containerName}"; var propertySetter = "/* SET */ null"; if (!PropertyTypeNode.IsCompositeType(propertyType.Tag) && !propertyType.IsReadonly) { propertySetter = $"/* SET */ ({containerAsAParemeterType} container, {propertyTypeString} value) => container.{propertyAccessorName} = value"; } var propertyRefGetter = string.Empty; if (propertyType.Tag == PropertyTypeNode.TypeTag.Struct) { propertyRefGetter = $"/* REF */ ({containerAsAParemeterType} container, {propertyWrapperTypeString}.RefVisitMethod a, IPropertyVisitor v) => a(ref container.m_{propertyType.PropertyName}, v)"; } return(new PropertyWrapperAccessors() { ValueGetter = $"/* GET */ ({containerAsAParemeterType} container) => container.{propertyAccessorName}", ValueSetter = propertySetter, RefGetter = propertyRefGetter }); }
SerializePropertyFieldsForType(PropertyTypeNode type) { var properties = new List <object>(); foreach (var property in type.Properties) { var propertyFielsMap = new Dictionary <string, object> { [JsonSchema.Keys.PropertyNameKey] = property.PropertyName, [JsonSchema.Keys.PropertyTypeKey] = property.TypeName }; if (property.Of != null) { propertyFielsMap[JsonSchema.Keys.PropertyItemTypeKey] = property.Of != null ? property.Of.TypeName : string.Empty; } if (property.IsReadonly != PropertyTypeNode.Defaults.IsReadonly) { propertyFielsMap[JsonSchema.Keys.IsReadonlyPropertyKey] = property.IsReadonly; } if (property.IsCustomProperty != PropertyTypeNode.Defaults.IsCustomProperty) { propertyFielsMap[JsonSchema.Keys.IsCustomPropertyKey] = property.IsCustomProperty; } if (property.IsPublicProperty != PropertyTypeNode.Defaults.IsPublicProperty) { propertyFielsMap[JsonSchema.Keys.PropertyIsPublicKey] = property.IsPublicProperty; } if (property.DontInitializeBackingField != PropertyTypeNode.Defaults.DontInitializeBackingField) { propertyFielsMap[JsonSchema.Keys.DontInitializeBackingFieldKey] = property.DontInitializeBackingField; } properties.Add(propertyFielsMap); } return(properties); }
private static string GeneratePropertyWrapperBackingVariable( string propertyWrapperTypeName, PropertyTypeNode.TypeTag containerTypeTag, PropertyTypeNode propertyType) { var accessModifiers = AccessModifiers.Static | AccessModifiers.Readonly; if (containerTypeTag == PropertyTypeNode.TypeTag.Class) { accessModifiers |= (propertyType.IsPublicProperty ? AccessModifiers.Public : AccessModifiers.Protected); } else { accessModifiers |= AccessModifiers.Private; } var modifiers = string.Join(" ", ModifiersToStrings(accessModifiers)); var propertyWrapperVariableName = GetPropertyWrapperVariableName(propertyType); return($@"{modifiers} {propertyWrapperTypeName} {propertyWrapperVariableName};"); }
private static string GeneratePropertyWrapperInitializer( string propertyName, string containerName, PropertyTypeNode.TypeTag containerTypeTag, string propertyWrapperTypeString, bool isReadonlyProperty, string propertyAccessorName, string propertyTypeString, PropertyTypeNode.TypeTag propertyTypeTag ) { List <string> initializerParams = new List <string>(); var containerAsAParemeterType = containerTypeTag.HasFlag(PropertyTypeNode.TypeTag.Struct) ? $"ref {containerName}" : $"{containerName}"; initializerParams.Add($"nameof({propertyName})"); initializerParams.Add($"/* GET */ ({containerAsAParemeterType} container) => container.{propertyAccessorName}"); var propertySetter = "/* SET */ null"; if (!PropertyTypeNode.IsCompositeType(propertyTypeTag) && !isReadonlyProperty) { propertySetter = $"/* SET */ ({containerAsAParemeterType} container, {propertyTypeString} value) => container.{propertyAccessorName} = value"; } initializerParams.Add(propertySetter); if (propertyTypeTag == PropertyTypeNode.TypeTag.Struct) { initializerParams.Add( $"/* REF */ ({containerAsAParemeterType} container, {propertyWrapperTypeString}.RefVisitMethod a, IPropertyVisitor v) => a(ref container.m_{propertyName}, v)" ); } string parameters = string.Join(", ", initializerParams); return($@"new { propertyWrapperTypeString }( {parameters} )"); }
private static List <string> DependantAssemblyNamesFor(PropertyTypeNode typeNode) { var assemblyNames = new List <string>(); if (typeNode == null) { return(assemblyNames); } if (typeNode.NativeType != null) { assemblyNames.Add(typeNode.NativeType.Assembly.GetName().Name); } foreach (var t in typeNode.NestedContainers) { assemblyNames.AddRange(DependantAssemblyNamesFor(t)); } foreach (var p in typeNode.Properties) { assemblyNames.AddRange(DependantAssemblyNamesFor(p)); } return(assemblyNames); }
private static void GenerateClassPropertiesForPropertyAccessor( PropertyTypeNode.TypeTag containerTypeTag, PropertyTypeNode propertyType, Scope code ) { var containerAsAParamTokens = new List <string> { }; if (containerTypeTag.HasFlag(PropertyTypeNode.TypeTag.Struct)) { containerAsAParamTokens.Add("ref"); } containerAsAParamTokens.Add("this"); var getSetValueCallContainerParam = string.Join(" ", containerAsAParamTokens); var propertyWrapperVariableName = GetPropertyWrapperVariableName(propertyType); var propertyTypeString = TypeDeclarationStringForProperty(propertyType); var isCompositeType = PropertyTypeNode.IsCompositeType(propertyType.Tag); var modifiers = string.Join(" ", ModifiersToStrings(AccessModifiers.Public)); code.AddLine($"{modifiers} {propertyTypeString} {propertyType.PropertyName}"); { code.AddLine("{"); var accessorScope = new Scope(code); accessorScope.AddLine($"get {{ return {propertyWrapperVariableName}.GetValue({getSetValueCallContainerParam}); }}"); if (!isCompositeType) { accessorScope.AddLine($"set {{ {propertyWrapperVariableName}.SetValue({getSetValueCallContainerParam}, value); }}"); } code.AddLine("}"); } }
private void GenerateUserHooksFor(PropertyTypeNode c, Scope scope) { if (c.UserHooks.HasFlag(UserHookFlags.OnPropertyBagConstructed)) { GenerateUserHook( scope.Code, OnPropertyBagConstructedMethodName, new List <string>() { "IPropertyBag bag" }); // Add a post property construction stage for that hook call AddStaticConstructorPostStageFragment( ConstructorStage.PropertyInitializationStage, new CSharpGenerationFragmentContext() { Scope = scope, Fragment = $"{OnPropertyBagConstructedMethodName}({PropertyBagStaticVarName});" }); } }
SerializePropertyContainerToJson(PropertyTypeNode type) { var serializedContainer = new Dictionary <string, object> { [JsonSchema.Keys.ContainerNameKey] = type.TypeName, [JsonSchema.Keys.ContainerIsStructKey] = type.Tag == PropertyTypeNode.TypeTag.Struct, [JsonSchema.Keys.PropertiesListKey] = SerializePropertyFieldsForType(type) }; if (!string.IsNullOrEmpty(type.TypePath.Namespace)) { serializedContainer[JsonSchema.Keys.NamespaceKey] = type.TypePath.Namespace; } if (type.IsAbstractClass != PropertyTypeNode.Defaults.IsAbstractClass) { serializedContainer[JsonSchema.Keys.IsAbstractClassKey] = type.IsAbstractClass; } if (type.NoDefaultImplementation != PropertyTypeNode.Defaults.NoDefaultImplementation) { serializedContainer[JsonSchema.Keys.NoDefaultImplementationKey] = type.NoDefaultImplementation; } if (!string.IsNullOrEmpty(type.OverrideDefaultBaseClass)) { serializedContainer[JsonSchema.Keys.OverrideDefaultBaseClassKey] = type.OverrideDefaultBaseClass; } if (type.UserHooks.HasFlag(UserHookFlags.OnPropertyBagConstructed)) { serializedContainer[JsonSchema.Keys.GeneratedUserHooksKey] = UserHookFlags.OnPropertyBagConstructed.ToString(); } return(serializedContainer); }
private static string GetPropertyWrapperTypeFor( string containerName, PropertyTypeNode.TypeTag containerTypeTag, PropertyTypeNode propertyType) { // TODO warning we rely on type definitions here var propertyWrapperTypeStringPrefix = ""; if (containerTypeTag.HasFlag(PropertyTypeNode.TypeTag.Struct)) { propertyWrapperTypeStringPrefix = "Struct"; } switch (propertyType.Tag) { case PropertyTypeNode.TypeTag.Struct: return($"{propertyWrapperTypeStringPrefix}MutableContainerProperty<{containerName}, {propertyType.TypeName}>"); case PropertyTypeNode.TypeTag.Class: return($"{propertyWrapperTypeStringPrefix}ContainerProperty<{containerName}, {propertyType.TypeName}>"); case PropertyTypeNode.TypeTag.Enum: return($"{propertyWrapperTypeStringPrefix}EnumProperty<{containerName}, {propertyType.TypeName}>"); case PropertyTypeNode.TypeTag.Array: case PropertyTypeNode.TypeTag.List: { var t = TypeStringFromEnumerableProperty(propertyType); return($"{propertyWrapperTypeStringPrefix}ListProperty<{containerName}, {t}, {propertyType.Of.TypeName}>"); } default: break; } return($"{propertyWrapperTypeStringPrefix}Property<{containerName}, {propertyType.TypeName}>"); }
private static string GetPropertyWrapperVariableName(PropertyTypeNode propertyType) { string prefix = propertyType.IsPublicProperty ? string.Empty : "s_"; return($"{prefix}{propertyType.PropertyName}Property"); }
private void GeneratePropertyContainerFor( PropertyTypeNode c, Func <string, CSharpGenerationCache.CodeInfo> dependancyLookupFunc, StringBuffer gen) { var containerName = c.TypeName; var containerTypeTag = c.Tag; var baseClass = string.IsNullOrEmpty(c.OverrideDefaultBaseClass) ? "IPropertyContainer" : c.OverrideDefaultBaseClass; var rootScope = new Scope(); var shouldGeneratePRopertyContainerImplementation = !c.NoDefaultImplementation; using (var d = new PropertyContainerDataTypeDecorator(c, rootScope.Code, new List <string> { baseClass })) using (var scope = new Scope(rootScope)) { if (shouldGeneratePRopertyContainerImplementation) { if (c.Properties.Count != 0) { foreach (var propertyType in c.Properties) { GenerateProperty( containerName, containerTypeTag, propertyType, scope ); scope.AddLine(""); } scope.AddLine(""); } GenerateUserHooksFor(c, scope); // Add inherited properties if it applies var propertyBagElementNames = PropertyBagItemNames; if (!string.IsNullOrEmpty(c.OverrideDefaultBaseClass) && dependancyLookupFunc != null) { var cachedContainer = dependancyLookupFunc(c.OverrideDefaultBaseClass); if (cachedContainer != null) { propertyBagElementNames = PropertyBagItemNames.Select(n => n).ToList(); propertyBagElementNames.AddRange(cachedContainer.GeneratedPropertyFieldNames); } } GeneratePropertyBag( c, propertyBagElementNames, scope); GenerateConstructorFor(c, scope.Code); GenerateStaticConstructorFor(c, scope.Code); // @TODO Cleanup // Recurse to collect nested container definitions foreach (var nestedContainer in c.NestedContainers) { if (nestedContainer == null) { continue; } var g = new CSharpContainerGenerator() { DoGenerateNamespace = false }; g.GeneratePropertyContainer(nestedContainer, dependancyLookupFunc); if (!string.IsNullOrEmpty(g.Code.ToString())) { scope.AddLine(string.Empty); scope.AddLine(string.Empty); scope.AddLine(g.Code.ToString()); scope.AddLine(string.Empty); scope.AddLine(string.Empty); } } scope.AddLine("public IVersionStorage VersionStorage => DefaultVersionStorage.Instance;"); scope.AddLine(Environment.NewLine); } } gen.Append(rootScope.Code); }
public override void OnPropertyContainerGenerationCompleted(PropertyTypeNode c) { throw new NotImplementedException(); }
private static string TypeStringFromEnumerableProperty(PropertyTypeNode propertyType) { return($"{propertyType.TypeName}<{propertyType.Of.TypeName}>"); }
private void GenerateConstructorFor( PropertyTypeNode c, StringBuffer gen) { var constructor = c.Constructor; if (constructor == null) { return; } if (c.Tag == PropertyTypeNode.TypeTag.Struct && constructor.ParameterTypes.Count == 0) { // baild out for struct + no param constructor return; } if (c.Tag == PropertyTypeNode.TypeTag.Class && c.Properties.Count == 0) { // baild out for class + no properties return; } var containerTypeName = c.TypeName; int i = 0; var i1 = i; gen.Append(' ', Style.Space * 1); gen.Append( $"public {containerTypeName} ({string.Join(",", constructor.ParameterTypes.Select(p => $"{p.Key} p{i1}"))}){Environment.NewLine}" ); gen.Append(' ', Style.Space * 1); gen.Append("{"); // Generate constructor param -> field init i = 0; foreach (var paramType in constructor.ParameterTypes) { gen.Append(' ', Style.Space * 2); gen.Append($"{paramType.Value} = p{i};\n"); } // Generate property initializers if (ConstructorInitializerFragments.Count != 0) { gen.Append(Environment.NewLine); gen.Append(' ', Style.Space * 2); gen.Append("// Property backing field initializers"); gen.Append(Environment.NewLine); foreach (var fragment in ConstructorInitializerFragments) { var codeFragment = fragment as CSharpGenerationFragmentContext; if (codeFragment != null) { gen.Append(' ', Style.Space * 2); gen.Append(codeFragment.Fragment); gen.Append(Environment.NewLine); } } } gen.Append(' ', Style.Space * 1); gen.Append("}"); gen.Append(Environment.NewLine); }
public void GenerateProperty( string containerName, PropertyTypeNode.TypeTag containerTypeTag, PropertyTypeNode propertyType, Scope code) { // Public C# Property & backing field GenerateClassPropertiesForPropertyAccessor(containerTypeTag, propertyType, code); var propertyWrapperTypeName = GetPropertyWrapperTypeFor( containerName, containerTypeTag, propertyType); code.AddLine(GeneratePropertyWrapperBackingVariable( propertyWrapperTypeName, containerTypeTag, propertyType)); // Backing field if any var propertyAccessorName = string.Empty; var backingField = GeneratePropertyBackingField( propertyType.PropertyName, propertyType, out propertyAccessorName ); if (!string.IsNullOrEmpty(backingField)) { // If we have a class we delegate init to constructor otherwise we default construct here var initializer = GenerateInitializerFromProperty(containerTypeTag, propertyType); var initializerFragment = backingField; if (!string.IsNullOrEmpty(initializer) && !propertyType.DontInitializeBackingField) { initializerFragment += $" = {initializer}"; } initializerFragment += ";"; code.AddLine(initializerFragment); } // -> Add constructor initializer fragments for later stage for that property var propertyTypeString = TypeDeclarationStringForProperty(propertyType); var propertyWrapperVariableName = GetPropertyWrapperVariableName(propertyType); { var initializer = GeneratePropertyWrapperInitializers( propertyType, containerName, containerTypeTag, propertyWrapperTypeName, propertyAccessorName, propertyTypeString, code); AddStaticConstructorInStageFragment( ConstructorStage.PropertyInitializationStage, new CSharpGenerationFragmentContext() { Scope = code, Fragment = $"{propertyWrapperVariableName} = {initializer};" }); } PropertyBagItemNames.Add(propertyWrapperVariableName); }
public override void OnGenerateNestedContainer(PropertyTypeNode container, PropertyTypeNode nestedContainer) { throw new NotImplementedException(); }