public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { if (_inner.Any()) { writer.Write($"BLOCK:switch ({_event.Usage})"); foreach (var frame in _inner) { frame.GenerateCode(method, writer); } writer.FinishBlock(); } Next?.GenerateCode(method, writer); }
public sealed override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { if (_inner.Length > 1) { for (int i = 1; i < _inner.Length; i++) { _inner[i - 1].Next = _inner[i]; } } generateCode(method, writer, _inner[0]); Next?.GenerateCode(method, writer); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { if (_aggregate == null) { writer.WriteLine($"return new {_slot.ReturnType.FullNameInCode()}({_arg.Usage});"); } else { writer.WriteLine($"{_aggregate.Usage} ??= new {_slot.ReturnType.FullNameInCode()}({_arg.Usage});"); } Next?.GenerateCode(method, writer); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { var alias = RoutingFrames.TypeOutputs[Variable.VariableType]; writer.WriteLine($"{alias} {Variable.Usage};"); writer.Write($"BLOCK:if (!{alias}.TryParse({_segments.Usage}[{Position}], out {Variable.Usage}))"); writer.WriteLine( $"{RouteGraph.Context}.{nameof(HttpContext.Response)}.{nameof(HttpResponse.StatusCode)} = 400;"); writer.WriteLine(method.ToExitStatement()); writer.FinishBlock(); writer.BlankLine(); Next?.GenerateCode(method, writer); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { writer.Write($"var {Persistor.Usage} = new {typeof(InMemoryEnvelopeTransaction).FullNameInCode()}();"); writer.Write($"await {_context.Usage}.{nameof(IMessageContext.EnlistInTransaction)}({Persistor.Usage});"); if (_existence == SagaStateExistence.Existing) { writer.Write( $"var {Document.Usage} = {_persistor.Usage}.{nameof(InMemorySagaPersistor.Load)}<{Document.VariableType.FullNameInCode()}>({_sagaId.Usage});"); } Next?.GenerateCode(method, writer); }
private void writeDeclaration(ISourceWriter writer) { var implemented = implements().ToArray(); if (implemented.Any()) { writer.Write( $"BLOCK:public class {TypeName} : {implemented.Select(x => x.FullNameInCode()).Join(", ")}"); } else { writer.Write($"BLOCK:public class {TypeName}"); } }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { var creation = $"var {_output.Usage} = new {_output.VariableType.FullName.Replace("+", ".")}()"; if (_output.VariableType.CanBeCastTo <IDisposable>()) { writer.UsingBlock(creation, w => Next?.GenerateCode(method, w)); } else { writer.WriteLine(creation + ";"); Next?.GenerateCode(method, writer); } }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { var typeFullName = Service.VariableType.FullName.Replace("+", "."); var declaration = $"var {Service.Usage} = ({typeFullName}){_provider.Usage}.{nameof(IServiceProvider.GetService)}(typeof({typeFullName}))"; if (Service.VariableType.CanBeCastTo <IDisposable>()) { writer.UsingBlock(declaration, w => Next?.GenerateCode(method, w)); } else { writer.Write(declaration + ";"); Next?.GenerateCode(method, writer); } }
public static void Write(IGenerationModel generationModel, ISourceWriter writer) { writeClassDeclaration(generationModel, writer); writeFields(generationModel, writer); writer.BlankLine(); writeConstructor(generationModel, writer); writer.BlankLine(); writeHandleMethod(generationModel, writer); writer.FinishBlock(); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { writer.WriteComment("Check if the saga has been completed"); writer.Write($"BLOCK:if ({_handler.Usage}.{nameof(StatefulSagaOf<string>.IsCompleted)})"); writer.WriteComment("Delete the saga state entity"); writer.Write($"{_context.Usage}.{nameof(DbContext.Remove)}({_state.Usage});"); writer.FinishBlock(); // writer.Write("BLOCK:else"); // writer.WriteComment("Persist the saga state entity"); // writer.Write($"{_context.Usage}.{nameof(DbContext.Add)}({_state.Usage});"); // writer.FinishBlock(); writer.BlankLine(); Next?.GenerateCode(method, writer); }
protected void LoopAttributes(IMethodVariables variables, ISourceWriter writer, string methodCall) { var resultsVariable = variables.FindVariable(typeof(ValidationFailures)); var attributeType = typeof(T).FullNameInCode(); var awaitMethod = this.IsAsync ? "await" : string.Empty; writer.Comment($"{this._property.PropertyInfoVariable} == {this._property.PropertyInfoVariable.Property.DeclaringType.Name}.{this._property.PropertyInfoVariable.Property.Name}"); writer.Block($"foreach (var attribute in {this._property.PropertyAttributesVariable})"); writer.Block($"if (attribute is {attributeType} x)"); writer.WriteLine($"var result = {awaitMethod} x.{methodCall};"); writer.Block($"if (result != {Variable.StaticFrom<ValidationResult>(nameof(ValidationResult.Success))})"); writer.WriteLine($"{resultsVariable}.{nameof(ValidationFailures.AddFailure)}(result);"); writer.FinishBlock(); writer.FinishBlock(); writer.FinishBlock(); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { if (SagaId.VariableType == typeof(string)) { writer.Write($"var {SagaId.Usage} = {_envelope.Usage}.{nameof(Envelope.SagaId)};"); writer.Write($"if (string.{nameof(string.IsNullOrEmpty)}({SagaFramePolicy.SagaIdVariableName})) throw new {typeof(IndeterminateSagaStateIdException).FullName}({_envelope.Usage});"); } else { var typeNameInCode = SagaId.VariableType == typeof(Guid) ? typeof(Guid).FullName : SagaId.VariableType.NameInCode(); writer.Write($"if (!{typeNameInCode}.TryParse({_envelope.Usage}.{nameof(Envelope.SagaId)}, out {typeNameInCode} sagaId)) throw new {typeof(IndeterminateSagaStateIdException).FullName}({_envelope.Usage});"); } Next?.GenerateCode(method, writer); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { var declaration = $"{typeof(List<>).Namespace}.List<{ElementType.FullNameInCode()}>"; var elements = Elements.Select(x => x.Usage).Join(", "); if (ReturnCreated) { writer.Write($"return new {declaration}{{{elements}}};"); } else { writer.Write($"var {Variable.Usage} = new {declaration}{{{elements}}};"); } Next?.GenerateCode(method, writer); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { writer.Write($"case {SpecificEvent.VariableType.FullNameInCode()} {SpecificEvent.Usage}:"); // TODO -- fix this with LamarCodeGeneration writer.As <SourceWriter>().IndentionLevel++; foreach (var frame in _inner) { frame.GenerateCode(method, writer); } writer.Write("break;"); writer.As <SourceWriter>().IndentionLevel--; Next?.GenerateCode(method, writer); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { writer.Write($"var stopwatch = new {typeof(Stopwatch).FullNameInCode()}();"); writer.Write($"stopwatch.Start();"); writer.Write("BLOCK:try"); Next?.GenerateCode(method, writer); writer.FinishBlock(); // Write a finally block where you record the stopwatch writer.Write("BLOCK:finally"); writer.Write($"stopwatch.Stop();"); writer.Write($"{_logger.Usage}.Log(Microsoft.Extensions.Logging.LogLevel.Information, \"{_chain.Description} ran in \" + {_stopwatch.Usage}.{nameof(Stopwatch.ElapsedMilliseconds)});)"); writer.FinishBlock(); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { writer.WriteLine($"{_aggregateType.FullNameInCode()} {Aggregate.Usage} = default({_aggregateType.FullNameInCode()});"); writer.Write($"BLOCK:if ({_slice.Usage}.{nameof(StreamAction.ActionType)} == {Constant.ForEnum(StreamActionType.Start).Usage})"); _create.Action = CreateAggregateAction.Assign; _create.GenerateCode(method, writer); writer.FinishBlock(); writer.Write("BLOCK:else"); _loadMethod.GenerateCode(method, writer); _create.Action = CreateAggregateAction.NullCoalesce; _create.GenerateCode(method, writer); writer.FinishBlock(); Next?.GenerateCode(method, writer); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { var elements = Elements.Select(x => x.Usage).Join(", "); var arrayType = ElementType.MustBeBuiltWithFunc() ? "object" : ElementType.FullNameInCode(); if (ReturnCreated) { writer.Write($"return new {arrayType}[]{{{elements}}};"); } else { writer.Write($"var {Variable.Usage} = new {arrayType}[]{{{elements}}};"); } Next?.GenerateCode(method, writer); }
// You have to override this method public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { var creation = $"var {Output.Usage} = new {Output.VariableType.FullNameInCode()}()"; if (Output.VariableType.CanBeCastTo <IDisposable>()) { // there is an ISourceWriter shortcut for this, but this makes // a better code demo;) writer.Write($"BLOCK:using ({creation})"); Next?.GenerateCode(method, writer); writer.FinishBlock(); } else { writer.WriteLine(creation + ";"); Next?.GenerateCode(method, writer); } }
public virtual void WriteSelectCode(ISourceWriter writer) { foreach (var route in ComplexArgRoutes) { writer.WriteComment("Look for odd shaped routes with complex parameter structures"); writer.Write($"if (Matches{route.VariableName}(segments)) return {route.VariableName};"); } if (_children.Any()) { writer.Write($"BLOCK:if (segments.Length > {LeafDepth})"); foreach (var node in _children) { writer.IfCurrentSegmentEquals(Depth, node.Segment, node.WriteSelectCode); } if (SpreadRoute != null) { writer.Return(SpreadRoute); } writer.ReturnNull(); writer.FinishBlock(); } foreach (var leaf in Leaves.OrderBy(x => x.LastSegment)) { writer.IfCurrentSegmentEquals(Depth, leaf.LastSegment, w => w.Return(leaf)); } if (TryFindLeafArgRoute(out var leafArg)) { writer.Return(leafArg); } if (SpreadRoute != null) { writer.Return(SpreadRoute); } writer.ReturnNull(); }
private void writeConstructorMethod(ISourceWriter writer, IList <InjectedField> args) { var ctorArgs = args.Select(x => x.CtorArgDeclaration).Join(", "); var declaration = $"BLOCK:public {TypeName}({ctorArgs})"; if (BaseConstructorArguments.Any()) { declaration = $"{declaration} : base({BaseConstructorArguments.Select(x => x.Usage).Join(", ")})"; } writer.Write(declaration); foreach (var field in args) { field.WriteAssignment(writer); } writer.FinishBlock(); }
public ApplicationGenerator( ILogProvider logProvider, IDslModel dslModel, IPluginsContainer <IGenerator> generatorsContainer, RhetosBuildEnvironment buildEnvironment, FilesUtility filesUtility, ISourceWriter sourceWriter, BuildOptions buildOptions) { _logProvider = logProvider; _logger = logProvider.GetLogger(GetType().Name); _performanceLogger = logProvider.GetLogger("Performance." + GetType().Name); _dslModel = dslModel; _generatorsContainer = generatorsContainer; _buildEnvironment = buildEnvironment; _filesUtility = filesUtility; _sourceWriter = sourceWriter; _buildOptions = buildOptions; }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { var invokeMethod = invocationCode(); var returnValue = ""; if (IsAsync) { returnValue = method.AsyncMode == AsyncMode.ReturnFromLastNode ? "return " : "await "; } if (ReturnVariable != null) { returnValue = $"var {ReturnVariable.Usage} = {returnValue}"; } writer.Write($"{returnValue}{invokeMethod};"); Next?.GenerateCode(method, writer); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { if (CommentText.IsNotEmpty()) { writer.WriteComment(CommentText); } var invokeMethod = invocationCode(); var returnValue = ""; if (IsAsync) { returnValue = method.AsyncMode == AsyncMode.ReturnFromLastNode ? "return " : "await "; } var isDisposable = false; if (shouldAssignVariableToReturnValue(method)) { #if !NET4x returnValue = ReturnVariable.VariableType.IsValueTuple() ? $"{ReturnVariable.Usage} = {returnValue}" : $"var {ReturnVariable.Usage} = {returnValue}"; #else returnValue = $"var {ReturnVariable.Usage} = {returnValue}"; #endif isDisposable = ReturnVariable.VariableType.CanBeCastTo <IDisposable>(); } if (isDisposable && DisposalMode == DisposalMode.UsingBlock) { writer.UsingBlock($"{returnValue}{invokeMethod}", w => Next?.GenerateCode(method, writer)); } else { writer.Write($"{returnValue}{invokeMethod};"); Next?.GenerateCode(method, writer); } }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { var arguments = _arguments.Select(x => x.Usage).Join(", "); var implementationTypeName = _implementationType.FullNameInCode(); if (ReturnCreated) { writer.Write($"return new {implementationTypeName}({arguments});"); Next?.GenerateCode(method, writer); return; } var declaration = $"var {Variable.Usage} = new {implementationTypeName}({arguments})"; switch (Disposal) { case DisposeTracking.None: writer.Write(declaration + ";"); Next?.GenerateCode(method, writer); break; case DisposeTracking.WithUsing: if (Next is ConstructorFrame && Next.As <ConstructorFrame>().Disposal == DisposeTracking.WithUsing) { writer.Write($"using ({declaration})"); Next?.GenerateCode(method, writer); } else { writer.UsingBlock(declaration, w => Next?.GenerateCode(method, w)); } break; case DisposeTracking.RegisterWithScope: writer.Write(declaration + ";"); writer.Write($"{_scope.Usage}.{nameof(Scope.TryAddDisposable)}({Variable.Usage});"); Next?.GenerateCode(method, writer); break; } }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { IfStyle.Open(writer, null); if (_constructor == null) { writer.WriteLine($"throw new {typeof(InvalidOperationException).FullNameInCode()}(\"There is no default constructor for {_returnType.FullNameInCode()}\");"); } else if (_setter != null) { writer.WriteLine("return AggregateBuilder();"); } else { writer.WriteLine($"return new {_returnType.FullNameInCode()}();"); } IfStyle.Close(writer); Next?.GenerateCode(method, writer); }
private void WriteConstructorMethod(ISourceWriter writer, HashSet <InjectedField> args) { var tempQualifier = args.Select(x => x.CtorArgDeclaration); var ctorArgs = string.Join(", ", tempQualifier); var declaration = $"public {this.TypeName}({ctorArgs})"; if (this.BaseConstructorArguments.Any()) { var tempQualifier1 = this.BaseConstructorArguments.Select(x => x.ArgumentName); declaration = $"{declaration} : base({string.Join(", ", tempQualifier1)})"; } writer.Block(declaration); foreach (var field in args) { field.WriteAssignment(writer); } writer.FinishBlock(); }
public void Write(ISourceWriter writer) { writeDeclaration(writer); if (AllInjectedFields.Any()) { writeFieldDeclarations(writer, AllInjectedFields); writeConstructorMethod(writer, AllInjectedFields); } writeSetters(writer); foreach (var method in _methods.Where(x => x.WillGenerate())) { writer.BlankLine(); method.WriteMethod(writer); } writer.FinishBlock(); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { writer.Write( $"await {typeof(JasperEnvelopeEntityFrameworkCoreExtensions).FullName}.{nameof(JasperEnvelopeEntityFrameworkCoreExtensions.EnlistInTransaction)}({_context.Usage}, {Context.Usage});"); foreach (var loaded in _loadedDocs) { loaded.Write(writer, Context); } Next?.GenerateCode(method, writer); foreach (var saved in _saved) { writer.Write($"{Context.Usage}.{nameof(DbContext.Add)}({saved.Usage});"); } writer.BlankLine(); writer.WriteComment("Commit the unit of work"); writer.Write($"await {Context.Usage}.{nameof(DbContext.SaveChangesAsync)}();"); }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { if (_createsSession) { writer.BlankLine(); writer.WriteComment("Open a new document session"); writer.Write( $"BLOCK:using (var {Session.Usage} = {_store.Usage}.{nameof(IDocumentStore.LightweightSession)}())"); } if (_context != null && _isUsingPersistence) { writer.Write( $"await {typeof(MessageContextExtensions).FullName}.{nameof(MessageContextExtensions.EnlistInTransaction)}({_context.Usage}, {Session.Usage});"); } foreach (var loaded in _loadedDocs) { loaded.Write(writer, Session); } Next?.GenerateCode(method, writer); foreach (var saved in _saved) { writer.Write($"{Session.Usage}.{nameof(IDocumentSession.Store)}({saved.Usage});"); } writer.BlankLine(); writer.WriteComment("Commit the unit of work"); writer.Write($"await {Session.Usage}.{nameof(IDocumentSession.SaveChangesAsync)}();"); if (_createsSession) { writer.FinishBlock(); } }
public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) { switch (Mode) { case ConstructorCallMode.Variable: writer.Write(Declaration() + ";"); ActivatorFrames.Write(method, writer); Next?.GenerateCode(method, writer); break; case ConstructorCallMode.ReturnValue: if (ActivatorFrames.Any()) { writer.Write(Declaration() + ";"); ActivatorFrames.Write(method, writer); writer.Write($"return {Variable.Usage};"); Next?.GenerateCode(method, writer); } else { writer.Write($"return {Invocation()};"); Next?.GenerateCode(method, writer); } break; case ConstructorCallMode.UsingNestedVariable: writer.UsingBlock(Declaration(), w => { ActivatorFrames.Write(method, writer); Next?.GenerateCode(method, w); }); break; } }