protected override IScope[] Select(List<IScope> scopes) { IRandom random = RandomParameter.ActualValue; int children = ChildrenParameter.ActualValue.Value; int parents = ParentsPerChildParameter.ActualValue.Value; int parentsAvailable = scopes.Count; if (parents > parentsAvailable) throw new InvalidOperationException("WithoutRepeatingBatchedRandomSelector: Cannot select more parents per child than there are parents available"); IScope[] result = new IScope[children * parents]; int count = 0; HashSet<int> selectedParents = new HashSet<int>(); for (int i = 0; i < children; i++) { selectedParents.Clear(); for (int j = 0; j < parents; j++) { int nextParent = j; // will be used in case parents == parentsAvailable if (parents < parentsAvailable) { do { nextParent = random.Next(parentsAvailable); } while (selectedParents.Contains(nextParent)); } result[count++] = (IScope)scopes[nextParent].Clone(); selectedParents.Add(nextParent); } } return result; }
protected internal Init(NRefactory.VariableInitializer variableInitializer, IScope scope, INRefcatoryExpressionVisitor visitor) : base(scope, visitor) { NRefactory.Expression initializer = null; _variableInitializer = variableInitializer; initializer = variableInitializer.Initializer; }
/// <summary> /// Add built-in array functions to the scope /// </summary> internal static void Register(IScope scope) { scope.SetValue("l3.mapToMap", new MapToMap()); scope.SetValue("l3.mapToArray", new MapToArray()); scope.SetValue("l3.getMapKeys", new GetMapKeys()); scope.SetValue("l3.getMapValues", new GetMapValues()); }
/// <summary> /// Lookups the input type of the provider. /// </summary> /// <param name="scope">The scope.</param> /// <param name="name">The provider name.</param> /// <returns><code>Live</code> if live, <code>Vod</code> if VOD stream, <code>NotFound</code> otherwise.</returns> /// <remarks>Live is checked first and VOD second.</remarks> public InputType LookupProviderInputType(IScope scope, string name) { InputType result = InputType.NotFound; if (scope.GetBasicScope(Constants.BroadcastScopeType, name) != null) { //We have live input result = InputType.Live; } else { try { FileInfo file = GetStreamFile(scope, name); if (file != null) { //We have vod input result = InputType.Vod; } } catch (Exception ex) { log.Warn(string.Format("Exception attempting to lookup file: {0}", name), ex); } } return result; }
public IMessageInput GetProviderInput(IScope scope, string name) { IMessageInput msgIn = GetLiveProviderInput(scope, name, false); if (msgIn == null) return GetVODProviderInput(scope, name); return msgIn; }
protected internal AbstractExpression(IScope scope, IExpressionConfigurationVisitor visitor) { if (scope != null) { Scope = scope; } Visitor = visitor; }
public SummonAction(IScope scope, ICost cost, UnitData unit, IScreenEffect screenEffect) { _scope = scope; _cost = cost; _unit = unit; _screenEffect = screenEffect; }
protected override void InternalExecute(IScope scope) { var commands = Regex.Split(CommandText, @"(?i)(^|[\r\n])\s*go\s*([\r\n]|$)") .Where(_=>!string.IsNullOrWhiteSpace(_) && _.Trim().ToLowerInvariant()!="go").ToArray(); using (var c = GetConnection(null, scope)) { c.WellOpen(); L.Trace(">>>> start script " +TaskCode + " : " + TaskName); for (var i = 0; i < commands.Length; i++) { var command = c.CreateCommand(); command.CommandText = commands[i]; try { command.ExecuteNonQuery(); } catch (Exception e) { if (ErrorLevel <= LogLevel.Trace) { L.Trace("<<<<< error " + TaskCode + " : " + i + " : " + e.Message); continue; } throw; } L.Info(">>>> executed " + TaskCode + " : " + i); L.Debug(commands[i]); } L.Trace("<<<<< end script " + TaskCode + " : " + TaskName); } }
internal SystemContext(ServiceContainer container) { scope = container.OpenScope(ContextNames.System); scope.RegisterInstance<ISystemContext>(this); EventRegistry = new EventRegistry(this); }
protected internal Index(NRefactory.IndexerExpression indexerExpression, IScope scope, INRefcatoryExpressionVisitor visitor) : base(scope, visitor) { bool isAssignment = false; PropertyReference propertyReference = null; _indexerExpression = indexerExpression; isAssignment = IsAssignment(); Target = indexerExpression.Target.AcceptVisitor(Visitor, ParentScope); TryGetArguments(); if (indexerExpression.HasAnnotationOf<PropertyReference>(out propertyReference)) { var propertyInfo = Target.Type.GetProperty(propertyReference.Name); InternalType = propertyInfo.PropertyType; _indexer = propertyInfo; } else { _isArrayIndex = true; var targetType = Target.Type; if (targetType.HasElementType) { targetType = Target.Type.GetElementType(); } InternalType = targetType; _methodCall = _isAssignment ? Expression.ArrayAccess : (Func<Expression, IEnumerable<Expression>, Expression>)Expression.ArrayAccess; } }
/// <summary> /// Constructor /// </summary> /// <param name="statement">The statement.</param> /// <param name="sqlStatement"></param> /// <param name="scope"></param> public ProcedureSql(IScope scope, string sqlStatement, IStatement statement) { _sqlStatement = sqlStatement; _statement = statement; _dataExchangeFactory = scope.DataExchangeFactory; }
protected internal Identifier(NRefactory.IdentifierExpression identifierExpression, IScope scope, INRefcatoryExpressionVisitor visitor) : base(scope, visitor) { _identifierExpression = identifierExpression; Expression = scope.Find(_identifierExpression.Identifier); InternalType = Expression.Type; Name = _identifierExpression.Identifier; }
protected internal Switch(NRefactory.SwitchStatement switchStatement, IScope scope, INRefcatoryExpressionVisitor visitor) : base(scope, visitor) { _switchStatement = switchStatement; SwitchValue = switchStatement.Expression.AcceptVisitor(Visitor, scope); BuildSwitchCases(); InternalType = TypeSystem.Void; }
protected VScope(IScope Parent) { this.OnDateType = new Dictionary<string, List<Type>>(); this.ScopeVariables = new List<Expression>(); this.ScopeFunctions = new List<FunctionMeta>(); this.Parent = Parent; }
public ParameterScope( IScope parent, string[] parameters ) { _parent = parent; _contents = new StandardScope(); foreach( string p in parameters ) _contents.set( p, null ); }
internal static Value Do(List<DelimiterList> parsedLines, IScope scope) { // run each line, returning value of last line Value retval = null; int count = parsedLines.Count; int indent = -1; for (int i = 0; i < count; i++) { DelimiterList line = parsedLines[i]; if (indent == -1) indent = line.Indent; if (indent == line.Indent) { // only run lines that are at the original indentation ILineRequestor requestor = Utility.GetSubLineRequestor(parsedLines, i, out i); try { retval = EvalList.Do(line.Nodes, scope, requestor); } catch (Loki3Exception e) { // this line is the correct context if there isn't already one there if (!e.Errors.ContainsKey(Loki3Exception.keyLineContents)) e.AddLine(line.Original); if (requestor != null && !e.Errors.ContainsKey(Loki3Exception.keyLineNumber)) e.AddLineNumber(requestor.GetCurrentLineNumber()); throw e; } } } return (retval == null ? new ValueNil() : retval); }
/// <summary> /// Initializes a new instance of the FileConsumer class. /// </summary> /// <param name="scope">Scope of consumer.</param> /// <param name="file">File.</param> public FileConsumer(IScope scope, FileInfo file) { _scope = scope; _file = file; _offset = 0; _lastTimestamp = 0; _startTimestamp = -1; }
protected internal New(NRefactory.ObjectCreateExpression objectCreation, IScope scope, INRefcatoryExpressionVisitor visitor) : base(scope, visitor) { _objectCreation = objectCreation; if (!objectCreation.Type.IsNull) { InternalType = objectCreation.Type.AcceptVisitor(Visitor, ParentScope).Type; if (objectCreation.Initializer != null) { if (objectCreation.Arguments.Count == 2) { Expression expression; NRefactory.Expression @this = objectCreation.Arguments.First(); NRefactory.Expression func = objectCreation.Arguments.Last(); if (TryHandleAnonymousMethod(@this, func as NRefactory.InvocationExpression, out expression)) { Expression = expression; return; } } if (objectCreation.Initializer != NRefactory.ArrayInitializerExpression.Null) { Expression = objectCreation.Initializer.AcceptVisitor(Visitor, ParentScope); return; } } Expression = BuildConstructor(); } else { Expression = HandleAnonymousType(); } }
internal static Value Do(List<Value> valueLines, IScope parent) { // run each line, returning value of last line Value retval = null; int count = valueLines.Count; for (int i = 0; i < count; i++) { Value v = valueLines[i]; if (v is ValueString) { ILineRequestor requestor = Utility.GetSubLineRequestor(valueLines, i, out i); DelimiterList line = ParseLine.Do(v.AsString, parent); retval = EvalList.Do(line.Nodes, parent, requestor); } else if (v is ValueRaw) { ValueRaw raw = v as ValueRaw; // use value's scope if present, otherwise use passed in scope IScope rawScope = (raw.Scope != null ? raw.Scope : parent); retval = EvalList.Do(raw.GetValue().Nodes, rawScope); } else { throw new Loki3Exception().AddBadLine(v); } } return (retval == null ? new ValueNil() : retval); }
public RunTimeView(IEnterInterpreterHost pEnterClientInterface, Epi.View pView, int pParentRecordId, string pParentGlobalRecordId, IScope pScope = null) { // to do set the enter interpreter // application domain. Assembly a = Assembly.Load(pView.Project.EnterMakeviewIntepreter); // Get the type to use. Type myType = a.GetType(pView.Project.EnterMakeviewIntepreter + ".EpiInterpreterParser"); // Create an instance. if (pScope == null) { this.mEpiInterpreter = (IEnterInterpreter)Activator.CreateInstance(myType, new object[] { pEnterClientInterface }); } else { this.mEpiInterpreter = (IEnterInterpreter)Activator.CreateInstance(myType, new object[] { pEnterClientInterface, pScope }); } this.mEpiInterpreter.Context.Scope.Name = pView.Name; this.mEpiInterpreter.Host = pEnterClientInterface; this.EnterClientInterface = pEnterClientInterface; this.AfterStack = new Stack<KeyValuePair<EventActionEnum, StackCommand>>(); this.parentViewRecordId = pParentRecordId; this.parentViewGlobalRecordId = pParentGlobalRecordId; this.RecordNumberMap = new Dictionary<int, int>(); this.mView = pView; this.mView.ForeignKeyField.CurrentRecordValueString = this.ParentGlobalRecordId; }
private void DoBuildHtml(IReportContext context, IScope scope) { var htmlconfig = new HtmlConfig(); bool standalone = context.Request.Standalone; if (standalone) { htmlconfig.DocHeader = RenderXml(context, scope, DocHeader, null, "DocHeader"); } htmlconfig.Header = RenderXml(context, scope, Header, null, "Header"); htmlconfig.Content = RenderXml(context, scope, Content, null, "Content"); var items = context.Data.arr("items"); IList<ItemXml> xitems = new List<ItemXml>(); if (null != items) { var i = 0; foreach (var item in items) { var itemScope = new Scope(scope); itemScope["_item"] = item; itemScope["_idx"] = i; var xitem = new ItemXml(); xitem.Before = RenderXml(context, itemScope, BeforeItem, item, "BeforeItem"); xitem.Item = RenderXml(context, itemScope, Item, item, "Item"); xitem.After = RenderXml(context, itemScope, AfterItem, item, "AfterItem"); if (null != (xitem.Before ?? xitem.After ?? xitem.Before)) { xitems.Add(xitem); } i++; } } htmlconfig.Items = xitems; htmlconfig.Footer = RenderXml(context, scope, Footer, null, "Footer"); XElement docfooter = null; if (standalone) { htmlconfig.DocFooter = RenderXml(context, scope, DocFooter, null, "DocFooter"); } var xmlhtml = CompileHtml(context, scope, htmlconfig); context.Write(xmlhtml.ToString()); }
public GiveAbnormalConditionAction(IScope scope, ICost cost, IScreenEffect screenEffect, IAbnormalCondition cond) { _scope = scope; _cost = cost; _screenEffect = screenEffect; _cond = cond; }
public override bool Equals(IScope x, IScope y) { if (object.ReferenceEquals(x, y)) return true; if (x == null || y == null) return false; double q1 = ((DoubleValue)x.Variables[QualityVariableName].Value).Value; double q2 = ((DoubleValue)y.Variables[QualityVariableName].Value).Value; return q1.IsAlmost(q2) && CalculateSolutionSimilarity(x, y).IsAlmost(1.0); }
/// <summary> /// Eval a list of DelimiterNodes and return a Value /// </summary> internal static Value Do(List<DelimiterNode> nodes, IScope scope, ILineRequestor requestor) { ListEval eval = new ListEval(nodes, scope); while (eval.EvalNext(requestor)) ; return eval.GetValue(); }
public string GenerateFilename(IScope scope, string name, string extension, GenerationType type) { string result = GetStreamDirectory(scope) + name; if (extension != null && !string.Empty.Equals(extension)) { result += extension; } return result; }
protected internal NamedExpression(NRefactory.NamedExpression namedExpression, IScope scope, INRefcatoryExpressionVisitor visitor) : base(scope, visitor) { Name = namedExpression.Identifier; _namedExpression = namedExpression; Expression = _namedExpression.Expression.AcceptVisitor(Visitor, ParentScope); InternalType = Expression.Type; }
protected internal Invocation(NRefactory.InvocationExpression invocationExpression, IScope scope, INRefcatoryExpressionVisitor visitor) : base(scope, visitor) { var methodReference = invocationExpression.Annotation<Mono.Cecil.MethodReference>(); _invocationExpression = invocationExpression; if (methodReference != null) { MethodInfo methodInfo = null; Member = methodInfo = methodReference.GetActualMethod<MethodInfo>(); if (IsInitializeArray(methodInfo)) { var first = _invocationExpression.Arguments.First().AcceptVisitor(Visitor, ParentScope); var invocation = _invocationExpression.Arguments.Last() as NRefactory.InvocationExpression; var second = invocation.Arguments.First(); var memberReference = invocationExpression.Target as NRefactory.MemberReferenceExpression; var target = memberReference.Target as NRefactory.TypeReferenceExpression; var type = target.Type.GetActualType(); var parameters = methodReference.Parameters; return; } } BuildInvocation(); }
/// <summary>Read and eval all the lines in a file</summary> internal static void Do(string file, IScope scope) { StreamReader stream = null; try { List<string> lines = new List<string>(); stream = new StreamReader(file); while (!stream.EndOfStream) lines.Add(stream.ReadLine()); LineConsumer consumer = new LineConsumer(lines); EvalLines.Do(consumer, scope); stream.Close(); } catch (Loki3Exception e) { e.AddFileName(file); if (stream != null) stream.Close(); throw e; } catch (System.Exception e) { if (stream != null) stream.Close(); throw e; } }
protected EngineAlgorithm() : base() { globalScope = new Scope("Global Scope"); globalScope.Variables.Add(new Variable("Results", new ResultCollection())); operatorGraph = new OperatorGraph(); Initialize(); }
//interface public static IInterface evaluate(Node_Interface node, IScope scope) { IList<IInterface> inheritees = new List<IInterface>(); IList<Callee> callees = new List<Callee>(); IList<Breeder> breeders = new List<Breeder>(); IList<Property> props = new List<Property>(); IList<Method> meths = new List<Method>(); foreach( INode_Expression inherNode in node.inheritees ) inheritees.Add( Bridge.toNativeInterface( Executor.executeAny(inherNode, scope))); foreach( Node_StatusedMember sm in node.members ) { //xxx member status (sm.memberStatus) is ignored INode_InterfaceMember member = sm.member; if( member is Node_Callee ) callees.Add(evaluate(member as Node_Callee, scope)); if( member is Node_Breeder ) breeders.Add(evaluate(member as Node_Breeder, scope)); if( member is Node_Property ) props.Add(evaluate(member as Node_Property, scope)); if( member is Node_Method ) meths.Add(evaluate(member as Node_Method, scope)); } return new Interface( inheritees, callees, breeders, props, meths ); }
/// <summary> /// Connect to another scope on server. /// </summary> /// <param name="scope">New scope.</param> /// <returns>true on success, false otherwise.</returns> public bool Connect(IScope scope) { return(Connect(scope, null)); }
internal DataSource(IScope scope) { this.scope = scope; }
public IScope GetNewScope(string pName, IScope pParent) { return(new SymbolTable(pName, pParent)); }
private void Initialize() { IScope scope = this.currentScope; while (scope.GetEnclosingScope() != null) { if (scope.Name == "global") { LoadPermanentVariables(scope); break; } scope = scope.GetEnclosingScope(); } ProgramText = new StringBuilder(); DLLClassList = new Dictionary <string, IDLLClass>(StringComparer.OrdinalIgnoreCase); _parsedUndefinedVariables = new List <string>(); _parsedFieldNames = new List <string>(); _parsedPageNames = new List <string>(); Page_Checkcode = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); Field_Checkcode = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); BeforeCheckCode = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); AfterCheckCode = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); PageBeforeCheckCode = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); PageAfterCheckCode = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); FieldBeforeCheckCode = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); FieldAfterCheckCode = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); FieldClickCheckCode = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); Subroutine = new Dictionary <string, EnterRule>(StringComparer.OrdinalIgnoreCase); _IsVariableValidationEnable = false; SelectCommandList.Add(CommandNames.ABS); SelectCommandList.Add(CommandNames.ASSIGN); SelectCommandList.Add(CommandNames.ASCENDING); SelectCommandList.Add(CommandNames.AND); SelectCommandList.Add(CommandNames.ALWAYS); SelectCommandList.Add(CommandNames.APPEND); SelectCommandList.Add(CommandNames.MOD); SelectCommandList.Add(CommandNames.LIKE); SelectCommandList.Add(CommandNames.OR); SelectCommandList.Add(CommandNames.XOR); SelectCommandList.Add(CommandNames.NOT); SelectCommandList.Add(CommandNames.EXP); SelectCommandList.Add(CommandNames.LN); SelectCommandList.Add(CommandNames.LOG); SelectCommandList.Add(CommandNames.NUMTODATE); SelectCommandList.Add(CommandNames.NUMTOTIME); SelectCommandList.Add(CommandNames.RECORDCOUNT); SelectCommandList.Add(CommandNames.RND); SelectCommandList.Add(CommandNames.ROUND); SelectCommandList.Add(CommandNames.STEP); SelectCommandList.Add(CommandNames.SIN); SelectCommandList.Add(CommandNames.COS); SelectCommandList.Add(CommandNames.TAN); SelectCommandList.Add(CommandNames.TRUNC); SelectCommandList.Add(CommandNames.PFROMZ); SelectCommandList.Add(CommandNames.ZSCORE); SelectCommandList.Add(CommandNames.YEARS); SelectCommandList.Add(CommandNames.MONTHS); SelectCommandList.Add(CommandNames.DAYS); SelectCommandList.Add(CommandNames.YEAR); SelectCommandList.Add(CommandNames.MONTH); SelectCommandList.Add(CommandNames.DAY); SelectCommandList.Add(CommandNames.CURRENTUSER); SelectCommandList.Add(CommandNames.EXISTS); SelectCommandList.Add(CommandNames.FILEDATE); SelectCommandList.Add(CommandNames.SYSTEMDATE); SelectCommandList.Add(CommandNames.SYSTEMTIME); SelectCommandList.Add(CommandNames.HOURS); SelectCommandList.Add(CommandNames.MINUTES); SelectCommandList.Add(CommandNames.SECONDS); SelectCommandList.Add(CommandNames.HOUR); SelectCommandList.Add(CommandNames.MINUTE); SelectCommandList.Add(CommandNames.SECOND); SelectCommandList.Add(CommandNames.FINDTEXT); SelectCommandList.Add(CommandNames.FORMAT); SelectCommandList.Add(CommandNames.LINEBREAK); SelectCommandList.Add(CommandNames.STRLEN); SelectCommandList.Add(CommandNames.SUBSTRING); SelectCommandList.Add(CommandNames.TXTTONUM); SelectCommandList.Add(CommandNames.TXTTODATE); SelectCommandList.Add(CommandNames.UPPERCASE); SelectCommandList.Add(CommandNames.ISUNIQUE); SelectCommandList.Add(CommandNames.EPIWEEK); SelectCommandList.Add("("); SelectCommandList.Add(","); }
public Rule_Context(IScope pScope) { this.currentScope = new SymbolTable(pScope); this.Initialize(); }
public Rule_Context() { this.currentScope = new SymbolTable("global", null); Rule_Context.LoadPermanentVariables(this.currentScope); this.Initialize(); }
public DataModule(IScope scope, string connectionString) { Scope = scope; ConnectionString = connectionString; }
public DelegateOnDisposeScopeDecorator(Action @delegate, IScope scope) { _delegate = @delegate; _scope = scope; }
public override IOperation Apply() { double maxSelPress = MaximumSelectionPressureParameter.ActualValue.Value; double successRatio = SuccessRatioParameter.ActualValue.Value; IScope scope = ExecutionContext.Scope; IScope parents = scope.SubScopes[0]; IScope offspring = scope.SubScopes[1]; int populationSize = parents.SubScopes.Count; // retrieve actual selection pressure and success ratio DoubleValue selectionPressure = SelectionPressureParameter.ActualValue; if (selectionPressure == null) { selectionPressure = new DoubleValue(0); SelectionPressureParameter.ActualValue = selectionPressure; } DoubleValue currentSuccessRatio = CurrentSuccessRatioParameter.ActualValue; if (currentSuccessRatio == null) { currentSuccessRatio = new DoubleValue(0); CurrentSuccessRatioParameter.ActualValue = currentSuccessRatio; } // retrieve next population ItemList <IScope> population = OffspringPopulationParameter.ActualValue; ItemList <IScope> virtual_population = OffspringVirtualPopulationParameter.ActualValue; IntValue successfulOffspring; if (population == null) { population = new ItemList <IScope>(); OffspringPopulationParameter.ActualValue = population; selectionPressure.Value = 0; // initialize selection pressure for this round currentSuccessRatio.Value = 0; // initialize current success ratio for this round successfulOffspring = new IntValue(0); OffspringPopulationWinnersParameter.ActualValue = successfulOffspring; virtual_population = new ItemList <IScope>(); OffspringVirtualPopulationParameter.ActualValue = virtual_population; } else { successfulOffspring = OffspringPopulationWinnersParameter.ActualValue; } int successfulOffspringAdded = 0; // implement the ActualValue fetch here - otherwise the parent scope would also be included, given that there may be 1000 or more parents, this is quite unnecessary string tname = SuccessfulOffspringParameter.TranslatedName; double tmpSelPress = selectionPressure.Value; double tmpSelPressInc = 1.0 / populationSize; for (int i = 0; i < offspring.SubScopes.Count; i++) { // fetch value IVariable tmpVar; if (!offspring.SubScopes[i].Variables.TryGetValue(tname, out tmpVar)) { throw new InvalidOperationException(Name + ": Could not determine if an offspring was successful or not."); } BoolValue tmp = (tmpVar.Value as BoolValue); if (tmp == null) { throw new InvalidOperationException(Name + ": The variable that indicates whether an offspring is successful or not must contain a BoolValue."); } // add to population if (tmp.Value) { IScope currentOffspring = offspring.SubScopes[i]; offspring.SubScopes.RemoveAt(i); i--; // next loop should continue with the subscope at index i which replaced currentOffspring population.Add(currentOffspring); successfulOffspringAdded++; } else { IScope currentOffspring = offspring.SubScopes[i]; offspring.SubScopes.RemoveAt(i); i--; virtual_population.Add(currentOffspring); // add to losers pool } tmpSelPress += tmpSelPressInc; double tmpSuccessRatio = (successfulOffspring.Value + successfulOffspringAdded) / ((double)populationSize); if (tmpSuccessRatio >= successRatio && (population.Count + virtual_population.Count) >= populationSize) { break; } } successfulOffspring.Value += successfulOffspringAdded; // calculate actual selection pressure and success ratio selectionPressure.Value = tmpSelPress; currentSuccessRatio.Value = successfulOffspring.Value / ((double)populationSize); // check if enough children have been generated (or limit of selection pressure or evaluted solutions is reached) if (((EvaluatedSolutionsParameter.ActualValue.Value < MaximumEvaluatedSolutionsParameter.ActualValue.Value) && (selectionPressure.Value < maxSelPress) && (currentSuccessRatio.Value < successRatio)) || ((population.Count + virtual_population.Count) < populationSize)) { // more children required -> reduce left and start children generation again scope.SubScopes.Remove(parents); scope.SubScopes.Remove(offspring); while (parents.SubScopes.Count > 0) { IScope parent = parents.SubScopes[0]; parents.SubScopes.RemoveAt(0); // TODO: repeated call of RemoveAt(0) is inefficient? scope.SubScopes.Add(parent); // order of subscopes is reversed } IOperator offspringCreator = OffspringCreatorParameter.ActualValue as IOperator; if (offspringCreator == null) { throw new InvalidOperationException(Name + ": More offspring are required, but no operator specified for creating them."); } return(ExecutionContext.CreateOperation(offspringCreator)); // this assumes that this operator will be called again indirectly or directly } else { // enough children generated var fitnessComparer = new FitnessComparer(QualityParameter.TranslatedName, MaximizationParameter.ActualValue.Value); population.Sort(fitnessComparer); // sort individuals by descending fitness // keeps only the best successRatio * populationSize solutions in the population (the remaining ones are added to the virtual population) int removed = 0; for (int i = 0; i < population.Count; i++) { double tmpSuccessRatio = i / (double)populationSize; if (tmpSuccessRatio > successRatio) { virtual_population.Add(population[i]); removed++; } } population.RemoveRange(population.Count - removed, removed); //fill up population with best remaining children (successful or unsuccessful) virtual_population.Sort(fitnessComparer); int offspringNeeded = populationSize - population.Count; for (int i = 0; i < offspringNeeded && i < virtual_population.Count; i++) { population.Add(virtual_population[i]); // children are sorted by descending fitness } offspring.SubScopes.Clear(); offspring.SubScopes.AddRange(population); scope.Variables.Remove(OffspringPopulationParameter.TranslatedName); scope.Variables.Remove(OffspringVirtualPopulationParameter.TranslatedName); scope.Variables.Remove(OffspringPopulationWinnersParameter.TranslatedName); return(base.Apply()); } }
/// <summary> /// Initializes a new instance of the ScopeNotFoundException class. /// </summary> /// <param name="scope"></param> /// <param name="childName"></param> public ScopeNotFoundException(IScope scope, string childName) : base(__Res.GetString(__Res.Scope_ChildNotFound, childName, scope.Name)) { }
public NamespaceSymbol(string name, IScope enclosingScope) : base(name) { base.SetEnclosingScope(enclosingScope); }
public Singleton(IScope scope) { Name = scope.Name; }
public EngineHiveTask(EngineTask engineTask, IScope parentScopeClone) : base(engineTask) { this.parentScopeClone = parentScopeClone; }
internal ParagraphImpl(Microsoft.ReportingServices.ReportIntermediateFormat.Paragraph paragraphDef, Microsoft.ReportingServices.RdlExpressions.ReportRuntime reportRT, IErrorContext iErrorContext, IScope scope) { m_textRuns = new TextRunsImpl(paragraphDef, reportRT, iErrorContext, scope); }
public void HandleOperationBefore(IExecutionContext context, IScope scope) { }
protected EngineHiveTask(EngineHiveTask original, Cloner cloner) : base(original, cloner) { this.parentScopeClone = cloner.Clone(original.parentScopeClone); }
/// <summary> /// Executes as part of the upgrade scope and before all migrations have executed. /// </summary> public virtual void BeforeMigrations(IScope scope, ILogger logger) { }
public void HandleOperationAfter(IExecutionContext context, IScope scope) { }
/// <summary> /// Выполняет транзакцию /// </summary> /// <param name="actions"></param> /// <param name="context"></param> public static void ExecuteTransaction(this IEnumerable <TransactionAction> actions, IScope context = null) { if (actions == null) { throw new ArgumentNullException("actions"); } actions = actions.ToArray(); context = context ?? new Scope(); try { foreach (var a in actions) { a.Execute(context); } //если все выполнилось успешно - можно коммитить foreach (var a in actions) { a.Commit(context); } } catch { foreach (var a in actions) { a.Rollback(context); } } }
/// <summary> /// Executes as part of the upgrade scope and after all migrations have executed. /// </summary> public virtual void AfterMigrations(IScope scope, ILogger logger) { }
/// <summary> /// Выполняет операцию применения (для транзакций) /// </summary> /// <param name="context"></param> public abstract void Commit(IScope context);
public ParagraphsImpl(AspNetCore.ReportingServices.ReportIntermediateFormat.TextBox textBoxDef, AspNetCore.ReportingServices.RdlExpressions.ReportRuntime reportRT, IErrorContext iErrorContext, IScope scope) { this.m_textBoxDef = textBoxDef; this.m_reportRT = reportRT; this.m_iErrorContext = iErrorContext; this.m_scope = scope; List <AspNetCore.ReportingServices.ReportIntermediateFormat.Paragraph> paragraphs = this.m_textBoxDef.Paragraphs; if (paragraphs != null) { this.m_paragraphs = new ParagraphImpl[paragraphs.Count]; } else { this.m_paragraphs = new ParagraphImpl[0]; } }
/// <summary> /// Parse Inline ParameterMap /// </summary> /// <param name="statement"></param> /// <param name="sqlStatement"></param> /// <returns>A new sql command text.</returns> /// <param name="scope"></param> public SqlText ParseInlineParameterMap(IScope scope, IStatement statement, string sqlStatement) { string newSql = sqlStatement; ArrayList mappingList = new ArrayList(); Type parameterClassType = null; if (statement != null) { parameterClassType = statement.ParameterClass; } StringTokenizer parser = new StringTokenizer(sqlStatement, PARAMETER_TOKEN, true); StringBuilder newSqlBuffer = new StringBuilder(); string token = null; string lastToken = null; IEnumerator enumerator = parser.GetEnumerator(); while (enumerator.MoveNext()) { token = (string)enumerator.Current; if (PARAMETER_TOKEN.Equals(lastToken)) { if (PARAMETER_TOKEN.Equals(token)) { newSqlBuffer.Append(PARAMETER_TOKEN); token = null; } else { ParameterProperty mapping = null; if (token.IndexOf(PARAM_DELIM) > -1) { mapping = OldParseMapping(token, parameterClassType, scope); } else { mapping = NewParseMapping(token, parameterClassType, scope); } mappingList.Add(mapping); newSqlBuffer.Append("? "); enumerator.MoveNext(); token = (string)enumerator.Current; if (!PARAMETER_TOKEN.Equals(token)) { throw new DataMapperException("Unterminated inline parameter in mapped statement (" + statement.Id + ")."); } token = null; } } else { if (!PARAMETER_TOKEN.Equals(token)) { newSqlBuffer.Append(token); } } lastToken = token; } newSql = newSqlBuffer.ToString(); ParameterProperty[] mappingArray = (ParameterProperty[])mappingList.ToArray(typeof(ParameterProperty)); SqlText sqlText = new SqlText(); sqlText.Text = newSql; sqlText.Parameters = mappingArray; return(sqlText); }
/// <summary> /// Осуществляет откат /// </summary> /// <param name="context"></param> public abstract void Rollback(IScope context);
/// <summary> /// Parse inline parameter with syntax as /// #propertyName,type=string,dbype=Varchar,direction=Input,nullValue=N/A,handler=string# /// </summary> /// <param name="token"></param> /// <param name="parameterClassType"></param> /// <param name="scope"></param> /// <returns></returns> private ParameterProperty NewParseMapping(string token, Type parameterClassType, IScope scope) { ParameterProperty mapping = new ParameterProperty(); StringTokenizer paramParser = new StringTokenizer(token, "=,", false); IEnumerator enumeratorParam = paramParser.GetEnumerator(); enumeratorParam.MoveNext(); mapping.PropertyName = ((string)enumeratorParam.Current).Trim(); while (enumeratorParam.MoveNext()) { string field = (string)enumeratorParam.Current; if (enumeratorParam.MoveNext()) { string value = (string)enumeratorParam.Current; if ("type".Equals(field)) { mapping.CLRType = value; } else if ("dbType".Equals(field)) { mapping.DbType = value; } else if ("direction".Equals(field)) { mapping.DirectionAttribute = value; } else if ("nullValue".Equals(field)) { mapping.NullValue = value; } else if ("handler".Equals(field)) { mapping.CallBackName = value; } else { throw new DataMapperException("Unrecognized parameter mapping field: '" + field + "' in " + token); } } else { throw new DataMapperException("Incorrect inline parameter map format (missmatched name=value pairs): " + token); } } if (mapping.CallBackName.Length > 0) { mapping.Initialize(scope, parameterClassType); } else { ITypeHandler handler = null; if (parameterClassType == null) { handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler(); } else { handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, mapping.PropertyName, mapping.CLRType, mapping.DbType); } mapping.TypeHandler = handler; mapping.Initialize(scope, parameterClassType); } return(mapping); }
/// <summary> /// Производит выполнение операции обновления (может генерировать ошибки) /// </summary> public abstract void Execute(IScope context);
public CustomScopeManager(IScope scope) { _scope = scope; }
/// <summary> /// Parse inline parameter with syntax as /// #propertyName:dbType:nullValue# /// </summary> /// <param name="token"></param> /// <param name="parameterClassType"></param> /// <param name="scope"></param> /// <returns></returns> private ParameterProperty OldParseMapping(string token, Type parameterClassType, IScope scope) { ParameterProperty mapping = new ParameterProperty(); if (token.IndexOf(PARAM_DELIM) > -1) { StringTokenizer paramParser = new StringTokenizer(token, PARAM_DELIM, true); IEnumerator enumeratorParam = paramParser.GetEnumerator(); int n1 = paramParser.TokenNumber; if (n1 == 3) { enumeratorParam.MoveNext(); string propertyName = ((string)enumeratorParam.Current).Trim(); mapping.PropertyName = propertyName; enumeratorParam.MoveNext(); enumeratorParam.MoveNext(); //ignore ":" string dBType = ((string)enumeratorParam.Current).Trim(); mapping.DbType = dBType; ITypeHandler handler = null; if (parameterClassType == null) { handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler(); } else { handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, propertyName, null, dBType); } mapping.TypeHandler = handler; mapping.Initialize(scope, parameterClassType); } else if (n1 >= 5) { enumeratorParam.MoveNext(); string propertyName = ((string)enumeratorParam.Current).Trim(); enumeratorParam.MoveNext(); enumeratorParam.MoveNext(); //ignore ":" string dBType = ((string)enumeratorParam.Current).Trim(); enumeratorParam.MoveNext(); enumeratorParam.MoveNext(); //ignore ":" string nullValue = ((string)enumeratorParam.Current).Trim(); while (enumeratorParam.MoveNext()) { nullValue = nullValue + ((string)enumeratorParam.Current).Trim(); } mapping.PropertyName = propertyName; mapping.DbType = dBType; mapping.NullValue = nullValue; ITypeHandler handler = null; if (parameterClassType == null) { handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler(); } else { handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, propertyName, null, dBType); } mapping.TypeHandler = handler; mapping.Initialize(scope, parameterClassType); } else { throw new ConfigurationException("Incorrect inline parameter map format: " + token); } } else { mapping.PropertyName = token; ITypeHandler handler = null; if (parameterClassType == null) { handler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler(); } else { handler = ResolveTypeHandler(scope.DataExchangeFactory.TypeHandlerFactory, parameterClassType, token, null, null); } mapping.TypeHandler = handler; mapping.Initialize(scope, parameterClassType); } return(mapping); }
public DirectoryScope(string name, IScope enclosingScope) : base(enclosingScope) { Name = name; }
public override void HandleAfter(IExecutionContext executionContext, IScope scope) { factory .GetInstace(executionContext.RequestContext.RequestName) .HandleOperationAfter(executionContext, scope); }