private static CodeStatement[] CreateAggregateMappingStatements(ClassMappingDescriptor descriptor, ICollection<MemberMappingDescriptor> members, CodeGeneratorContext context) { /*if (!member.IsAggregateExpression) todo: remove throw new OtisException(string.Format("Expression '{0}' is not a aggregate expression", member.Expression)); */ AggregateExpressionBuilder expBuilder = new AggregateExpressionBuilder(descriptor, members, context.FunctionMap); return expBuilder.GetStatements(); }
public Stream Generate( CodeGeneratorContext context ) { Arg.NotNull( context, nameof( context ) ); var extension = Path.GetExtension( context.FilePath ); var message = SR.CodeGeneratorFileTypeNotSupported.FormatDefault( extension ); context.Progress.ReportWarning( message ); return new MemoryStream(); }
internal static ICodeGenerator CreateCodeGenerator( CodeGeneratorContext context ) { Contract.Requires( context != null ); Contract.Ensures( Contract.Result<ICodeGenerator>() != null ); var extension = Path.GetExtension( context.FilePath ).ToUpperInvariant(); switch ( extension ) { case ".CS": return new CSharpDbContextCodeGenerator(); default: return new DefaultDbContextGenerator(); } }
public static CodeStatement[] CreateMappingStatements(ClassMappingDescriptor descriptor, CodeGeneratorContext context) { Dictionary<string, List<MemberMappingDescriptor>> aggregateGroups = new Dictionary<string, List<MemberMappingDescriptor>>(); List<CodeStatement> statements = new List<CodeStatement>(20); foreach (MemberMappingDescriptor member in descriptor.MemberDescriptors) { if (member.IsAggregateExpression) { // group all agregates by expression to avoid multiple traversals over same path //string path = GetPath(member.Expression); string path = GetPath(descriptor, member); if(!aggregateGroups.ContainsKey(path)) aggregateGroups[path] = new List<MemberMappingDescriptor>(1); aggregateGroups[path].Add(member); } else { CodeStatement[] st = CreateNonAggregateMappingStatements(descriptor, member, context); if(member.HasNullValue) { CodeStatement[] falseStatements = st; CodeStatement[] trueStatements = new CodeStatement[1]; trueStatements[0] = new CodeAssignStatement( new CodeVariableReferenceExpression("target." + member.Member), new CodeSnippetExpression(member.NullValue.ToString())); string checkExpression = GetNullablePartsCheckExpression(member); CodeExpression ifExpression = new CodeSnippetExpression(checkExpression); st = new CodeStatement[1]; st[0] = new CodeConditionStatement(ifExpression, trueStatements, falseStatements); } statements.AddRange(st); } } foreach (List<MemberMappingDescriptor> group in aggregateGroups.Values) { CodeStatement[] st = CreateAggregateMappingStatements(descriptor, group, context); statements.AddRange(st); } return statements.ToArray(); }
public AssemblerGenerator(CodeGeneratorContext context) { m_context = context; string ns; if (string.IsNullOrEmpty(m_context.AssemblerGenerationOptions.Namespace)) ns = "NS" + Guid.NewGuid().ToString("N"); else ns = m_context.AssemblerGenerationOptions.Namespace; m_generator = new ClassMappingGenerator(m_context); m_namespace = new CodeNamespace(ns); m_namespace.Imports.Add(new CodeNamespaceImport("System")); m_namespace.Imports.Add(new CodeNamespaceImport("System.Text")); m_namespace.Imports.Add(new CodeNamespaceImport("System.Collections")); m_namespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); m_namespace.Imports.Add(new CodeNamespaceImport("Otis")); m_assemblerClass = new CodeTypeDeclaration("Assembler"); m_assemblerClass.IsClass = true; m_assemblerClass.Attributes = MemberAttributes.Public; m_namespace.Types.Add(m_assemblerClass); m_explicitAssemblies.Add(Assembly.GetExecutingAssembly().CodeBase.Substring(8)); }
public void AddMapping(ClassMappingDescriptor descriptor, CodeGeneratorContext context) { CodeMemberMethod methodAssembleFrom = m_generator.CreateTypeTransformationMethod(descriptor); m_assemblerClass.Members.Add(methodAssembleFrom); CodeMemberMethod methodAssemble = m_generator.CreateInPlaceTransformationMethod(descriptor); m_assemblerClass.Members.Add(methodAssemble); CodeMemberMethod methodAssembleValueType = m_generator.CreateInPlaceTransformationMethodForValueTypes(descriptor); m_assemblerClass.Members.Add(methodAssembleValueType); CodeMemberMethod methodToList = m_generator.CreateToListMethod(descriptor); m_assemblerClass.Members.Add(methodToList); CodeMemberMethod methodToArray = m_generator.CreateToArrayMethod(descriptor); m_assemblerClass.Members.Add(methodToArray); string interfaceType = string.Format( "IAssembler<{0}, {1}>", TypeHelper.GetTypeDefinition(descriptor.TargetType), TypeHelper.GetTypeDefinition(descriptor.SourceType)); m_assemblerClass.BaseTypes.Add(interfaceType); AddReferencedAssemblies(descriptor); }
public override void GenerateCode(Span target, CodeGeneratorContext context) { context.CodeTreeBuilder.AddSetBaseTypeChunk(GetBaseType(context, BaseType), target); }
/// <summary> /// Instantiates a new instance of the <see cref="CodeBuilderContext"/> object. /// </summary> /// <param name="generatorContext">A <see cref="CodeGeneratorContext"/> to copy information from.</param> /// <param name="errorSink"> /// The <see cref="ErrorSink"/> used to collect <see cref="RazorError"/>s encountered /// when parsing the current Razor document. /// </param> public CodeBuilderContext(CodeGeneratorContext generatorContext, ErrorSink errorSink) : base(generatorContext) { ErrorSink = errorSink; ExpressionRenderingMode = ExpressionRenderingMode.WriteToOutput; }
protected override string ResolveType(CodeGeneratorContext context, string baseType) { return GetBaseType(context, baseType); }
public CSharpCodeVisitor(CSharpCodeWriter writer, CodeGeneratorContext context) : base(writer, context) { _paddingBuilder = new CSharpPaddingBuilder(context.Host); }
/// <summary> /// Generates the code content using the provided context. /// </summary> /// <param name="context">The <see cref="">context</see> used to generate content.</param> /// <returns>A <see cref="Stream">stream</see> containing the generated content.</returns> protected override Stream Generate( CodeGeneratorContext context ) { var generator = DbContextGeneratorFactory.CreateCodeGenerator( context ); return generator.Generate( context ); }
public void WriteStartInstrumentationContext(CodeGeneratorContext context, SyntaxTreeNode syntaxNode, bool isLiteral) { WriteStartMethodInvocation(context.Host.GeneratedClassContext.BeginContextMethodName); Write(syntaxNode.Start.AbsoluteIndex.ToString(CultureInfo.InvariantCulture)); WriteParameterSeparator(); Write(syntaxNode.Length.ToString(CultureInfo.InvariantCulture)); WriteParameterSeparator(); Write(isLiteral ? "true" : "false"); WriteEndMethodInvocation(); }
protected override void Initialize(CodeGeneratorContext context) { base.Initialize(context); }
public CSharpCodeBuilder(CodeGeneratorContext context) : base(context) { }
protected override void Initialize(CodeGeneratorContext context) { base.Initialize(context); context.GeneratedClass.Members.Insert(0, new CodeSnippetTypeMember(HiddenLinePragma)); }
public override void PostProcessGeneratedCode(CodeGeneratorContext context) { _codeTransformer.ProcessGeneratedCode(context.CompileUnit, context.Namespace, context.GeneratedClass, context.TargetMethod); }
public override void MapVariables(CodeGeneratorContext context) { base.MapVariables(context); lnkOut.DataMapIdx = (short)_DataIndex; }
public override void GenerateInit(CodeGeneratorContext context, TextWriter __CPP) { __CPP.WriteLine("set_val({0}, {1});", lnkOut.MappedValueName, tbInitVal.Text); __CPP.WriteLine("set_val({0}_CHANGED,0);", lnkOut.MappedValueName); }
public override void GenerateDataMap(CodeGeneratorContext context, TextWriter __H, TextWriter __CPP) { __H.WriteLine("#define {0} {1}", lnkOut.MappedValueName, _DataIndex); __H.WriteLine("#define {0}_CHANGED {1}", lnkOut.MappedValueName, _DataIndex + 1); }
private static void EvaluateAndGenerateCode( CodeGeneratorContext context, StreamWriter writer ) { Contract.Requires( context != null ); Contract.Requires( writer != null ); var ast = ParseText( context.FileContents ); var root = ast.GetRoot(); var classes = FindClasses( root ); if ( classes.Count == 0 ) { writer.WriteLine( SR.DbContextClassNotFound.FormatDefault( Comment ) ); return; } var usings = FindUsings( root ); var declarations = FindInterfaceDeclarations( classes ); if ( declarations.Count == 0 ) writer.WriteLine( SR.NoInterfacesFound.FormatDefault( typeof( IReadOnlyRepository<> ), typeof( IRepository<> ), typeof( IUnitOfWork<> ) ) ); else ImplementInterfaces( context, usings, declarations, writer ); }
public CodeGenerator(CodeGeneratorContext context) { _context = context; }
private string GetBaseType(CodeGeneratorContext context, string baseType) { var host = (RazorEngineHost)context.Host; return _builtBaseTypeName(host.DefaultBaseTemplateType, baseType); }
public void WriteEndInstrumentationContext(CodeGeneratorContext context) { WriteMethodInvocation(context.Host.GeneratedClassContext.EndContextMethodName); }
private static CodeStatement[] CreateNonAggregateMappingStatements(ClassMappingDescriptor descriptor, MemberMappingDescriptor member, CodeGeneratorContext context) { if (member.Projections.Count > 0) return CreateProjectionMapping(member); if (member.Type == typeof(string) || member.Type.IsPrimitive) return CreateSimpleMapping(member); if (member.IsArray) return CreateArrayMappingStatements(member); if (member.IsList) return CreateListMappingStatements(member); return CreateAssemblerMapping(member); }
private static void ImplementInterfaces( CodeGeneratorContext context, IReadOnlyList<UsingDirectiveSyntax> usings, IReadOnlyList<InterfaceDeclaration> declarations, TextWriter writer ) { Contract.Requires( context != null ); Contract.Requires( declarations != null ); Contract.Requires( writer != null ); var iterator = declarations.GetEnumerator(); if ( !iterator.MoveNext() ) return; var indentingWriter = new IndentingTextWriter( writer ); var implementedInterfaces = new HashSet<string>(); var hasNamespace = WriteStartClass( indentingWriter, context.DefaultNamespace, usings, iterator.Current.DefiningClass ); ImplementInterface( indentingWriter, iterator.Current, implementedInterfaces ); while ( iterator.MoveNext() ) { writer.WriteLine(); ImplementInterface( indentingWriter, iterator.Current, implementedInterfaces ); } WriteEndClass( indentingWriter, hasNamespace ); }
public ClassMappingGenerator(CodeGeneratorContext context) { m_context = context; }
public Stream Generate( CodeGeneratorContext context ) { Arg.NotNull( context, nameof( context ) ); var stream = new MemoryStream(); var writer = new StreamWriter( stream ); try { EvaluateAndGenerateCode( context, writer ); } catch { writer.Close(); throw; } writer.Flush(); stream.Seek( 0L, SeekOrigin.Begin ); return stream; }
public override void GenerateDataMap(CodeGeneratorContext context, TextWriter __H, TextWriter __CPP) { __H.WriteLine("#define {0}_DOWN {1}", lnkOut.MappedValueName, __buttons.GetDownConstant(__ButtonIndex)); __H.WriteLine("#define {0}_PRESSED {1}", lnkOut.MappedValueName, __buttons.GetPressedConstant(__ButtonIndex)); }