public static CodeSnippetTypeMember CreateCast(string typeT, string typeT1, bool useAutoTyping, string @namespace = "", GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { CodeSnippetTypeMember castMember = new CodeSnippetTypeMember(); @namespace = @namespace.IsNotEmpty() ? $"{@namespace}." : ""; var visibilityKeyword = visibility.ToKeyword(); var servicesClassName = @namespace + NameGenerator.GetServicesClassName(); if (useAutoTyping) { castMember.Text = String.Concat($"\t\t{visibilityKeyword} static explicit operator ", typeT, "(XElement xe) { ", "return (", typeT, ")", Constants.XTypedServices, ".ToXTypedElement(xe,", servicesClassName, ".Instance as ILinqToXsdTypeManager); }"); } else { castMember.Text = String.Concat($"\t\t{visibilityKeyword} static explicit operator ", typeT, "(XElement xe) { return ", Constants.XTypedServices, ".ToXTypedElement<", GetInnerType(typeT, typeT1), ">(xe,", servicesClassName, ".Instance as ILinqToXsdTypeManager); }"); } return(castMember); }
public static TypePropertyBuilder Create(GroupingInfo groupingInfo, CodeTypeDeclaration decl, CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { switch (groupingInfo.ContentModelType) { case ContentModelType.None: case ContentModelType.All: return(new DefaultPropertyBuilder(decl, declItems, visibility)); case ContentModelType.Sequence: if (groupingInfo.IsComplex) { return(new DefaultPropertyBuilder(decl, declItems, visibility)); } return(new SequencePropertyBuilder(groupingInfo, decl, declItems, visibility)); case ContentModelType.Choice: if (groupingInfo.IsComplex) { return(new DefaultPropertyBuilder(decl, declItems, visibility)); } return(new ChoicePropertyBuilder(groupingInfo, decl, declItems, visibility)); default: throw new InvalidOperationException(); } }
public ContentModelPropertyBuilder(ContentModelPropertyBuilder parentBuilder, GroupingInfo grouping, CodeTypeDeclaration decl, CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility) : base(decl, declItems, visibility) { this.ParentBuilder = parentBuilder; this.grouping = grouping; //The grouping the contentmodelbuilder works on }
/// <summary> /// Creates a new <see cref="Namespace"/> instance from given values. Defaults to <see cref="GeneratedTypesVisibility.Public"/> <paramref name="visibility"/>. /// </summary> /// <param name="schemaUri"></param> /// <param name="clrNamespace"></param> /// <param name="visibility"></param> /// <returns></returns> public static Namespace New(string schemaUri, string clrNamespace, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { return(new Namespace { DefaultVisibility = visibility.ToKeyword(), Schema = schemaUri.IsEmpty() ? null : new Uri(schemaUri), Clr = clrNamespace }); }
public static CodeTypeDeclaration CreateTypeDeclaration(string clrTypeName, string innerType, GeneratedTypesVisibility generatedTypesVisibility = GeneratedTypesVisibility.Public) { CodeTypeDeclaration typeDecl = new CodeTypeDeclaration(clrTypeName); typeDecl.TypeAttributes = generatedTypesVisibility.ToTypeAttribute(); typeDecl.IsPartial = true; return(typeDecl); }
public static CodeSnippetTypeMember CreateXRootGetter(string typeName, string fqTypeName, LocalSymbolTable lst, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { string symbolName = lst.AddMember(typeName); CodeSnippetTypeMember castMember = new CodeSnippetTypeMember(); castMember.Text = String.Concat("\r\n", $"\t\t{visibility.ToKeyword()} ", fqTypeName, " ", symbolName, " { get {", "return rootObject as ", fqTypeName, "; } }"); return(castMember); }
public ChoicePropertyBuilder(ContentModelPropertyBuilder parentBuilder, GroupingInfo grouping, CodeTypeDeclaration decl, CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) : base(parentBuilder, grouping, decl, declItems, visibility) { flatChoice = !grouping.IsNested && !grouping.IsRepeating && !grouping.HasChildGroups; hasDuplicateType = false; if (flatChoice) { propertyTypeNameTable = new Dictionary <string, ClrBasePropertyInfo>(); } }
public static CodeTypeMember CreateSave(string paramName, string paramType, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { CodeMemberMethod saveMethod = new CodeMemberMethod(); saveMethod.Name = "Save"; saveMethod.Attributes = (saveMethod.Attributes & ~MemberAttributes.AccessMask) | visibility.ToMemberAttribute(); saveMethod.Parameters.Add(CreateParameter(paramName, paramType)); saveMethod.Statements.Add( CreateMethodCall( new CodeTypeReferenceExpression(Constants.XTypedServices), "Save", new CodeVariableReferenceExpression(paramName), new CodePropertyReferenceExpression(null, Constants.Untyped))); return(saveMethod); }
public static CodeMemberMethod CreateXRootSave(string[][] paramList, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { CodeMemberMethod staticMethod = new CodeMemberMethod(); staticMethod.Name = "Save"; staticMethod.Attributes = visibility.ToMemberAttribute(); CodeExpression[] parameterExp = new CodeExpression[paramList.Length]; for (int i = 0; i < paramList.Length; i++) { string[] paramRef = paramList[i]; // index 0 is the type name and index 1 is the parameter name staticMethod.Parameters.Add(CreateParameter(paramRef[1], paramRef[0])); parameterExp[i] = new CodeVariableReferenceExpression(paramRef[1]); } CodeExpression doc = new CodeVariableReferenceExpression("doc"); staticMethod.Statements.Add( //root.doc = XDocument.Save(...); CreateMethodCall(doc, "Save", parameterExp)); return(staticMethod); }
public static CodeMemberMethod CreateInterfaceImplMethod(string methodName, string interfaceName, CodeTypeReference returnType, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { CodeMemberMethod interfaceMethod = CreateMethod(methodName, returnType, visibility.ToMemberAttribute()); interfaceMethod.PrivateImplementationType = new CodeTypeReference(interfaceName); interfaceMethod.ImplementationTypes.Add(new CodeTypeReference(interfaceName)); return(interfaceMethod); }
public static CodeTypeMember CreateStaticMethod(string methodName, string typeT, string typeT1, string parameterName, string parameterType, bool useAutoTyping, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { CodeMemberMethod staticMethod = new CodeMemberMethod(); staticMethod.Name = methodName; staticMethod.Attributes = MemberAttributes.Static | visibility.ToMemberAttribute(); staticMethod.ReturnType = new CodeTypeReference(typeT); staticMethod.Parameters.Add(CreateParameter(parameterName, parameterType)); CodeExpression parameterExp = new CodeVariableReferenceExpression(parameterName); if (useAutoTyping) { staticMethod.Statements.Add( new CodeMethodReturnStatement( new CodeCastExpression( staticMethod.ReturnType, CreateMethodCall( new CodeTypeReferenceExpression(Constants.XTypedServices), Constants.ToXTypedElement, CreateMethodCall(new CodeTypeReferenceExpression(Constants.XElement), methodName, parameterExp), CodeDomHelper.SingletonTypeManager())))); } else { CodeMethodInvokeExpression methodCall = CreateMethodCall( new CodeTypeReferenceExpression(Constants.XTypedServices), methodName + "<" + GetInnerType(typeT, typeT1) + ">", parameterExp); if (typeT1 != null) { methodCall.Parameters.Add(CodeDomHelper.SingletonTypeManager()); } staticMethod.Statements.Add(new CodeMethodReturnStatement(methodCall)); } return(staticMethod); }
public static TypePropertyBuilder Create(CodeTypeDeclaration decl, CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { return(new DefaultPropertyBuilder(decl, declItems, visibility)); }
internal DefaultPropertyBuilder(CodeTypeDeclaration decl, CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) : base(decl, declItems, visibility) { }
public TypePropertyBuilder(CodeTypeDeclaration decl, CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility) { this.decl = decl; this.declItems = declItems; this.visibility = visibility; }
public SequencePropertyBuilder(ContentModelPropertyBuilder parentBuilder, GroupingInfo grouping, CodeTypeDeclaration decl, CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) : base(parentBuilder, grouping, decl, declItems, visibility) { }
/// <summary> /// Converts <see cref="GeneratedTypesVisibility"/> to an appropriate <see cref="TypeAttributes"/> instance. /// </summary> /// <param name="gtv"></param> /// <returns></returns> public static TypeAttributes ToTypeAttribute(this GeneratedTypesVisibility gtv) => gtv.HasFlag(GeneratedTypesVisibility.Internal) || gtv == GeneratedTypesVisibility.Internal ? TypeAttributes.NestedAssembly : TypeAttributes.Public;
public static CodeMemberMethod CreateXRootMethod(string returnType, string methodName, string[][] paramList, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { CodeTypeReference xRootType = new CodeTypeReference(returnType); CodeMemberMethod staticMethod = new CodeMemberMethod(); staticMethod.Name = methodName; staticMethod.Attributes = visibility.ToMemberAttribute() | MemberAttributes.Static; staticMethod.ReturnType = xRootType; CodeExpression[] parameterExp = new CodeExpression[paramList.Length]; for (int i = 0; i < paramList.Length; i++) { string[] paramRef = paramList[i]; // index 0 is the type name and index 1 is the parameter name staticMethod.Parameters.Add(CreateParameter(paramRef[1], paramRef[0])); parameterExp[i] = new CodeVariableReferenceExpression(paramRef[1]); } CodeExpression rootExp = new CodeVariableReferenceExpression("root"); CodeExpression doc = new CodeFieldReferenceExpression(rootExp, "doc"); staticMethod.Statements.Add( //XRoot root = new XRoot; new CodeVariableDeclarationStatement(xRootType, "root", new CodeObjectCreateExpression(xRootType))); staticMethod.Statements.Add( //root.doc = XDocument.Load(xmlFile); new CodeAssignStatement( doc, CreateMethodCall(new CodeTypeReferenceExpression("XDocument"), methodName, parameterExp))); staticMethod.Statements.Add( //XTypedElement typedRoot = XTypedServices.ToXTypedElement(....) new CodeVariableDeclarationStatement( Constants.XTypedElement, "typedRoot", CreateMethodCall( new CodeTypeReferenceExpression(Constants.XTypedServices), Constants.ToXTypedElement, new CodePropertyReferenceExpression(doc, "Root"), CodeDomHelper.SingletonTypeManager()))); staticMethod.Statements.Add( //if(typedRoot == null) new CodeConditionStatement( new CodeBinaryOperatorExpression( new CodeVariableReferenceExpression("typedRoot"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(null) ), new CodeThrowExceptionStatement( new CodeObjectCreateExpression(Constants.LinqToXsdException, new CodePrimitiveExpression("Invalid root element in xml document.")) ))); staticMethod.Statements.Add( //root.rootObject = typedRoot new CodeAssignStatement( new CodeFieldReferenceExpression(rootExp, "rootObject"), new CodeVariableReferenceExpression("typedRoot"))); staticMethod.Statements.Add( //return root; new CodeMethodReturnStatement(rootExp)); return(staticMethod); }
/// <summary> /// Converts <see cref="GeneratedTypesVisibility"/> to an appropriate <see cref="MemberAttributes"/> instance. /// </summary> /// <param name="gtv"></param> /// <returns></returns> public static MemberAttributes ToMemberAttribute(this GeneratedTypesVisibility gtv) => gtv.HasFlag(GeneratedTypesVisibility.Internal) || gtv == GeneratedTypesVisibility.Internal ? MemberAttributes.Assembly : MemberAttributes.Public;
public static CodeConstructor CreateXRootFunctionalConstructor(string typeName, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { CodeConstructor constructor = CodeDomHelper.CreateConstructor(visibility.ToMemberAttribute()); constructor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeName), "root")); constructor.Statements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression(This(), "doc"), new CodeObjectCreateExpression( "XDocument", new CodePropertyReferenceExpression( new CodeVariableReferenceExpression("root"), Constants.Untyped)))); constructor.Statements.Add( new CodeAssignStatement( new CodeFieldReferenceExpression(This(), "rootObject"), new CodeVariableReferenceExpression("root"))); return(constructor); }
/// <summary> /// Converts <see cref="GeneratedTypesVisibility"/> to a keyword for use in code-generation. /// </summary> /// <param name="gtv"></param> /// <returns></returns> public static string ToKeyword(this GeneratedTypesVisibility gtv) => gtv.HasFlag(GeneratedTypesVisibility.Internal) || gtv == GeneratedTypesVisibility.Internal ? "internal" : "public";
private void CreateXRoot(CodeNamespace codeNamespace, string rootName, List <CodeTypeDeclaration> elements, List <CodeNamespace> namespaces, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) { LocalSymbolTable lst = new LocalSymbolTable(); CodeTypeDeclaration xroot = CodeDomHelper.CreateTypeDeclaration(rootName, null, visibility); //Create Methods CodeMemberField docField = CodeDomHelper.CreateMemberField("doc", "XDocument", false, MemberAttributes.Private); CodeMemberField rootField = CodeDomHelper.CreateMemberField("rootObject", Constants.XTypedElement, false, MemberAttributes.Private); xroot.Members.Add(docField); xroot.Members.Add(rootField); lst.Init(rootName); lst.RegisterMember("doc"); lst.RegisterMember("rootObject"); lst.RegisterMember("Load"); lst.RegisterMember("Parse"); lst.RegisterMember("Save"); lst.RegisterMember("XDocument"); lst.RegisterMember("Root"); // Constructor xroot.Members.Add(CodeDomHelper.CreateConstructor(MemberAttributes.Private)); //Load Methods xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", new string[][] { new string[] { "System.String", "xmlFile" } }, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", new string[][] { new string[] { "System.String", "xmlFile" }, new string[] { "LoadOptions", "options" } }, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", new string[][] { new string[] { "TextReader", "textReader" } }, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", new string[][] { new string[] { "TextReader", "textReader" }, new string[] { "LoadOptions", "options" } }, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", new string[][] { new string[] { "XmlReader", "xmlReader" } }, visibility)); //Parse Methods xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Parse", new string[][] { new string[] { "System.String", "text" } }, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Parse", new string[][] { new string[] { "System.String", "text" }, new string[] { "LoadOptions", "options" } }, visibility)); //Save Methods xroot.Members.Add( CodeDomHelper.CreateXRootSave(new string[][] { new string[] { "System.String", "fileName" } }, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][] { new string[] { "TextWriter", "textWriter" } }, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][] { new string[] { "XmlWriter", "writer" } }, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][] { new string[] { "TextWriter", "textWriter" }, new string[] { "SaveOptions", "options" } }, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][] { new string[] { "System.String", "fileName" }, new string[] { "SaveOptions", "options" } }, visibility)); CodeMemberProperty docProp = CodeDomHelper.CreateProperty("XDocument", "XDocument", docField, visibility.ToMemberAttribute(), false); xroot.Members.Add(docProp); CodeMemberProperty rootProp = CodeDomHelper.CreateProperty("Root", "XTypedElement", rootField, visibility.ToMemberAttribute(), false); xroot.Members.Add(rootProp); for (int i = 0; i < elements.Count; i++) { string typeName = elements[i].Name; string fqTypeName = (namespaces == null || namespaces[i].Name == String.Empty) ? typeName : "global::" + namespaces[i].Name + "." + typeName; xroot.Members.Add(CodeDomHelper.CreateXRootFunctionalConstructor(fqTypeName, visibility)); xroot.Members.Add(CodeDomHelper.CreateXRootGetter(typeName, fqTypeName, lst, visibility)); } codeNamespace.Types.Add(xroot); }
public SequencePropertyBuilder(GroupingInfo grouping, CodeTypeDeclaration decl, CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) : base(grouping, decl, declItems, visibility) { }