private IClassLikeDeclaration CreateClassHandlerDeclaration([NotNull] string entityName, [NotNull] string handlerInterfaceName) { var baseCtorArgs = new List <string>(2); var propertyWithKeyAttribute = classDeclaration.PropertyDeclarations.FirstOrDefault(x => x.Attributes.HasAttribute(Constants.Key)); if (propertyWithKeyAttribute?.Type.IsGuid() ?? false) { baseCtorArgs.Add(propertyWithKeyAttribute.NameIdentifier.Name); } var timestampPropertyName = FindTimestampPropertyName(); if (!string.IsNullOrWhiteSpace(timestampPropertyName)) { baseCtorArgs.Add(timestampPropertyName); } var classHandlerName = $"{entityName}Handler"; var baseCtorArgsStr = string.Join(", ", new[] { "dataContextProvider" }.Concat(baseCtorArgs.Select(x => $"x => x.{x}"))); var classHandlerDeclaration = (IClassLikeDeclaration)factory.CreateTypeMemberDeclaration($"public class $0 : EntityHandlerBase<{className}>, $1 {{" + $" public $0(IDataContextProvider dataContextProvider) : base({baseCtorArgsStr}){{}}" + $"}}", classHandlerName, handlerInterfaceName); return(classHandlerDeclaration); }
private IMethodDeclaration CreateDeclaration([NotNull] MonoBehaviourEvent monoBehaviourEvent, [NotNull] CSharpElementFactory elementFactory, [NotNull] IClassLikeDeclaration context) { var builder = new StringBuilder(128); builder.Append("void "); builder.Append(monoBehaviourEvent.Name); builder.Append("("); for (int i = 0; i < monoBehaviourEvent.Parameters.Length; i++) { if (i > 0) { builder.Append(","); } var parameter = monoBehaviourEvent.Parameters[i]; builder.Append(parameter.ClrTypeName.FullName); if (parameter.IsArray) { builder.Append("[]"); } builder.Append(' '); builder.Append(parameter.Name); } builder.Append(");"); var declaration = (IMethodDeclaration)elementFactory.CreateTypeMemberDeclaration(builder.ToString()); declaration.SetResolveContextForSandBox(context, SandBoxContextType.Child); declaration.FormatNode(); return(declaration); }
public void Generate(CSharpGeneratorContext context, IList <GeneratorDeclaredElement <ITypeOwner> > elements, CSharpElementFactory factory) { IMethodDeclaration methodDeclaration = null; ITypeElement declaredElement = context.ClassDeclaration.DeclaredElement; if (declaredElement != null) { IDeclaredType byteType = TypeFactory.CreateTypeByCLRName(PredefinedType.BYTE_FQN, context.PsiModule, context.Anchor.GetResolveContext()); _byteArrayType = TypeFactory.CreateArrayType(byteType, 1); _typeConversionRule = new CSharpTypeConversionRule(context.PsiModule); IOverridableMember member = declaredElement.Methods.FirstOrDefault(ValidateMethod); if (member != null) { methodDeclaration = (IMethodDeclaration)member.GetDeclarations().FirstOrDefault(); Generate(context, methodDeclaration, elements, factory); return; } } string method = String.Format("public Int32 {0}(Byte[] bytes, Int32 startIndex)", MethodName); methodDeclaration = (IMethodDeclaration)factory.CreateTypeMemberDeclaration(method); Generate(context, methodDeclaration, elements, factory); context.PutMemberDeclaration(methodDeclaration, null, newDeclaration => new GeneratorDeclarationElement(newDeclaration)); }
public void Generate(CSharpGeneratorContext context, IList <GeneratorDeclaredElement <ITypeOwner> > elements, CSharpElementFactory factory) { IMethodDeclaration methodDeclaration = null; ITypeElement declaredElement = context.ClassDeclaration.DeclaredElement; if (declaredElement != null) { IOverridableMember member = declaredElement.Methods.FirstOrDefault(ValidateMethod); if (member != null) { methodDeclaration = (IMethodDeclaration)member.GetDeclarations().FirstOrDefault(); Generate(context, methodDeclaration, elements, factory); return; } } string method = String.Format("public Int32 {0}()", MethodName); methodDeclaration = (IMethodDeclaration)factory.CreateTypeMemberDeclaration(method); Generate(context, methodDeclaration, elements, factory); context.PutMemberDeclaration(methodDeclaration, null, newDeclaration => new GeneratorDeclarationElement(newDeclaration)); }
public IMethodDeclaration CreateDeclaration([NotNull] CSharpElementFactory factory, [NotNull] IClassLikeDeclaration classDeclaration) { var builder = new StringBuilder(128); builder.Append("private "); if (IsStatic) { builder.Append("static "); } builder.Append(ReturnType.FullName); if (ReturnTypeIsArray) { builder.Append("[]"); } builder.Append(" "); builder.Append(Name); builder.Append("("); for (var i = 0; i < Parameters.Length; i++) { if (i > 0) { builder.Append(","); } var parameter = Parameters[i]; // TODO: `out` or `ref`? // From reflection point of view, it's a "ByRef" Type, and that's all we know... // The only place it's currently being used is an out parameter if (parameter.IsByRef) { builder.Append("out "); } builder.Append(parameter.ClrTypeName.FullName); if (parameter.IsArray) { builder.Append("[]"); } builder.Append(' '); builder.Append(parameter.Name); } builder.Append(");"); var declaration = (IMethodDeclaration)factory.CreateTypeMemberDeclaration(builder.ToString()); declaration.SetResolveContextForSandBox(classDeclaration, SandBoxContextType.Child); declaration.FormatNode(); return(declaration); }
public IMethodDeclaration CreateDeclaration([NotNull] CSharpElementFactory factory, [NotNull] IClassLikeDeclaration classDeclaration) { var builder = new StringBuilder(128); builder.Append("private "); if (IsStatic) { builder.Append("static "); } builder.Append(ReturnType.FullName); if (ReturnTypeIsArray) { builder.Append("[]"); } builder.Append(" "); builder.Append(Name); builder.Append("("); for (var i = 0; i < Parameters.Length; i++) { if (i > 0) { builder.Append(","); } var parameter = Parameters[i]; builder.Append(parameter.ClrTypeName.FullName); if (parameter.IsArray) { builder.Append("[]"); } builder.Append(' '); builder.Append(parameter.Name); } builder.Append(");"); var declaration = (IMethodDeclaration)factory.CreateTypeMemberDeclaration(builder.ToString()); declaration.SetResolveContextForSandBox(classDeclaration, SandBoxContextType.Child); declaration.FormatNode(); return(declaration); }
private IClassDeclaration GenerateContractClassDeclaration(string contractClassName) { Contract.Ensures(Contract.Result <IClassDeclaration>() != null); var classDeclaration = (IClassDeclaration)_factory.CreateTypeMemberDeclaration( string.Format("class {0} {{}}", contractClassName)); if (_addContractForAvailability.IsInterface) { AddContractClassForInterface(classDeclaration); } else { AddContractClassForAbstractClass(classDeclaration); } //ITypeUsage typeUsage = null; //var contractClass = CSharpTypeFactory.CreateType(typeUsage); return(classDeclaration); }
private static void CreateDispose(CSharpGeneratorContext context, CSharpElementFactory factory, ICollection <GeneratorDeclaredElement <ITypeOwner> > typeOwners) { var existingEquals = FindDispose(context); IMethodDeclaration declaration; if (existingEquals != null) { if (context.GetGlobalOptionValue("ChangeDispose") == "Skip") { return; } if (context.GetGlobalOptionValue("ChangeDispose") == "Replace") { declaration = (IMethodDeclaration)existingEquals.GetDeclarations().FirstOrDefault(); GenerateDisposeBody(context, declaration, typeOwners, factory); return; } } declaration = (IMethodDeclaration)factory.CreateTypeMemberDeclaration( "public void Dispose();"); GenerateDisposeBody(context, declaration, typeOwners, factory); context.PutMemberDeclaration(declaration, null, newDeclaration => new GeneratorDeclarationElement(newDeclaration)); }
public void Signature(IClassLikeDeclaration classDeclaration, CSharpElementFactory dataProviderElementFactory) { classDeclaration.AddClassMemberDeclaration((IClassMemberDeclaration)dataProviderElementFactory.CreateTypeMemberDeclaration(Signature())); }
public IMethodDeclaration CreateDeclaration([NotNull] CSharpElementFactory factory, [NotNull] IClassLikeDeclaration classDeclaration, AccessRights accessRights, bool makeVirtual = false) { var builder = new StringBuilder(128); if (accessRights != AccessRights.NONE) { builder.Append(CSharpDeclaredElementPresenter.Instance.Format(accessRights)); builder.Append(" "); } if (IsStatic) { builder.Append("static "); } // Consider this declaration a template, and the final generated code implements (or overrides) this API if (makeVirtual) { builder.Append("virtual "); } builder.Append("global::"); builder.Append(ReturnType.FullName); if (ReturnTypeIsArray) { builder.Append("[]"); } builder.Append(" "); builder.Append(Name); builder.Append("("); for (var i = 0; i < Parameters.Length; i++) { if (i > 0) { builder.Append(","); } var parameter = Parameters[i]; // TODO: `out` or `ref`? // From reflection point of view, it's a "ByRef" Type, and that's all we know... // The only place it's currently being used is an out parameter if (parameter.IsByRef) { builder.Append("out "); } builder.Append("global::"); builder.Append(parameter.ClrTypeName.FullName); if (parameter.IsArray) { builder.Append("[]"); } builder.Append(' '); builder.Append(parameter.Name); } builder.Append(");"); var declaration = (IMethodDeclaration)factory.CreateTypeMemberDeclaration(builder.ToString()); declaration.SetResolveContextForSandBox(classDeclaration, SandBoxContextType.Child); return(declaration); }
/// <summary> /// Adds the interface. /// </summary> /// <param name="classDeclaration"> /// The class declaration. /// </param> /// <param name="factory"> /// The factory. /// </param> private static void AddProxyClass(IClassDeclaration classDeclaration, CSharpElementFactory factory) { var className = classDeclaration.DeclaredName; var variableName = GetVariableName(classDeclaration); var namingPolicy = CodeStyleSettingsManager.Instance.CodeStyleSettings.GetNamingSettings2().PredefinedNamingRules[NamedElementKinds.PrivateInstanceFields]; var prefix = namingPolicy.NamingRule.Prefix; var proxyProperty = prefix + variableName; var isStatic = false; // classDeclaration.IsStatic; var staticClass = isStatic ? " static" : string.Empty; var code = new StringBuilder(string.Format("public{1} class {0}Proxy {{", classDeclaration.DeclaredName, staticClass)); if (!isStatic) { code.Append(string.Format("\r\nreadonly {0} {1};", classDeclaration.DeclaredName, proxyProperty)); code.Append(string.Format("public {0}Proxy({0} {1}) {{\r\n{2} = {1};\r\n}}\r\n", classDeclaration.DeclaredName, variableName, proxyProperty)); } var cls = classDeclaration.DeclaredElement as IClass; if (cls == null) { return; } AddMembers(code, cls, proxyProperty, className); code.Append("}"); var memberDeclaration = factory.CreateTypeMemberDeclaration(code.ToString()) as IClassDeclaration; var namespaceDeclaration = classDeclaration.GetContainingNamespaceDeclaration(); namespaceDeclaration.AddTypeDeclarationAfter(memberDeclaration, classDeclaration); }
public IMethodDeclaration CreateDeclaration([NotNull] CSharpElementFactory factory, [NotNull] KnownTypesCache knownTypesCache, [NotNull] IClassLikeDeclaration classDeclaration, AccessRights accessRights, bool makeVirtual = false, bool makeCoroutine = false) { var builder = new StringBuilder(128); var args = new object[1 + Parameters.Length]; object arg; var argIndex = 0; var module = classDeclaration.GetPsiModule(); if (accessRights != AccessRights.NONE) { builder.Append(CSharpDeclaredElementPresenter.Instance.Format(accessRights)); builder.Append(" "); } if (IsStatic) { builder.Append("static "); } // Consider this declaration a template, and the final generated code implements (or overrides) this API if (makeVirtual) { builder.Append("virtual "); } if (makeCoroutine && CanBeCoroutine) { builder.Append(PredefinedType.IENUMERATOR_FQN.FullName); } else { arg = GetTypeObject(ReturnType, knownTypesCache, module); if (arg is string) { builder.Append(arg); if (ReturnType.IsArray) { builder.Append("[]"); } } else { builder.Append("$0"); args[argIndex++] = arg; } } builder.Append(" "); builder.Append(Name); builder.Append("("); for (var i = 0; i < Parameters.Length; i++) { if (i > 0) { builder.Append(","); } var parameter = Parameters[i]; // TODO: `out` or `ref`? // From reflection point of view, it's a "ByRef" Type, and that's all we know... // The only place it's currently being used is an out parameter if (parameter.IsByRef) { builder.Append("out "); } arg = GetTypeObject(parameter.TypeSpec, knownTypesCache, module); if (arg is string) { builder.Append(arg); if (parameter.TypeSpec.IsArray) { builder.Append("[]"); } } else { builder.Append($"${argIndex}"); args[argIndex++] = arg; } builder.Append(' '); builder.Append(parameter.Name); } builder.Append(");"); var declaration = (IMethodDeclaration)factory.CreateTypeMemberDeclaration(builder.ToString(), args); declaration.SetResolveContextForSandBox(classDeclaration, SandBoxContextType.Child); return(declaration); }
private static void AddProxyClass(IClassDeclaration classDeclaration, CSharpElementFactory factory) { var builderType = string.Format("{0}Builder", classDeclaration.DeclaredName); var code = new StringBuilder(string.Format("public class {0} {{", builderType)); code.AppendLine(); var cls = classDeclaration.DeclaredElement as IClass; if (cls == null) { return; } var ctor = cls.Constructors.OrderByDescending(x => x.Parameters.Count).FirstOrDefault(); if (ctor == null) { return; } var fields = new StringBuilder(); var methods = new StringBuilder(); foreach (var parameter in ctor.Parameters) { var typePresentableName = parameter.Type.GetPresentableName(cls.PresentationLanguage); var shortName = parameter.ShortName; var capitalizedShortName = shortName.Capitalize(); fields.AppendLine("private {0} _{1};", typePresentableName, shortName); methods.AppendLine("public {2} With{1}({0} value){{ ", typePresentableName, capitalizedShortName, builderType); methods.AppendLine(" _{0} = value;", shortName); methods.AppendLine("return this;"); methods.AppendLine("}"); methods.AppendLine(); if (parameter.Type.IsGenericIEnumerable()) { var genericParameter = typePresentableName.Split(new[] { '<', '>' })[1]; var listType = string.Format("List<{0}>", genericParameter); var singularName = NounUtil.GetSingular(capitalizedShortName); methods.AppendLine("public {0} Add{1}({2} value){{", builderType, singularName, genericParameter); methods.AppendLine(" if(_{0} == null){{", shortName); methods.AppendLine(" _{0} = new {1}();", shortName, listType); methods.AppendLine(" }"); methods.AppendLine(" var collection = _{0} as ICollection<{1}>;", shortName, genericParameter); methods.AppendLine(" if (collection == null || collection.IsReadOnly){"); methods.AppendLine(" throw new InvalidOperationException(\"Add{0}() method cannot be used with this collection type\");", singularName); methods.AppendLine(" }"); methods.AppendLine(" collection.Add(value);"); methods.AppendLine(" return this;"); methods.AppendLine("}"); methods.AppendLine(); } } code.Append(fields); code.Append(methods); code.AppendLine("public {0} Build(){{", classDeclaration.DeclaredName); code.AppendFormat("return new {0}(", classDeclaration.DeclaredName); code.Append(ctor.Parameters.Select(x => string.Format("_{0}", x.ShortName)).ToArray().Join(", ")); code.AppendLine(");"); code.AppendLine("}"); code.Append("}"); var memberDeclaration = factory.CreateTypeMemberDeclaration(code.ToString()) as IClassDeclaration; var namespaceDeclaration = classDeclaration.GetContainingNamespaceDeclaration(); namespaceDeclaration.AddTypeDeclarationAfter(memberDeclaration, classDeclaration); }
/// <summary> /// Adds the member. /// </summary> /// <param name="classDeclaration"> /// The class declaration. /// </param> /// <param name="factory"> /// The factory. /// </param> /// <param name="code"> /// The member code. /// </param> private static void AddMember(IClassDeclaration classDeclaration, CSharpElementFactory factory, string code) { var memberDeclaration = factory.CreateTypeMemberDeclaration(code) as IClassMemberDeclaration; classDeclaration.AddClassMemberDeclaration(memberDeclaration); }
private IClassDeclaration GenerateNonGenericContractClassDeclaration(string contractClassName) { return((IClassDeclaration)_factory.CreateTypeMemberDeclaration( "abstract class $0 : $1 {}", contractClassName, _addContractForAvailability.DeclaredType)); }