public override void OnBeforeBuild(BuilderState state) { if (this._config == null) { this._config = state.ResolveOption(this.option); } if (this._config == null) { return; } if (this._config.packages.Count > 0) { foreach (var p in this._config.packages) { if (!state.includedPackages.Contains(p)) { state.includedPackages.Add(p); } } } for (int i = 0; i < this._config.modules.Count; i++) { var m = this._config.modules[i]; m.OnBeforeBuild(state); } }
public void AppendLineWithText_Adds_Text() { var sut = new BuilderState(new TypeInformation()); sut.AppendLine("hello"); Assert.Equal($"hello{Environment.NewLine}", sut.Builder.ToString()); }
public static XElement Build(IXmlDescriptor descriptor, BuilderState state = null) { if (state == null) state = new BuilderState(); descriptor = ProcessBindings(descriptor, state); var xelement = new XElement(descriptor.XmlTagName); if (descriptor.XmlAttributes != null) foreach (var attribute in descriptor.XmlAttributes) { if (attribute.Key != null && !attribute.Value.IsDefault()) { var xattribute = new XAttribute(attribute.Key, attribute.Value); xelement.Add(xattribute); } } if (descriptor.XmlChildren != null) foreach (var child in descriptor.XmlChildren) if (child != null) { var xchild = Build(child, state); xelement.Add(xchild); } if (descriptor.XmlCustomContent != null) xelement.Add(descriptor.XmlCustomContent); return xelement; }
public void AppendLine_Adds_EmptyLine() { var sut = new BuilderState(new TypeInformation()); sut.AppendLine(); Assert.Equal(Environment.NewLine, sut.Builder.ToString()); }
private static IXmlDescriptor ProcessBindings(IXmlDescriptor descriptor, BuilderState state) { var bindable = descriptor as IBindable; if (bindable != null && bindable.DataContext != null) { var data = bindable.DataContext; var bindableType = bindable.GetType(); var bindableProps = state.GetTypeProps(bindableType); var bindablePropValues = bindableProps .Select(b => new { Property = b, Value = b.IsIndexed() ? null : b.GetValue(bindable)?.ToString() }) .Where(b => b.Value.IsBindingDefenition()); if (bindablePropValues.Any()) { var dataType = data.GetType(); var dataProps = state.GetTypeProps(dataType); var correspondingProperties = bindablePropValues .Select(b => new { BindablePropery = b.Property, DataProperty = dataProps.FirstOrDefault(d => d.Name.ToBindingDefenition() == b.Value && d.PropertyType == b.Property.PropertyType) }) .Where(p => p.DataProperty != null).ToList(); foreach (var pair in correspondingProperties) { var value = pair.DataProperty.GetValue(data); pair.BindablePropery.SetValue(bindable, value); } } } return descriptor; }
public ITreeBuilder End() { ++noOfCommands; if (RequiresRootNode()) { SetErrorCode(BuilderError.REQUIRES_A_ROOT_NODE); return(this); } if (IsTreeInvalid()) { return(this); } if (mCallStack.Count <= 0) { SetErrorCode(BuilderError.STACK_UNDERFLOW); return(this); } mCallStack.Pop(); if (!ContainsItems()) { State = BuilderState.TREE_OK; mErrorCode = BuilderError.NO_ERROR; } //delete frame; return(this); }
private void PushNewFrame(INode currentNode) { mCallStack.Push(new TreeBuilderFrame { Parent = currentNode }); State = BuilderState.INVALID_TREE; }
void RunTransformsAndGenerateCode(ref BuilderState state, IDecompilerOutput output, DecompilationContext ctx, IAstTransform?additionalTransform = null) { var astBuilder = state.AstBuilder; astBuilder.RunTransformations(transformAbortCondition); if (additionalTransform is not null) { additionalTransform.Run(astBuilder.SyntaxTree); } var settings = GetDecompilerSettings(); CSharpDecompiler.AddXmlDocumentation(ref state, settings, astBuilder); var csharpUnit = astBuilder.SyntaxTree; csharpUnit.AcceptVisitor(new ICSharpCode.NRefactory.CSharp.InsertParenthesesVisitor() { InsertParenthesesForReadability = true }); GenericGrammarAmbiguityVisitor.ResolveAmbiguities(csharpUnit); var unit = csharpUnit.AcceptVisitor(new CSharpToVBConverterVisitor(state.AstBuilder.Context.CurrentModule, new ILSpyEnvironmentProvider(state.State.XmlDoc_StringBuilder)), null); var outputFormatter = new VBTextOutputFormatter(output, astBuilder.Context); var formattingPolicy = CreateVBFormattingOptions(settings); unit.AcceptVisitor(new OutputVisitor(outputFormatter, formattingPolicy), null); }
void Awake() { stopwatch = new Stopwatch(); state = BuilderState.None; startQualifierThread = false; regionLocationIndexes = new List <int>(); }
public void DoubleIncrement_Adds_DoubleIdentation() { var sut = new BuilderState(new TypeInformation()).IncrementIdentation().IncrementIdentation(); sut.AppendLine("hello"); Assert.Equal($" hello{Environment.NewLine}", sut.Builder.ToString()); }
public override void OnBuild(BuilderState config) { var targetGroup = BuilderWindow.GetBuildTargetGroup(config.buildTarget); var scriptingDefines = PlayerSettings.GetScriptingDefineSymbolsForGroup(targetGroup); config.parameters[this] = new State { targetGroup = targetGroup, originalDefines = scriptingDefines }; var newDefines = new List <string>(); foreach (var d in scriptingDefines.Split(';').Select(x => x.Trim()).Where(x => !string.IsNullOrEmpty(x))) { if (!newDefines.Contains(d)) { newDefines.Add(d); } } foreach (var s in this.defines) { if (!newDefines.Contains(s)) { newDefines.Add(s); } } PlayerSettings.SetScriptingDefineSymbolsForGroup(targetGroup, string.Join(";", newDefines.ToArray())); }
public DLCTransactionBuilder GetBuilder(Network network) { if (BuilderState is null) { throw new InvalidOperationException("The builder is not created yet"); } return(new DLCTransactionBuilder(BuilderState.ToString(), network)); }
internal TypeBuilder(ManualCompositeTypeProvider provider, Expression <Func <T, int> > versionGetter, string typeName = null) { State = new BuilderState(); State.Provider = provider; State.Type = typeof(T); State.TypeName = typeName ?? typeof(T).FullName; SetVersionProperty(versionGetter); }
public TreeBuilder() { mCallStack = new Stack <TreeBuilderFrame> (); noOfCommands = 0; mErrorCode = BuilderError.NO_ERROR; State = BuilderState.INVALID_TREE; mRoot = null; }
public void Increment_Increases_Identation() { var sut = new BuilderState(new TypeInformation()); var state = sut.IncrementIdentation(); Assert.Equal(0, sut.Identation); Assert.Equal(4, state.Identation); }
public void AppendLineWithText_Adds_IdentationSpacesAndText() { var baseIdentation = new BuilderState(new TypeInformation()); var sut = baseIdentation.IncrementIdentation(); sut.AppendLine("world"); Assert.Equal($" world{Environment.NewLine}", sut.Builder.ToString()); }
public TreeBuilder () { mCallStack = new Stack<TreeBuilderFrame> (); noOfCommands = 0; mErrorCode = BuilderError.NO_ERROR; State = BuilderState.INVALID_TREE; mRoot = null; }
private void Push(BuilderState state) { if (state == BuilderState.Array || state == BuilderState.Struct) { _firstObjectItemWritten.Add(false); } _state.Push(state); }
public void AdvanceTo(BuilderState next) { if(!CanAdvanceTo(next)) throw new InvalidOperationException("Can't move from state " + _state.ToString() + " to state " + next.ToString() + "."); BuilderState before = _state; _state = next; OnAfterAdvance(before, next, before != BuilderState.Idle, before != BuilderState.Idle && before != BuilderState.System); }
public FeatureImportInfo(BuilderState state, FeatureImportType type, uint script, uint language, uint feature) { _state = state; _type = type; _script = script; _language = language; _feature = feature; }
private void classAnalysis(TypeDefinition classDef) { BuilderState state = new BuilderState(this); foreach (var pass in classAnalysisPasses) { pass.analyze(classDef, state); } }
private void instructionAnalysis(Instruction instruction) { BuilderState state = new BuilderState(this); foreach (var pass in instructionAnalysisPasses) { pass.analyze(instruction, state); } }
public void Increment_DoesNotChange_TypeInformation_Builder_ToProcessTypeSymbols() { var sut = new BuilderState(new TypeInformation()); var state = sut.IncrementIdentation(); Assert.Same(sut.Builder, state.Builder); Assert.Same(sut.TypeInfo, state.TypeInfo); Assert.Same(sut.ToProcessTypeSymbols, state.ToProcessTypeSymbols); }
public void BeginProperty(string name) { Log("Begin property named " + name); Debug.Assert(m_BuilderState == BuilderState.Rule); m_BuilderState = BuilderState.Property; m_CurrentPropertyName = name; }
private void methodAnalysis(MethodDefinition methodDef) { BuilderState state = new BuilderState(this); foreach (var pass in methodAnalysisPasses) { pass.analyze(methodDef, state); } }
private void fieldAnalysis(FieldDefinition fieldDef) { BuilderState state = new BuilderState(this); foreach (var pass in fieldAnalysisPasses) { pass.analyze(fieldDef, state); } }
internal VersionBuilder(ManualCompositeTypeProvider provider, int version, CompositeProperty versionProperty, string typeName = null) { State = new BuilderState(); State.Provider = provider; State.Type = typeof(T); State.TypeName = typeName ?? typeof(T).FullName; State.Version = version; State.VersionProperty = versionProperty; }
public override void OnAfterBuild(BuilderState config) { if (!this.runAfterBuild || string.IsNullOrEmpty(this.path)) { return; } this.Run(this.path, config); }
public void NewBuilder_Initialized() { var typeInfo = new TypeInformation(); var sut = new BuilderState(typeInfo); Assert.Same(typeInfo, sut.TypeInfo); Assert.Equal(0, sut.Identation); Assert.Empty(sut.ToProcessTypeSymbols); Assert.NotNull(sut.Builder); }
public bool CanAdvanceTo(BuilderState next) { if(next == BuilderState.Idle) return true; int n = (int)next; int s = (int)_state; return n >= s; }
public void BeginRule(int ruleLine) { Log("Beginning rule"); Debug.Assert(m_BuilderState == BuilderState.Init); m_BuilderState = BuilderState.Rule; m_CurrentRule = new StyleRule { line = ruleLine }; }
private void defineQualifiers() { WorldBuilderProtocol.defineQualifiers(ref worldData); worldData.updateBoxerDistribution(); state = BuilderState.Complete; stopwatch.Stop(); print(stopwatch.Elapsed); }
public void AdvanceTo(BuilderState next) { if (!CanAdvanceTo(next)) { throw new InvalidOperationException("Can't move from state " + _state.ToString() + " to state " + next.ToString() + "."); } BuilderState before = _state; _state = next; OnAfterAdvance(before, next, before != BuilderState.Idle, before != BuilderState.Idle && before != BuilderState.System); }
public void EndProperty() { Log("Ending property"); Debug.Assert(m_BuilderState == BuilderState.Property); m_BuilderState = BuilderState.Rule; m_CurrentProperty.values = m_CurrentValues.ToArray(); m_CurrentProperty = null; m_CurrentValues.Clear(); }
public void Builder_AppendsLine_BasedOnItsIdentation() { var baseIdentation = new BuilderState(new TypeInformation()); baseIdentation.AppendLine("hello"); var sut = baseIdentation.IncrementIdentation(); sut.AppendLine("world"); baseIdentation.AppendLine("!"); Assert.Equal($"hello{Environment.NewLine} world{Environment.NewLine}!{Environment.NewLine}", sut.Builder.ToString()); }
protected override void OnAfterAdvance(BuilderState before, BuilderState after, bool wasInsideSystem, bool wasInsideGroup) { if(after != before) { if(wasInsideGroup) _writer.WriteEndElement(); if(after == BuilderState.Idle) _writer.WriteEndElement(); else _writer.WriteStartElement(after.ToString(), Context.YttriumNamespace); } }
private BuilderState Pop(BuilderState expectedState) { var currentState = Peek(); if (currentState != expectedState) { throw new InvalidOperationException(string.Format("Invalid state: current state is {0} but {1} was expected.", currentState, expectedState)); } var lastState = _state.Pop(); if (lastState == BuilderState.Array || lastState == BuilderState.Struct) { _firstObjectItemWritten.RemoveAt(_firstObjectItemWritten.Count - 1); } return lastState; }
public void SetFrom(IDataReader reader) { Id = reader.GetInt("Id").Value; State = (BuilderState) reader.GetInt("StateId").Value; }
public void UpdateState(BuilderState state) { Builder.State = state; dbBuilder.UpdateState(Builder.Id, state); }
private void PushNewFrame (INode currentNode) { mCallStack.Push (new TreeBuilderFrame { Parent=currentNode }); State = BuilderState.INVALID_TREE; }
public ITreeBuilder End() { ++noOfCommands; if (RequiresRootNode()) { SetErrorCode(BuilderError.REQUIRES_A_ROOT_NODE); return this; } if(IsTreeInvalid()) { return this; } if(mCallStack.Count <= 0) { SetErrorCode (BuilderError.STACK_UNDERFLOW); return this; } mCallStack.Pop(); if(!ContainsItems()) { State = BuilderState.TREE_OK; mErrorCode = BuilderError.NO_ERROR; } //delete frame; return this; }
public BuilderStateMachine() { _state = BuilderState.Idle; }
public virtual void Reset() { _state = BuilderState.Idle; }
protected virtual void OnAfterAdvance(BuilderState before, BuilderState after, bool wasInsideSystem, bool wasInsideGroup) { }
public void UpdateState(int builderId, BuilderState state) { const string query = "UPDATE [Builder] SET [StateId] = {1} WHERE Id = {0}"; using (var connection = SqlConnectionHelper.OpenConnection(connectionString)) { using (var cmd = new SqlCommand(string.Format(query, builderId, (int)state), connection)) { cmd.CommandTimeout = 30000; cmd.ExecuteNonQuery(); } } }