public ClassificationParseResult(ITextSnapshot snapshot, Token tokens, Comment[] comments, Directive[] directives)
 {
     Snapshot = snapshot;
       Tokens = tokens;
       Comments = comments;
       Directives = directives;
 }
 public static StrategyDecision New(
     Directive processDirective,
     MessageDirective messageDirective,
     IEnumerable<ProcessId> affects,
     Time pause
 ) =>
     new StrategyDecision(processDirective, messageDirective, affects, pause);
Example #3
0
        public void Add(Directive d)
        {
            if(IsDirectiveSet(d.name))
                throw new DirectiveAlreadySetException (d.name);

            directives.Add (d);
        }
Example #4
0
        public static void RenderDirective(StringBuilder sb, Directive dir)
        {
            switch (dir.Type)
            {
                case DirectiveType.Charset: RenderDirectiveToCharSetString(sb, dir); return;
                case DirectiveType.Page: RenderDirectiveToPageString(sb, dir); return;
                case DirectiveType.Media: RenderDirectiveToMediaString(sb, dir); return;
                case DirectiveType.Import: RenderDirectiveToImportString(sb, dir); return;
                case DirectiveType.FontFace: RenderDirectiveToFontFaceString(sb, dir); return;
            }

            sb.AppendFormat("{0} ", dir.Name);

            if (dir.Expression != null) {
                sb.AppendFormat("{0} ", dir.Expression);
            }

            bool first = true;
            foreach (Medium m in dir.Mediums)
            {
                if (first)
                {
                    first = false;
                    sb.Append(" ");
                }
                else
                {
                    sb.Append(", ");
                }

                RenderMedium(sb, m);
            }

            bool HasBlock = (dir.Declarations.Count > 0 || dir.Directives.Count > 0 || dir.RuleSets.Count > 0);

            if (!HasBlock)
            {
                sb.Append(";");
                return;
            }

            foreach (Directive dr in dir.Directives)
                RenderDirectiveToCharSetString(sb, dr);

            foreach (RuleSet rules in dir.RuleSets)
                RenderRuleSet(sb, rules);

            first = true;
            foreach (Declaration dec in dir.Declarations)
            {
                if (first) { first = false; } else { sb.Append(";"); }
                RenderDeclaration(sb, dec);
            }

            sb.Append("}");
        }
 public Failure(Directive directive, bool stop, int depth, int failPre, int failPost, int failConstr, int stopKids)
     : base("failure")
 {
     Directive = directive;
     Stop = stop;
     Depth = depth;
     FailPre = failPre;
     FailPost = failPost;
     FailConstr = failConstr;
     StopKids = stopKids;
 }
Example #6
0
 public static bool CanBeEmptyDirective(Directive current_directive)
 {
     return
         current_directive == Directive.Comment ||
         current_directive == Directive.SkipIf ||
         current_directive == Directive.ExpectPhp ||
         current_directive == Directive.ExpectCtError ||
         current_directive == Directive.ExpectCtWarning ||
         current_directive == Directive.Pure ||
         current_directive == Directive.Clr;
 }
 public StrategyDecision(
     Directive processDirective,
     MessageDirective messageDirective,
     IEnumerable<ProcessId> affects,
     Time pause
 )
 {
     ProcessDirective = processDirective;
     MessageDirective = messageDirective;
     Affects = affects;
     Pause = pause;
 }
Example #8
0
        public Z3BaseParams(Directive directive)
        {
            _directive = directive;

            var z3Directive = directive as Z3BaseDirective;
            if (z3Directive != null)
            {
                _optKind = z3Directive.OptKind;
                _cardAlgorithm = z3Directive.CardinalityAlgorithm;
                _pboAlgorithm = z3Directive.PseudoBooleanAlgorithm;
                _arithStrategy = z3Directive.ArithmeticStrategy;
                _smt2LogFile = z3Directive.SMT2LogFile;
            }
        }
Example #9
0
		public override Object Init(IInternalContextAdapter context, Object data)
		{
			base.Init(context, data);

			if (directive == null && rsvc.IsVelocimacro(directiveName, context.CurrentTemplateName))
			{
				directive = rsvc.GetVelocimacro(directiveName, context.CurrentTemplateName);
			}

			if (directive != null)
			{
				directive.Init(rsvc, context, this);
				directive.SetLocation(Line, Column);
			}

			return data;
		}
Example #10
0
        private void TestService1(Directive directive)
        {
            SolverContext context = SolverContext.GetContext();
            Model model = context.CreateModel();

            Decision x1 = new Decision(Domain.RealRange(0, 2), "x1");
            Decision x2 = new Decision(Domain.RealRange(0, 2), "x2");

            Decision z = new Decision(Domain.IntegerRange(0, 1), "z");

            model.AddDecisions(x1, x2, z);

            model.AddConstraint("Row0", x1 - z <= 1);
            model.AddConstraint("Row1", x2 + z <= 2);

            Goal goal = model.AddGoal("Goal0", GoalKind.Maximize, x1 + x2);

            Solution solution = context.Solve(directive);
            Assert.IsTrue(goal.ToInt32() == 3);
            context.ClearModel();
        }
Example #11
0
 public Z3TermParams(Directive directive) : base(directive)
 {
 }
Example #12
0
 /// <inheritdoc />
 public virtual void VisitDirective(Directive directive, ISchema schema)
 {
 }
Example #13
0
 /// <summary>
 /// Apply the specified prprocessor directive, and modify the
 /// current line index accordingly
 /// </summary>
 /// <param name="directive">Preprocessor directive</param>
 /// <param name="ifdefStack">Stack the holds #if/#ifdef information</param>
 /// <param name="processOps"></param>
 private void ApplyDirective(Directive directive, Stack <bool?> ifdefStack, ref bool processOps)
 {
     if (directive.Mnemonic == "#DEFINE" && processOps)
     {
         // --- Define a symbol
         ConditionSymbols.Add(directive.Identifier);
     }
     else if (directive.Mnemonic == "#UNDEF" && processOps)
     {
         // --- Remove a symbol
         ConditionSymbols.Remove(directive.Identifier);
     }
     else if (directive.Mnemonic == "#IFDEF" || directive.Mnemonic == "#IFNDEF" ||
              directive.Mnemonic == "#IFMOD" || directive.Mnemonic == "#IFNMOD" ||
              directive.Mnemonic == "#IF")
     {
         // --- Evaluate the condition and stop/start processing
         // --- operations accordingly
         if (processOps)
         {
             if (directive.Mnemonic == "#IF")
             {
                 var value = EvalImmediate(directive, directive.Expr);
                 processOps = value != null && value.Value != 0;
             }
             else if (directive.Mnemonic == "#IFMOD" || directive.Mnemonic == "#IFNMOD")
             {
                 // --- Check for invalid identifiers
                 if (!ValidModels.Contains(directive.Identifier))
                 {
                     ReportError(Errors.Z0090, directive);
                     processOps = false;
                 }
                 else
                 {
                     // --- OK, check the condition
                     var refModel = _output.ModelType ?? _options.CurrentModel;
                     processOps = refModel.ToString().ToUpper() == directive.Identifier ^
                                  directive.Mnemonic == "#IFNMOD";
                 }
             }
             else
             {
                 processOps = ConditionSymbols.Contains(directive.Identifier) ^
                              directive.Mnemonic == "#IFNDEF";
             }
             ifdefStack.Push(processOps);
         }
         else
         {
             // --- Do not process after #else or #endif
             ifdefStack.Push(null);
         }
     }
     else if (directive.Mnemonic == "#ELSE")
     {
         if (ifdefStack.Count == 0)
         {
             ReportError(Errors.Z0060, directive);
         }
         else
         {
             // --- Process operations according to the last
             // --- condition's value
             var peekVal = ifdefStack.Pop();
             if (peekVal.HasValue)
             {
                 processOps = !peekVal.Value;
                 ifdefStack.Push(processOps);
             }
             else
             {
                 ifdefStack.Push(null);
             }
         }
     }
     else if (directive.Mnemonic == "#ENDIF")
     {
         if (ifdefStack.Count == 0)
         {
             ReportError(Errors.Z0061, directive);
         }
         else
         {
             // --- It is the end of an #ifden/#ifndef block
             ifdefStack.Pop();
             // ReSharper disable once PossibleInvalidOperationException
             processOps = ifdefStack.Count == 0 || ifdefStack.Peek().HasValue&& ifdefStack.Peek().Value;
         }
     }
 }
 /// <summary>
 ///     Logs the failure.
 /// </summary>
 /// <param name="context">The actor cell.</param>
 /// <param name="child">The child.</param>
 /// <param name="cause">The cause.</param>
 /// <param name="directive">The directive.</param>
 protected virtual void LogFailure(IActorContext context, ActorRef child, Exception cause, Directive directive)
 {
     if(LoggingEnabled)
     {
         var actorInitializationException = cause as ActorInitializationException;
         string message;
         if(actorInitializationException != null && actorInitializationException.InnerException != null)
             message = actorInitializationException.InnerException.Message;
         else
             message = cause.Message;
         switch (directive)
         {
             case Directive.Resume:
                 Publish(context, new Warning(child.Path.ToString(), GetType(), message));
                 break;
             case Directive.Escalate:
                 //Don't log here
                 break;
             default:
                 //case Directive.Restart:
                 //case Directive.Stop:
                 Publish(context, new Error(cause, child.Path.ToString(), GetType(), message));
                 break;
         }
     }
 }
Example #15
0
 /// <summary>
 ///     Logs the failure.
 /// </summary>
 /// <param name="actorCell">The actor cell.</param>
 /// <param name="child">The child.</param>
 /// <param name="cause">The cause.</param>
 /// <param name="directive">The directive.</param>
 protected virtual void LogFailure(ActorCell actorCell, ActorRef child, Exception cause, Directive directive)
 {
     switch (directive)
     {
         case Directive.Resume:
             actorCell.System.EventStream.Publish(new Warning(child.Path.ToString(), GetType(), cause.Message));
             break;
         case Directive.Escalate:
             break;
         default:
             //case Directive.Restart:
             //case Directive.Stop:
             actorCell.System.EventStream.Publish(new Error(cause, child.Path.ToString(), GetType(),
                 cause.Message));
             break;
     }
 }
 protected override string GetValue(Directive directive)
 {
     return((directive as ChordSizeDirective)?.FontSize.ToString());
 }
Example #17
0
        private IActionResult HandleDiscovery(Directive directive)
        {
            List <Endpoint> endpoints          = new List <Endpoint>();
            var             thermostatEndpoint = new Endpoint
            {
                EndpointId        = "DefaultThermostat",
                FriendlyName      = "Thermostat",
                Description       = "A custom thermostat",
                ManufacturerName  = "Thermostat.Net",
                DisplayCategories = new List <string> {
                    DisplayCategories.Thermostat
                },
                Cookie       = new object(),
                Capabilities = new List <Capability>
                {
                    new Capability
                    {
                        Type       = "AlexaInterface",
                        Interface  = Interfaces.ThermostatController,
                        Properties = new Properties
                        {
                            Supported = new List <NameValue>
                            {
                                new NameValue {
                                    Name = "targetSetpoint"
                                },
                                new NameValue {
                                    Name = "thermostatMode"
                                }
                            },
                            ProactivelyReported = false,
                            Retrievable         = true
                        }
                    }
                }
            };

            endpoints.Add(thermostatEndpoint);

            //add available modes
            endpoints.AddRange(Status.Instance.Rules.Select(x => new Endpoint
            {
                EndpointId        = x.ClassName + "ThermostaMode",
                FriendlyName      = x.FriendlyName + " Thermostat Mode",
                Description       = "A custom operation mode for the thermostat",
                ManufacturerName  = "Thermostat.Net",
                DisplayCategories = new List <string> {
                    DisplayCategories.ActivityTrigger
                },
                Cookie       = new object(),
                Capabilities = new List <Capability>
                {
                    new Capability
                    {
                        Type       = "AlexaInterface",
                        Interface  = Interfaces.SceneController,
                        Properties = new Properties
                        {
                            Supported = new List <NameValue>
                            {
                                new NameValue {
                                    Name = "targetSetpoint"
                                },
                                new NameValue {
                                    Name = "thermostatMode"
                                }
                            },
                            ProactivelyReported  = false,
                            SupportsDeactivation = false
                        }
                    }
                }
            }));

            var response = new Response
            {
                Event = new Event
                {
                    Header = new Header
                    {
                        Namespace = Namespaces.Discovery,
                        Name      = Names.DiscoveryResponse, //TODO: this is inconsistent with documentation, should be just "Response"? There seems to be a inconsistence in the documentation as both versions can be seen
                        MessageId = Guid.NewGuid().ToString()
                    },
                    Payload = new Payload
                    {
                        Endpoints = endpoints
                    }
                }
            };

            return(Ok(response));
        }
Example #18
0
 public void SetScoreAtDirective(Directive directive)
 {
     //CurrentScore += directive.ScoreValue;
 }
Example #19
0
        protected override void AnimatedThreadWorkerDoWork(object sender, DoWorkEventArgs e)
        {
            GlobalObjects.ComponentCore.ReloadActualStateRecordForBaseComponents(_currentDirective.ParentAircraftId);

            #region Загрузка элементов

            AnimatedThreadWorker.ReportProgress(0, "load directives");

            try
            {
                if (_currentDirective.ItemId > 0)
                {
                    _currentDirective = GlobalObjects.DirectiveCore.GetDirectiveById(_currentDirective.ItemId, _currentDirective.DirectiveType);
                }
            }
            catch (Exception ex)
            {
                Program.Provider.Logger.Log("Error while loading directives", ex);
            }

            if (AnimatedThreadWorker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
            #endregion

            #region Калькуляция состояния директив

            AnimatedThreadWorker.ReportProgress(40, "calculation of directives");


            GlobalObjects.MTOPCalculator.CalculateDirectiveNew(_currentDirective);

            if (AnimatedThreadWorker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
            #endregion

            #region Фильтрация директив
            AnimatedThreadWorker.ReportProgress(70, "filter directives");

            if (AnimatedThreadWorker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
            #endregion

            #region Сравнение с рабочими пакетами

            AnimatedThreadWorker.ReportProgress(90, "comparison with the Work Packages");

            if (AnimatedThreadWorker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
            #endregion

            AnimatedThreadWorker.ReportProgress(100, "Complete");
        }
Example #20
0
 public MosekMipSolverParams(Directive directive) : base(directive)
 {
 }
 protected override string GetValue(Directive directive)
 {
     return((directive as SubtitleDirective)?.Text);
 }
Example #22
0
 public static void RenderDirectiveToImportString(StringBuilder sb, Directive dir)
 {
     sb.Append("@import ");
     if (dir.Expression != null) { sb.AppendFormat("{0} ", dir.Expression); }
     bool first = true;
     foreach (Medium m in dir.Mediums)
     {
         if (first)
         {
             first = false;
             sb.Append(" ");
         }
         else
         {
             sb.Append(", ");
         }
         RenderMedium(sb, m);
     }
     sb.Append(";");
 }
Example #23
0
        /// <summary>
        /// Возвращает имя цвета директивы в отчете
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        //TODO:(Evgenii Babak) пересмотреть подход с формированием conditionState
        private static Highlight GetHighlight(object item)
        {
            Highlight      conditionState = Highlight.White;
            ConditionState cond;

            if (item is Directive)
            {
                Directive directive = (Directive)item;
                if (directive.NextPerformanceIsBlocked)
                {
                    conditionState = Highlight.DarkGreen;
                }
                else
                {
                    cond = directive.Condition;
                    if (cond == ConditionState.NotEstimated)
                    {
                        conditionState = Highlight.Blue;
                        if (directive.Status != DirectiveStatus.Closed && directive.IsApplicability && directive.Threshold.FirstPerformanceSinceNew.IsNullOrZero() && directive.Threshold.RepeatInterval.IsNullOrZero())
                        {
                            conditionState = Highlight.Orange;
                        }
                    }
                    if (cond == ConditionState.Notify)
                    {
                        conditionState = Highlight.Yellow;
                    }
                    if (cond == ConditionState.Overdue)
                    {
                        conditionState = Highlight.Red;
                    }
                }
            }
            else if (item is AircraftFlight)
            {
                if (!((AircraftFlight)item).Correct)
                {
                    conditionState = Highlight.Blue;
                }
            }
            else if (item is BaseComponent)
            {
                conditionState = Highlight.White;
            }
            else if (item is Component)
            {
                Component component = (Component)item;
                if (component.NextPerformanceIsBlocked)
                {
                    conditionState = Highlight.DarkGreen;
                }
                else
                {
                    cond = component.Condition;
                    if (cond == ConditionState.NotEstimated)
                    {
                        conditionState = Highlight.Blue;
                    }
                    if (cond == ConditionState.Notify)
                    {
                        conditionState = Highlight.Yellow;
                    }
                    if (cond == ConditionState.Overdue)
                    {
                        conditionState = Highlight.Red;
                    }
                }
            }
            else if (item is ComponentDirective)
            {
                ComponentDirective detDir = (ComponentDirective)item;
                if (detDir.NextPerformanceIsBlocked)
                {
                    conditionState = Highlight.DarkGreen;
                }
                else
                {
                    cond = detDir.Condition;
                    if (cond == ConditionState.NotEstimated)
                    {
                        conditionState = Highlight.Blue;
                    }
                    if (cond == ConditionState.Notify)
                    {
                        conditionState = Highlight.Yellow;
                    }
                    if (cond == ConditionState.Overdue)
                    {
                        conditionState = Highlight.Red;
                    }
                }
            }
            else if (item is MaintenanceDirective)
            {
                MaintenanceDirective mpd = (MaintenanceDirective)item;
                if (mpd.NextPerformanceIsBlocked)
                {
                    conditionState = Highlight.DarkGreen;
                }
                else
                {
                    cond = mpd.Condition;
                    if (cond == ConditionState.NotEstimated)
                    {
                        conditionState = Highlight.Blue;
                        if (mpd.Status != DirectiveStatus.Closed && mpd.IsApplicability && mpd.IsApplicability && mpd.Threshold.FirstPerformanceSinceNew.IsNullOrZero() && mpd.Threshold.RepeatInterval.IsNullOrZero())
                        {
                            conditionState = Highlight.Orange;
                        }
                    }
                    if (cond == ConditionState.Notify)
                    {
                        conditionState = Highlight.Yellow;
                    }
                    if (cond == ConditionState.Overdue)
                    {
                        conditionState = Highlight.Red;
                    }
                    if (mpd.IsExtension)
                    {
                        conditionState = Highlight.LightBlue;
                    }
                }
            }
            else if (item is NextPerformance performance)
            {
                conditionState = Highlight.White;
                cond           = performance.Condition;
                if (cond == ConditionState.Notify)
                {
                    conditionState = Highlight.Yellow;
                }
                if (cond == ConditionState.Overdue)
                {
                    conditionState = Highlight.Red;
                }
                if (performance.BlockedByPackage != null)
                {
                    conditionState = Highlight.DarkGreen;
                }
                if (performance.Parent is IMtopCalc)
                {
                    if ((performance.Parent as IMtopCalc).IsExtension)
                    {
                        conditionState = Highlight.LightBlue;
                    }
                }
            }
            else if (item is Document)
            {
                var document = (Document)item;
                if (document.NextPerformanceIsBlocked)
                {
                    conditionState = Highlight.DarkGreen;
                }
                else
                {
                    cond = document.Condition;
                    if (cond == ConditionState.NotEstimated)
                    {
                        conditionState = Highlight.Blue;
                    }
                    if (cond == ConditionState.Notify)
                    {
                        conditionState = Highlight.Yellow;
                    }
                    if (cond == ConditionState.Overdue)
                    {
                        conditionState = Highlight.Red;
                    }
                }
            }
            else if (item is CheckLists)
            {
                var checkLists = (CheckLists)item;
                cond = checkLists.Condition;
                //if (cond == ConditionState.NotEstimated)
                //    conditionState = Highlight.Blue;
                //if (cond == ConditionState.Satisfactory)
                //    conditionState = Highlight.Green;
                if (cond == ConditionState.Notify)
                {
                    conditionState = Highlight.Yellow;
                }
                if (cond == ConditionState.Overdue)
                {
                    conditionState = Highlight.Red;
                }

                // if (checkLists.IsEditable)
                //     conditionState = Highlight.Green;
                // else conditionState = Highlight.Red;
            }
            else if (item is CAAEducationManagment)
            {
                var manual = (CAAEducationManagment)item;

                if (manual.Record == null)
                {
                    return(conditionState);
                }

                if (manual.Record?.Settings?.NextCompliance == null)
                {
                    return(conditionState);
                }

                cond = manual.Record.Settings.NextCompliance.Condition;
                //if (cond == ConditionState.NotEstimated)
                //    conditionState = Highlight.Blue;
                if (manual.Record.Settings.BlockedWpId.HasValue)
                {
                    conditionState = Highlight.GrayLight;
                }
                if (cond == ConditionState.Notify)
                {
                    conditionState = Highlight.Yellow;
                }
                if (cond == ConditionState.Overdue)
                {
                    conditionState = Highlight.Red;
                }
            }
            else if (item is StandartManual)
            {
                var manual = (StandartManual)item;
                cond = manual.Condition;
                //if (cond == ConditionState.NotEstimated)
                //    conditionState = Highlight.Blue;
                //if (cond == ConditionState.Satisfactory)
                //    conditionState = Highlight.Green;
                if (cond == ConditionState.Notify)
                {
                    conditionState = Highlight.Yellow;
                }
                if (cond == ConditionState.Overdue)
                {
                    conditionState = Highlight.Red;
                }
            }
            else if (item is SmartCore.CAA.ConcessionRequest)
            {
                var res = (ConcessionRequest)item;
                if (res.Status == ConcessionRequestStatus.Close)
                {
                    conditionState = Highlight.Blue;
                }
            }
            return(conditionState);
        }
Example #24
0
 protected override void EnterDirective(PrinterContext context, Directive directive)
 {
     context.Append($"@{directive.Name.Value}");
 }
Example #25
0
 public override Result PatternWeightExecute(Directive directive, Valve valve)
 {
     return(Result.OK);
 }
 public DirectiveAssignment(Directive directive, string value)
 {
     this.directive = directive;
     this.value = value;
 }
Example #27
0
        /// <summary>
        /// Parses the specified template text.
        /// </summary>
        /// <param name="templateText">The template text.</param>
        private void Parse(string templateText)
        {
            //var filePath = Path.GetFullPath(Path.Combine(templateCodePath, TemplateFileName));
            var tokeniser = new Tokeniser(TemplateFileName, templateText);

            AddCode(tokeniser.Location, "");

            bool skip = false;
            while ((skip || tokeniser.Advance()) && tokeniser.State != State.EOF)
            {
                skip = false;
                switch (tokeniser.State)
                {
                    case State.Block:
                        if (!String.IsNullOrEmpty(tokeniser.Value))
                            AddDoTemplateCode(tokeniser.Location, tokeniser.Value);
                        break;
                    case State.Content:
                        if (!String.IsNullOrEmpty(tokeniser.Value))
                            AddContent(tokeniser.Location, tokeniser.Value);
                        break;
                    case State.Expression:
                        if (!String.IsNullOrEmpty(tokeniser.Value))
                            AddExpression(tokeniser.Location, tokeniser.Value);
                        break;
                    case State.Helper:
                        _isTemplateClassCode = true;
                        if (!String.IsNullOrEmpty(tokeniser.Value))
                            AddDoTemplateClassCode(tokeniser.Location, tokeniser.Value);
                        break;
                    case State.Directive:
                        Directive directive = null;
                        string attName = null;
                        while (!skip && tokeniser.Advance())
                        {
                            switch (tokeniser.State)
                            {
                                case State.DirectiveName:
                                    if (directive == null)
                                        directive = new Directive {Name = tokeniser.Value.ToLower()};
                                    else
                                        attName = tokeniser.Value;
                                    break;
                                case State.DirectiveValue:
                                    if (attName != null && directive != null)
                                        directive.Attributes.Add(attName.ToLower(), tokeniser.Value);
                                    attName = null;
                                    break;
                                case State.Directive:
                                    //if (directive != null)
                                    //    directive.EndLocation = tokeniser.TagEndLocation;
                                    break;
                                default:
                                    skip = true;
                                    break;
                            }
                        }
                        if (directive != null)
                        {
                            if (directive.Name == "include")
                            {
                                string includeFile = directive.Attributes["file"];
                                if (OnInclude == null)
                                    throw new InvalidOperationException("Include file found. OnInclude event must be implemented");
                                var includeArgs = new TemplateIncludeArgs() {IncludeName = includeFile};
                                OnInclude(this, includeArgs);
                                Parse(includeArgs.Text ?? "");
                            }
                            _directives.Add(directive);
                        }
                        break;
                    default:
                        throw new InvalidOperationException();
                }
            }
        }
 public static KeyValuePair <Type, Directive> When <TException>(this Directive self) where TException : Exception
 {
     return(new KeyValuePair <Type, Directive>(typeof(TException), self));
 }
Example #29
0
 public Z3TermParams(Directive directive) : base(directive) { }
 public static DeployableDecider From(Directive defaultDirective, params KeyValuePair <Type, Directive>[] pairs)
 {
     return(new DeployableDecider(defaultDirective, pairs));
 }
Example #31
0
		public CustomDirective (string processorName, Directive directive)
		{
			this.ProcessorName = processorName;
			this.Directive = directive;
		}
 public static DeployableDecider From(Directive defaultDirective, IEnumerable <KeyValuePair <Type, Directive> > pairs)
 {
     return(new DeployableDecider(defaultDirective, pairs));
 }
Example #33
0
        public static void RenderDirectiveToMediaString(StringBuilder sb, Directive dir)
        {
            sb.Append("@media");

            bool first = true;
            foreach (Medium m in dir.Mediums)
            {
                if (first)
                {
                    first = false;
                    sb.Append(" ");
                }
                else
                {
                    sb.Append(", ");
                }
                RenderMedium(sb, m);
            }
            sb.Append("{");

            foreach (RuleSet rules in dir.RuleSets)
            {
                RenderRuleSet(sb, rules);
            }

            sb.Append("}");
        }
 public DeployableDecider(Directive defaultDirective, IEnumerable <KeyValuePair <Type, Directive> > pairs) : this(defaultDirective, pairs.ToArray())
 {
 }
Example #35
0
        /// <summary>
        ///     Logs the failure.
        /// </summary>
        /// <param name="context">The actor cell.</param>
        /// <param name="child">The child.</param>
        /// <param name="cause">The cause.</param>
        /// <param name="directive">The directive.</param>
        protected virtual void LogFailure(IActorContext context, ActorRef child, Exception cause, Directive directive)
        {
            if (LoggingEnabled)
            {
                var    actorInitializationException = cause as ActorInitializationException;
                string message;
                if (actorInitializationException != null && actorInitializationException.InnerException != null)
                {
                    message = actorInitializationException.InnerException.Message;
                }
                else
                {
                    message = cause.Message;
                }
                switch (directive)
                {
                case Directive.Resume:
                    Publish(context, new Warning(child.Path.ToString(), GetType(), message));
                    break;

                case Directive.Escalate:
                    //Don't log here
                    break;

                default:
                    //case Directive.Restart:
                    //case Directive.Stop:
                    Publish(context, new Error(cause, child.Path.ToString(), GetType(), message));
                    break;
                }
            }
        }
 public DeployableDecider(Directive defaultDirective, params KeyValuePair <Type, Directive>[] pairs)
 {
     DefaultDirective = defaultDirective;
     Pairs            = pairs;
 }
Example #37
0
 /// <inheritdoc />
 public virtual void VisitDirectiveArgumentDefinition(QueryArgument argument, Directive directive, ISchema schema)
 {
 }
 protected override bool TryCreate(DirectiveComponents components, out Directive directive)
 {
     directive = new GridDirective();
     return(true);
 }
Example #39
0
        //protected override void SetItemColor(ListViewItem listViewItem, BaseEntityObject item)
        //{
        //    if (item is NextPerformance)
        //    {
        //        NextPerformance nextPerformance = item as NextPerformance;
        //        if(_currentDirective.Status != WorkPackageStatus.Closed)
        //        {
        //            if (nextPerformance.BlockedByPackage != null)
        //            {
        //                listViewItem.ToolTipText = "This performance blocked by work package:" +
        //                   nextPerformance.BlockedByPackage.Title;
        //                listViewItem.BackColor = Color.FromArgb(Highlight.Grey.Color);
        //            }
        //            else if (nextPerformance.Condition == ConditionState.Notify)
        //                listViewItem.BackColor = Color.FromArgb(Highlight.Yellow.Color);
        //            else if (nextPerformance.Condition == ConditionState.Overdue)
        //                listViewItem.BackColor = Color.FromArgb(Highlight.Red.Color);
        //        }
        //        else
        //        {
        //            //Если это следующее выполнение, но рабочий пакет при этом закрыт
        //            //значит, выполнение для данной задачи в рамках данного рабочего пакета
        //            //не было введено

        //            //пометка этого выполнения краным цветом
        //            listViewItem.BackColor = Color.FromArgb(Highlight.Red.Color);
        //            //подсказка о том, что выполнение не было введено
        //            listViewItem.ToolTipText = "Performance for this directive within this work package is not entered.";
        //            if (nextPerformance.BlockedByPackage != null)
        //            {
        //                //дополнитльная подсказака, если предшествующее выполнение
        //                //имеется в другом открытом рабочем пакете
        //                listViewItem.ToolTipText += "\nThis performance blocked by work package:" +
        //                   nextPerformance.BlockedByPackage.Title +
        //                   "\nFirst, enter the performance of this directive as part of this work package ";
        //            }
        //        }

        //        if (nextPerformance.Parent.IsDeleted)
        //        {
        //            //запись так же может быть удаленной

        //            //шрифт серым цветом
        //            listViewItem.ForeColor = Color.Gray;
        //            if (listViewItem.ToolTipText.Trim() != "")
        //                listViewItem.ToolTipText += "\n";
        //            listViewItem.ToolTipText += string.Format("This {0} is deleted",nextPerformance.Parent.SmartCoreObjectType);
        //        }
        //    }
        //    else if (item is AbstractPerformanceRecord)
        //    {
        //        AbstractPerformanceRecord apr = (AbstractPerformanceRecord) item;
        //        if (apr.Parent.IsDeleted)
        //        {
        //            //запись так же может быть удаленной

        //            //шрифт серым цветом
        //            listViewItem.ForeColor = Color.Gray;
        //            if (listViewItem.ToolTipText.Trim() != "")
        //                listViewItem.ToolTipText += "\n";
        //            listViewItem.ToolTipText += string.Format("This {0} is deleted", apr.Parent.SmartCoreObjectType);
        //        }
        //    }
        //    else
        //    {
        //        if(!(item is NonRoutineJob))
        //        {
        //            //Если это не следующее выполнение, не запись о выполнении, и не рутинная работа
        //            //значит, выполнение для данной задачи расчитать нельзя

        //            //пометка этого выполнения синим цветом
        //            listViewItem.BackColor = Color.FromArgb(Highlight.Blue.Color);
        //            //подсказка о том, что выполнение не возможео расчитать
        //            listViewItem.ToolTipText = "Performance for this directive can not be calculated";
        //        }

        //        if (item.IsDeleted)
        //        {
        //            //запись так же может быть удаленной

        //            //шрифт серым цветом
        //            listViewItem.ForeColor = Color.Gray;
        //            if (listViewItem.ToolTipText.Trim() != "")
        //                listViewItem.ToolTipText += "\n";
        //            listViewItem.ToolTipText += string.Format("This {0} is deleted", item.SmartCoreObjectType);
        //        }
        //    }
        //}
        #endregion

        #region protected override ListViewItem.ListViewSubItem[] GetListViewSubItems(BaseSmartCoreObject item)

        protected override List <CustomCell> GetListViewSubItems(BaseEntityObject item)
        {
            var temp     = ListViewGroupHelper.GetGroupString(item);
            var subItems = new List <CustomCell>()
            {
                CreateRow(temp, temp)
            };
            var author = GlobalObjects.CasEnvironment.GetCorrector(item);

            //if(item.ItemId == 41043)
            //{

            //}
            if (item is NextPerformance)
            {
                NextPerformance np = (NextPerformance)item;

                double manHours = np.Parent is IEngineeringDirective ? ((IEngineeringDirective)np.Parent).ManHours : 0;
                double cost     = np.Parent is IEngineeringDirective ? ((IEngineeringDirective)np.Parent).Cost : 0;

                subItems.Add(CreateRow(np.ATAChapter.ToString(), np.ATAChapter));
                subItems.Add(CreateRow(np.Title, np.Title));
                subItems.Add(CreateRow(np.Description, np.Description));
                subItems.Add(CreateRow(np.KitsToString, np.Kits.Count));
                subItems.Add(CreateRow(np.PerformanceSource.ToString(), np.PerformanceSource));
                subItems.Add(CreateRow(np.Parent.Threshold.RepeatInterval.ToString(), np.Parent.Threshold.RepeatInterval));
                subItems.Add(CreateRow(np.Remains.ToString(), np.Remains));
                subItems.Add(CreateRow(np.WorkType, Tag = np.WorkType));
                subItems.Add(CreateRow(np.PerformanceDate == null ? "N/A" : SmartCore.Auxiliary.Convert.GetDateFormat((DateTime)np.PerformanceDate), np.PerformanceDate));
                subItems.Add(CreateRow(manHours.ToString(), manHours));
                subItems.Add(CreateRow(cost.ToString(), cost));
                subItems.Add(CreateRow(author, author));
            }
            else if (item is AbstractPerformanceRecord)
            {
                //DirectiveRecord directiveRecord = (DirectiveRecord)item;
                AbstractPerformanceRecord apr = (AbstractPerformanceRecord)item;
                Lifelength remains            = Lifelength.Null;
                double     manHours           = apr.Parent is IEngineeringDirective ? ((IEngineeringDirective)apr.Parent).ManHours : 0;
                double     cost = apr.Parent is IEngineeringDirective ? ((IEngineeringDirective)apr.Parent).Cost : 0;

                subItems.Add(CreateRow(apr.ATAChapter.ToString(), apr.ATAChapter));
                subItems.Add(CreateRow(apr.Title, apr.Title));
                subItems.Add(CreateRow(apr.Description, apr.Description));
                subItems.Add(CreateRow(apr.KitsToString, apr.Kits.Count));
                subItems.Add(CreateRow(apr.OnLifelength.ToString(), apr.OnLifelength));
                subItems.Add(CreateRow(apr.Parent.Threshold.RepeatInterval.ToString(), apr.Parent.Threshold.RepeatInterval));
                subItems.Add(CreateRow(remains.ToString(), remains));
                subItems.Add(CreateRow(apr.WorkType, apr.WorkType));
                subItems.Add(CreateRow(SmartCore.Auxiliary.Convert.GetDateFormat(apr.RecordDate), apr.RecordDate));
                subItems.Add(CreateRow(manHours.ToString(), manHours));
                subItems.Add(CreateRow(cost.ToString(), cost));
                subItems.Add(CreateRow(author, author));
            }
            else if (item is Directive)
            {
                Directive directive = (Directive)item;

                AtaChapter ata = directive.ATAChapter;
                subItems.Add(CreateRow(ata.ToString(), ata));
                subItems.Add(CreateRow(directive.Title, directive.Title));
                subItems.Add(CreateRow(directive.Description, directive.Description));

                #region Определение текста для колонки "КИТы"
                subItems.Add(CreateRow(directive.Kits.Count > 0 ? directive.Kits.Count + " kits" : "", directive.Kits.Count));
                #endregion

                #region Определение текста для колонки "Первое выполнение"

                var subItem = new CustomCell();
                if (directive.Threshold.FirstPerformanceSinceNew != null && !directive.Threshold.FirstPerformanceSinceNew.IsNullOrZero())
                {
                    subItem.Text = "s/n: " + directive.Threshold.FirstPerformanceSinceNew;
                    subItem.Tag  = directive.Threshold.FirstPerformanceSinceNew;
                }
                if (directive.Threshold.FirstPerformanceSinceEffectiveDate != null &&
                    !directive.Threshold.FirstPerformanceSinceEffectiveDate.IsNullOrZero())
                {
                    if (subItem.Text != "")
                    {
                        subItem.Text += " or ";
                    }
                    else
                    {
                        subItem.Text = "";
                        subItem.Tag  = directive.Threshold.FirstPerformanceSinceEffectiveDate;
                    }
                    subItem.Text += "s/e.d: " + directive.Threshold.FirstPerformanceSinceEffectiveDate;
                }

                subItems.Add(subItem);
                #endregion

                #region Определение текста для колонки "повторяющийся интервал"

                subItem = new CustomCell();
                if (!directive.Threshold.RepeatInterval.IsNullOrZero())
                {
                    subItem.Text = directive.Threshold.RepeatInterval.ToString();
                    subItem.Tag  = directive.Threshold.RepeatInterval;
                }
                else
                {
                    subItem.Text = "";
                    subItem.Tag  = Lifelength.Null;
                }
                subItems.Add(subItem);
                #endregion

                #region Определение текста для колонки "Остаток/Просрочено на сегодня"
                subItems.Add(CreateRow(directive.Remains.ToString(), directive.Remains));
                #endregion

                #region Определение текста для колонки "Тип работ"

                subItems.Add(CreateRow(directive.WorkType.ToString(), directive.WorkType));
                #endregion

                #region Определение текста для колонки "Следующее выполнение"
                subItems.Add(CreateRow(directive.NextPerformanceDate == null ? "N/A" : SmartCore.Auxiliary.Convert.GetDateFormat((DateTime)directive.NextPerformanceDate), directive.NextPerformanceDate));
                #endregion

                #region Определение текста для колонки "Человек/Часы"

                subItems.Add(CreateRow(directive.ManHours.ToString(), directive.ManHours));
                #endregion

                #region Определение текста для колонки "Стоимость"

                subItems.Add(CreateRow(directive.Cost.ToString(), directive.Cost));
                #endregion
                subItems.Add(CreateRow(author, author));
            }
            else if (item is BaseComponent)
            {
                BaseComponent bd  = (BaseComponent)item;
                AtaChapter    ata = bd.ATAChapter;

                subItems.Add(CreateRow(ata.ToString(), ata));
                subItems.Add(CreateRow(bd.PartNumber, bd.PartNumber));
                subItems.Add(CreateRow(bd.Description, bd.Description));
                subItems.Add(CreateRow(bd.Kits.Count > 0 ? bd.Kits.Count + " kits" : "", bd.Kits.Count));
                subItems.Add(CreateRow(bd.LifeLimit.ToString(), bd.LifeLimit));
                subItems.Add(CreateRow("", Lifelength.Null));
                subItems.Add(CreateRow(bd.Remains.ToString(), bd.Remains));
                subItems.Add(CreateRow(ComponentRecordType.Remove.ToString(), ComponentRecordType.Remove));
                subItems.Add(CreateRow(bd.NextPerformanceDate == null ? "N/A" : SmartCore.Auxiliary.Convert.GetDateFormat((DateTime)bd.NextPerformanceDate), bd.NextPerformanceDate));
                subItems.Add(CreateRow(bd.ManHours.ToString(), bd.ManHours));
                subItems.Add(CreateRow(bd.Cost.ToString(), bd.Cost));
                subItems.Add(CreateRow(author, author));
            }
            else if (item is Component)
            {
                Component  d   = (Component)item;
                AtaChapter ata = d.ATAChapter;

                subItems.Add(CreateRow(ata.ToString(), ata));
                subItems.Add(CreateRow(d.PartNumber, d.PartNumber));
                subItems.Add(CreateRow(d.Description, d.Description));
                subItems.Add(CreateRow(d.Kits.Count > 0 ? d.Kits.Count + " kits" : "", d.Kits.Count));
                subItems.Add(CreateRow(d.LifeLimit != null ? d.LifeLimit.ToString() : "", d.LifeLimit));
                subItems.Add(CreateRow("", Lifelength.Null));
                subItems.Add(CreateRow(d.Remains != null ? d.Remains.ToString() : "", d.Remains));
                subItems.Add(CreateRow(ComponentRecordType.Remove.ToString(), ComponentRecordType.Remove));
                subItems.Add(CreateRow(d.NextPerformanceDate == null ? "N/A" : SmartCore.Auxiliary.Convert.GetDateFormat((DateTime)d.NextPerformanceDate), d.NextPerformanceDate));
                subItems.Add(CreateRow(d.ManHours.ToString(), d.ManHours));
                subItems.Add(CreateRow(d.Cost.ToString(), d.Cost));
                subItems.Add(CreateRow(author, Tag = author));
            }
            else if (item is ComponentDirective)
            {
                ComponentDirective dd  = (ComponentDirective)item;
                AtaChapter         ata = dd.ParentComponent.ATAChapter;

                subItems.Add(CreateRow(ata != null ? ata.ToString() : "", ata));
                subItems.Add(CreateRow("", ""));
                subItems.Add(CreateRow(dd.Remarks, dd.Remarks));
                subItems.Add(CreateRow(dd.Kits.Count > 0 ? dd.Kits.Count + " kits" : "", dd.Kits.Count));
                #region Определение текста для колонки "Первое выполнение"

                var subItem = new CustomCell();
                if (dd.Threshold.FirstPerformanceSinceNew != null && !dd.Threshold.FirstPerformanceSinceNew.IsNullOrZero())
                {
                    subItem.Text = "s/n: " + dd.Threshold.FirstPerformanceSinceNew;
                    subItem.Tag  = dd.Threshold.FirstPerformanceSinceNew;
                }
                subItems.Add(subItem);
                #endregion
                #region Определение текста для колонки "повторяющийся интервал"

                subItem = new CustomCell();
                if (!dd.Threshold.RepeatInterval.IsNullOrZero())
                {
                    subItem.Text = dd.Threshold.RepeatInterval.ToString();
                    subItem.Tag  = dd.Threshold.RepeatInterval;
                }
                else
                {
                    subItem.Text = "";
                    subItem.Tag  = Lifelength.Null;
                }
                subItems.Add(subItem);
                #endregion
                subItems.Add(CreateRow(dd.Remains.ToString(), dd.Remains));
                subItems.Add(CreateRow(dd.DirectiveType.ToString(), dd.DirectiveType));
                subItems.Add(CreateRow(dd.NextPerformanceDate == null ? "N/A" : SmartCore.Auxiliary.Convert.GetDateFormat((DateTime)dd.NextPerformanceDate), dd.NextPerformanceDate));
                subItems.Add(CreateRow(dd.ManHours.ToString(), dd.ManHours));
                subItems.Add(CreateRow(dd.Cost.ToString(), dd.Cost));
                subItems.Add(CreateRow(author, author));
            }
            else if (item is MaintenanceCheck)
            {
                MaintenanceCheck mc = (MaintenanceCheck)item;
                subItems.Add(CreateRow("", null));
                subItems.Add(CreateRow("", ""));
                subItems.Add(CreateRow(mc.Name + (mc.Schedule ? " Shedule" : " Unshedule"), mc.Name));
                subItems.Add(CreateRow(mc.Kits.Count > 0 ? mc.Kits.Count + " kits" : "", mc.Kits.Count));
                subItems.Add(CreateRow(mc.Interval.ToString(), mc.Interval));
                subItems.Add(CreateRow("", Lifelength.Null));
                subItems.Add(CreateRow(mc.Remains.ToString(), mc.Remains));
                subItems.Add(CreateRow("", ""));
                subItems.Add(CreateRow(mc.NextPerformanceDate == null ? "N/A" : SmartCore.Auxiliary.Convert.GetDateFormat((DateTime)mc.NextPerformanceDate), mc.NextPerformanceDate));
                subItems.Add(CreateRow(mc.ManHours.ToString(), mc.ManHours));
                subItems.Add(CreateRow(mc.Cost.ToString(), mc.Cost));
                subItems.Add(CreateRow(author, author));
            }
            else if (item is MaintenanceDirective)
            {
                MaintenanceDirective md  = (MaintenanceDirective)item;
                AtaChapter           ata = md.ATAChapter;

                subItems.Add(CreateRow(ata != null ? ata.ToString() : "", ata));
                subItems.Add(CreateRow(md.ToString(), md.ToString()));
                subItems.Add(CreateRow(md.Description, md.Description));
                subItems.Add(CreateRow(md.Kits.Count > 0 ? md.Kits.Count + " kits" : "", md.Kits.Count));
                #region Определение текста для колонки "Первое выполнение"

                var subItem = new CustomCell();
                if (md.Threshold.FirstPerformanceSinceNew != null && !md.Threshold.FirstPerformanceSinceNew.IsNullOrZero())
                {
                    subItem.Text = "s/n: " + md.Threshold.FirstPerformanceSinceNew;
                    subItem.Tag  = md.Threshold.FirstPerformanceSinceNew;
                }
                if (md.Threshold.FirstPerformanceSinceEffectiveDate != null &&
                    !md.Threshold.FirstPerformanceSinceEffectiveDate.IsNullOrZero())
                {
                    if (subItem.Text != "")
                    {
                        subItem.Text += " or ";
                    }
                    else
                    {
                        subItem.Text = "";
                        subItem.Tag  = md.Threshold.FirstPerformanceSinceEffectiveDate;
                    }
                    subItem.Text += "s/e.d: " + md.Threshold.FirstPerformanceSinceEffectiveDate;
                }

                subItems.Add(subItem);
                #endregion
                #region Определение текста для колонки "повторяющийся интервал"

                subItem = new CustomCell();
                if (!md.Threshold.RepeatInterval.IsNullOrZero())
                {
                    subItem.Text = md.Threshold.RepeatInterval.ToString();
                    subItem.Tag  = md.Threshold.RepeatInterval;
                }
                else
                {
                    subItem.Text = "";
                    subItem.Tag  = Lifelength.Null;
                }
                subItems.Add(subItem);
                #endregion
                subItems.Add(CreateRow(md.Remains.ToString(), md.Remains));
                subItems.Add(CreateRow(md.WorkType.ToString(), md.WorkType));
                subItems.Add(CreateRow(md.NextPerformanceDate == null ? "N/A" : SmartCore.Auxiliary.Convert.GetDateFormat((DateTime)md.NextPerformanceDate), md.NextPerformanceDate));
                subItems.Add(CreateRow(md.ManHours.ToString(), md.ManHours));
                subItems.Add(CreateRow(md.Cost.ToString(), md.Cost));
                subItems.Add(CreateRow(author, author));
            }
            else if (item is Procedure)
            {
                Procedure md = (Procedure)item;

                subItems.Add(CreateRow("", ""));
                subItems.Add(CreateRow(md.ToString(), md.ToString()));
                subItems.Add(CreateRow(md.Description, md.Description));
                subItems.Add(CreateRow(md.Kits.Count > 0 ? md.Kits.Count + " kits" : "", md.Kits.Count));

                #region Определение текста для колонки "Первое выполнение"

                var subItem = new CustomCell();
                if (md.Threshold.FirstPerformanceSinceNew != null && !md.Threshold.FirstPerformanceSinceNew.IsNullOrZero())
                {
                    subItem.Text = "s/n: " + md.Threshold.FirstPerformanceSinceNew;
                    subItem.Tag  = md.Threshold.FirstPerformanceSinceNew;
                }
                if (md.Threshold.FirstPerformanceSinceEffectiveDate != null &&
                    !md.Threshold.FirstPerformanceSinceEffectiveDate.IsNullOrZero())
                {
                    if (subItem.Text != "")
                    {
                        subItem.Text += " or ";
                    }
                    else
                    {
                        subItem.Text = "";
                        subItem.Tag  = md.Threshold.FirstPerformanceSinceEffectiveDate;
                    }
                    subItem.Text += "s/e.d: " + md.Threshold.FirstPerformanceSinceEffectiveDate;
                }

                subItems.Add(subItem);
                #endregion

                #region Определение текста для колонки "повторяющийся интервал"

                subItem = new CustomCell();
                if (!md.Threshold.RepeatInterval.IsNullOrZero())
                {
                    subItem.Text = md.Threshold.RepeatInterval.ToString();
                    subItem.Tag  = md.Threshold.RepeatInterval;
                }
                else
                {
                    subItem.Text = "";
                    subItem.Tag  = Lifelength.Null;
                }
                subItems.Add(subItem);
                #endregion

                subItems.Add(CreateRow(md.Remains.ToString(), md.Remains));
                subItems.Add(CreateRow(md.ProcedureType.ToString(), md.ProcedureType));
                subItems.Add(CreateRow(md.NextPerformanceDate == null ? "N/A" : SmartCore.Auxiliary.Convert.GetDateFormat((DateTime)md.NextPerformanceDate), md.NextPerformanceDate));
                subItems.Add(CreateRow(md.ManHours.ToString(), md.ManHours));
                subItems.Add(CreateRow(md.Cost.ToString(), md.Cost));
                subItems.Add(CreateRow(author, author));
            }
            else if (item is NonRoutineJob)
            {
                NonRoutineJob job = (NonRoutineJob)item;
                AtaChapter    ata = job.ATAChapter;
                subItems.Add(CreateRow(ata != null ? ata.ToString() : "", ata));
                subItems.Add(CreateRow(job.Title, job.Title));
                subItems.Add(CreateRow(job.Description, job.Description));
                subItems.Add(CreateRow(job.Kits.Count > 0 ? job.Kits.Count + " kits" : "", job.Kits.Count));
                subItems.Add(CreateRow("", Lifelength.Null));
                subItems.Add(CreateRow("", Lifelength.Null));
                subItems.Add(CreateRow("", Lifelength.Null));
                subItems.Add(CreateRow("", ""));
                subItems.Add(CreateRow("", DateTimeExtend.GetCASMinDateTime()));
                subItems.Add(CreateRow(job.ManHours.ToString(), job.ManHours));
                subItems.Add(CreateRow(job.Cost.ToString(), job.Cost));
                subItems.Add(CreateRow(author, author));
            }
            else
            {
                throw new ArgumentOutOfRangeException($"1135: Takes an argument has no known type {item.GetType()}");
            }

            return(subItems);
        }
Example #40
0
        /// <summary>
        /// Parses the specified template text.
        /// </summary>
        /// <param name="templateText">The template text.</param>
        private void Parse(string templateText)
        {
            //var filePath = Path.GetFullPath(Path.Combine(templateCodePath, TemplateFileName));
            var tokeniser = new Tokeniser(TemplateFileName, templateText);

            AddCode(tokeniser.Location, "");

            bool skip = false;

            while ((skip || tokeniser.Advance()) && tokeniser.State != State.EOF)
            {
                skip = false;
                switch (tokeniser.State)
                {
                case State.Block:
                    if (!String.IsNullOrEmpty(tokeniser.Value))
                    {
                        AddDoTemplateCode(tokeniser.Location, tokeniser.Value);
                    }
                    break;

                case State.Content:
                    if (!String.IsNullOrEmpty(tokeniser.Value))
                    {
                        AddContent(tokeniser.Location, tokeniser.Value);
                    }
                    break;

                case State.Expression:
                    if (!String.IsNullOrEmpty(tokeniser.Value))
                    {
                        AddExpression(tokeniser.Location, tokeniser.Value);
                    }
                    break;

                case State.Helper:
                    _isTemplateClassCode = true;
                    if (!String.IsNullOrEmpty(tokeniser.Value))
                    {
                        AddDoTemplateClassCode(tokeniser.Location, tokeniser.Value);
                    }
                    break;

                case State.Directive:
                    Directive directive = null;
                    string    attName   = null;
                    while (!skip && tokeniser.Advance())
                    {
                        switch (tokeniser.State)
                        {
                        case State.DirectiveName:
                            if (directive == null)
                            {
                                directive = new Directive {
                                    Name = tokeniser.Value.ToLower()
                                }
                            }
                            ;
                            else
                            {
                                attName = tokeniser.Value;
                            }
                            break;

                        case State.DirectiveValue:
                            if (attName != null && directive != null)
                            {
                                directive.Attributes.Add(attName.ToLower(), tokeniser.Value);
                            }
                            attName = null;
                            break;

                        case State.Directive:
                            //if (directive != null)
                            //    directive.EndLocation = tokeniser.TagEndLocation;
                            break;

                        default:
                            skip = true;
                            break;
                        }
                    }
                    if (directive != null)
                    {
                        if (directive.Name == "include")
                        {
                            string includeFile = directive.Attributes["file"];
                            if (OnInclude == null)
                            {
                                throw new InvalidOperationException("Include file found. OnInclude event must be implemented");
                            }
                            var includeArgs = new TemplateIncludeArgs()
                            {
                                IncludeName = includeFile
                            };
                            OnInclude(this, includeArgs);
                            Parse(includeArgs.Text ?? "");
                        }
                        _directives.Add(directive);
                    }
                    break;

                default:
                    throw new InvalidOperationException();
                }
            }
        }
Example #41
0
 public override Result InspectRectExecute(Directive directive)
 {
     return(Result.OK);
 }
Example #42
0
        /// <summary>
        /// Создает объект отображающий краткую информацию о директиве
        /// </summary>
        /// <param name="currentDirective"></param>
        public DirectiveSummary(Directive currentDirective) : this()
        {
            _currentDirective = currentDirective;

            UpdateInformation();
        }
Example #43
0
 public override Result WetExecute(Directive directive)
 {
     return(Result.OK);
 }
 public override void VisitDirective(Directive directive, ISchema schema) => SetDescription(directive);
Example #45
0
 public static void RenderDirectiveToCharSetString(StringBuilder sb, Directive dir)
 {
     sb.AppendFormat("{0} ", dir.Name);
     RenderExpression(sb, dir.Expression);
 }
 public override void VisitDirectiveArgumentDefinition(QueryArgument argument, Directive directive, ISchema schema) => SetDescription(argument);
Example #47
0
	    private void SaveBlock(List<string> block, Directive directive)
		{
            if (block == null || block.Count == 0 || directive == Directive.None)
            {
                return;
            }

            switch (directive)
            {
                case Directive.Expect:
                    this.expect.Add(block);
                    break;

                case Directive.ExpectCtError:
                    if (this.expectCtError != null)
                        throw new TestException(String.Format("{0}: [expect ct-error] redefinition", this.sourcePath));
                    this.expectedTestResult = TestResult.CtError;
                    this.expectCtError = block;
                    break;

                case Directive.ExpectCtWarning:
                    this.expectCtWarning.Add(block);
                    break;

                case Directive.ExpectExact:
                    if (this.expectExact != null)
                        throw new TestException(String.Format("{0}: [expect exact] redefinition", this.sourcePath));
                    this.expectExact = block;
                    break;

                case Directive.ExpectPhp:
                    if (expectPhp)
                        throw new TestException(String.Format("{0}: [expect php] specified twice", this.sourcePath));
                    expectPhp = true;
                    break;

                case Directive.Config:
                    if (configuration != null)
                        throw new TestException(String.Format("{0}: [configuration] specified twice", this.sourcePath));
                    configuration = block;
                    break;

                case Directive.File:
                    if (this.script != null)
                        throw new TestException(String.Format("{0}: [script] redefinition", this.sourcePath));
                    this.script = block;
                    break;

                case Directive.Comment:
                    if (this.comment != null)
                        throw new TestException(String.Format("{0}: [test] redefinition", this.sourcePath));
                    this.comment = block;
                    break;

                case Directive.SkipIf:
                    if (this.skipIf != null)
                        throw new TestException(String.Format("{0}: [skipif] redefinition", this.sourcePath));
                    this.skipIf = block;
                    break;

                case Directive.NumberOfRuns:
                    if (this.numberOfRuns > 0)
                    {
                        throw new TestException(String.Format("{0}: [runs] redefinition", sourcePath));
                    }

                    if (!Int32.TryParse(Utils.ListToString(block), out numberOfRuns))
                    {
                        throw new TestException(String.Format("{0}: [runs] invalid value", sourcePath));  
                    }

                    break;

                case Directive.AdditionalScripts:
                    if (this.additionalScripts != null)
                        throw new TestException(String.Format("{0}: [additional scripts] redefinition", this.sourcePath));
                    this.additionalScripts = block;
                    break;

                case Directive.Pure:
                    this.isPure = true;
                    break;
                case Directive.Clr:
                    this.isClr = true;
                    break;
            }
		}
Example #48
0
        public static void RenderDirectiveToFontFaceString(StringBuilder sb, Directive dir)
        {
            sb.Append("@font-face {");

            bool first = true;
            foreach (Declaration dec in dir.Declarations)
            {
                if (first) {
                    first = false;
                } else {
                    sb.Append(";");
                }
                RenderDeclaration(sb, dec);
            }

            sb.Append("}");
        }
Example #49
0
 private void AlignToMe(Directive me)
 {
     if (Alignment == ArcAlignment.None)
         return;
     Vector3 endPoint = me.Points[0];
     Vector3 startPoint = Points[0];
     AlignmentSwitch(startPoint, endPoint);
 }
Example #50
0
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 public static Directive add_directive(Directives which_directive, ScreenBuffer target_buffer = null, List<Layer> layers = null, ScreenBuffer source_buffer = null, EffectInstance shader = null, uint color = 0xff000000)
 {
     Directive D = new Directive(which_directive, source_buffer, target_buffer, layers, shader, color);
     program.Add(D);
     return D;
 }
Example #51
0
        void directive(out Directive dir)
        {
            dir = new Directive();
            Declaration dec = null;
            RuleSet rset = null;
            Expression exp = null;
            Directive dr = null;
            string ident = null;
            Medium m;

            Expect(23);
            dir.Name = "@";
            if (la.kind == 24) {
                Get();
                dir.Name += "-";
            }
            identity(out ident);
            dir.Name += ident;
            switch (dir.Name.ToLower()) {
                case "@media": dir.Type = DirectiveType.Media; break;
                case "@import": dir.Type = DirectiveType.Import; break;
                case "@charset": dir.Type = DirectiveType.Charset; break;
                case "@page": dir.Type = DirectiveType.Page; break;
                case "@font-face": dir.Type = DirectiveType.FontFace; break;
                case "@namespace": dir.Type = DirectiveType.Namespace; break;
                default: dir.Type = DirectiveType.Other; break;
            }

            while (la.kind == 4) {
                Get();
            }
            if (StartOf(4)) {
                if (StartOf(5)) {
                    medium(out m);
                    dir.Mediums.Add(m);
                    while (la.kind == 4) {
                        Get();
                    }
                    while (la.kind == 25) {
                        Get();
                        while (la.kind == 4) {
                            Get();
                        }
                        medium(out m);
                        dir.Mediums.Add(m);
                        while (la.kind == 4) {
                            Get();
                        }
                    }
                } else {
                    expr(out exp);
                    dir.Expression = exp;
                    while (la.kind == 4) {
                        Get();
                    }
                }
            }
            if (la.kind == 26) {
                Get();
                while (la.kind == 4) {
                    Get();
                }
                if (StartOf(6)) {
                    while (StartOf(1)) {
                        if (dir.Type == DirectiveType.Page || dir.Type == DirectiveType.FontFace) {
                            declaration(out dec);
                            dir.Declarations.Add(dec);
                            while (la.kind == 4) {
                                Get();
                            }
                            while (la.kind == 27) {
                                Get();
                                while (la.kind == 4) {
                                    Get();
                                }
                                if (la.val.Equals("}")) { Get(); return; }
                                declaration(out dec);
                                dir.Declarations.Add(dec);
                                while (la.kind == 4) {
                                    Get();
                                }
                            }
                            if (la.kind == 27) {
                                Get();
                                while (la.kind == 4) {
                                    Get();
                                }
                            }
                        } else if (StartOf(2)) {
                            ruleset(out rset);
                            dir.RuleSets.Add(rset);
                            while (la.kind == 4) {
                                Get();
                            }
                        } else {
                            directive(out dr);
                            dir.Directives.Add(dr);
                            while (la.kind == 4) {
                                Get();
                            }
                        }
                    }
                }
                Expect(28);
                while (la.kind == 4) {
                    Get();
                }
            } else if (la.kind == 27) {
                Get();
                while (la.kind == 4) {
                    Get();
                }
            } else SynErr(49);
        }
 public static Directive WithName(this Directive directive,
                                  in Name name)
Example #53
0
        protected override object EvalDirective(ParseTree tree, params object[] paramlist)
        {
            Grammar g = (Grammar)paramlist[0];
            GrammarNode node = (GrammarNode)paramlist[1];
            string name = node.Nodes[1].Token.Text;

            switch (name)
            {
                case "TinyPG":
                case "Parser":
                case "Scanner":
                case "ParseTree":
                case "TextHighlighter":
                    if (g.Directives.Find(name) != null)
                    {
                        tree.Errors.Add(new ParseError("Directive '" + name + "' is already defined", 0x1030, node.Nodes[1]));
                        return null; ;
                    }
                    break;
                default:
                    tree.Errors.Add(new ParseError("Directive '" + name + "' is not supported", 0x1031, node.Nodes[1]));
                    break;
            }

            Directive directive = new Directive(name);
            g.Directives.Add(directive);

            foreach (ParseNode n in node.Nodes)
            {
                if (n.Token.Type == TokenType.NameValue)
                    EvalNameValue(tree, new object[] { g, directive, n });
            }

            return null;
        }
Example #54
0
        public void AppendDirective(string name, string body, string comment)
        {
            if (IsMultipleDirective(name))
            {
                if (Directives.ContainsKey(name) == false)
                    Directives[name] = new List<Directive>();
            }
            else
            {
                Directives[name] = new List<Directive>();
            }

            Directive d = new Directive();
            d.Text = body.Trim();
            d.Comment = comment.Trim();
            Directives[name].Add(d);
        }
 static bool ComplainExcessAttributes(Directive dt, ParsedTemplate pt)
 {
     if (dt.Attributes.Count == 0)
         return false;
     StringBuilder sb = new StringBuilder ("Unknown attributes ");
     bool first = true;
     foreach (string key in dt.Attributes.Keys) {
         if (!first) {
             sb.Append (", ");
         } else {
             first = false;
         }
         sb.Append (key);
     }
     sb.Append (" found in ");
     sb.Append (dt.Name);
     sb.Append (" directive.");
     pt.LogWarning (sb.ToString (), dt.StartLocation);
     return false;
 }
Example #56
0
 /// <summary>
 /// Returns the string representation of the underlying syntax, not including its leading and trailing trivia.
 /// </summary>
 /// <returns></returns>
 public override string ToString()
 {
     return(Directive?.ToString() ?? "");
 }
Example #57
0
        private void ToolStripMenuItemShowTaskCardClick(object sender, EventArgs e)
        {
            if (_directivesViewer.SelectedItems == null ||
                _directivesViewer.SelectedItems.Count == 0)
            {
                return;
            }

            BaseEntityObject  o = _directivesViewer.SelectedItems[0];
            IBaseEntityObject parent;

            if (o is NextPerformance)
            {
                parent = ((NextPerformance)o).Parent;
            }
            else if (o is AbstractPerformanceRecord)
            {
                parent = ((AbstractPerformanceRecord)o).Parent;
            }
            else
            {
                parent = o;
            }

            Directive dir = null;

            if (parent is Directive)
            {
                dir = (Directive)parent;
            }

            AttachedFile attachedFile = null;

            if (sender == _toolStripMenuItemShowADFile && dir != null)
            {
                attachedFile = dir.ADNoFile;
            }
            if (sender == _toolStripMenuItemShowSBFile && dir != null)
            {
                attachedFile = dir.ServiceBulletinFile;
            }
            if (sender == _toolStripMenuItemShowEOFile && dir != null)
            {
                attachedFile = dir.EngineeringOrderFile;
            }
            if (attachedFile == null)
            {
                MessageBox.Show("Not set required File", (string)new GlobalTermsProvider()["SystemName"],
                                MessageBoxButtons.OK, MessageBoxIcon.Exclamation,
                                MessageBoxDefaultButton.Button1);
                return;
            }
            try
            {
                string message;
                GlobalObjects.CasEnvironment.OpenFile(attachedFile, out message);
                if (message != "")
                {
                    MessageBox.Show(message, (string)new GlobalTermsProvider()["SystemName"],
                                    MessageBoxButtons.OK, MessageBoxIcon.Exclamation,
                                    MessageBoxDefaultButton.Button1);
                    return;
                }
            }
            catch (Exception ex)
            {
                string errorDescriptionSctring =
                    $"Error while Open Attached File for {dir}, id {dir.ItemId}. \nFileId {attachedFile.ItemId}";
                Program.Provider.Logger.Log(errorDescriptionSctring, ex);
            }
        }
Example #58
0
        public static void RenderDirectiveToPageString(StringBuilder sb, Directive dir)
        {
            sb.Append("@page ");
            if (dir.Expression != null) { sb.AppendFormat("{0} ", dir.Expression); }
            sb.Append("{");

            bool first = true;
            foreach (Declaration dec in dir.Declarations)
            {
                if (first) {
                    first = false;
                } else {
                    sb.Append(";");
                }
                RenderDeclaration(sb, dec);
            }

            sb.Append("}");
        }
Example #59
0
        private void InitListView(DefferedListView directiveListView)
        {
            _directivesViewer                       = directiveListView;
            _directivesViewer.TabIndex              = 2;
            _directivesViewer.Location              = new Point(panel1.Left, panel1.Top);
            _directivesViewer.Dock                  = DockStyle.Fill;
            _directivesViewer.SelectedItemsChanged += DirectivesViewerSelectedItemsChanged;
            Controls.Add(_directivesViewer);
            //события
            _directivesViewer.SelectedItemsChanged += DirectivesViewerSelectedItemsChanged;

            _directivesViewer.AddMenuItems(_toolStripMenuItemOpen,
                                           _toolStripMenuItemShowADFile,
                                           _toolStripMenuItemShowSBFile,
                                           _toolStripMenuItemShowEOFile,
                                           new RadMenuSeparatorItem(),
                                           _toolStripMenuItemHighlight);

            _directivesViewer.MenuOpeningAction = () =>
            {
                if (_directivesViewer.SelectedItems.Count <= 0)
                {
                    _toolStripMenuItemOpen.Enabled       = false;
                    _toolStripMenuItemShowADFile.Enabled = false;
                    _toolStripMenuItemShowSBFile.Enabled = false;
                    _toolStripMenuItemShowEOFile.Enabled = false;
                    _toolStripMenuItemHighlight.Enabled  = false;
                }

                if (_directivesViewer.SelectedItems.Count == 1)
                {
                    _toolStripMenuItemOpen.Enabled = true;

                    BaseEntityObject  o = _directivesViewer.SelectedItems[0];
                    IBaseEntityObject parent;
                    if (o is NextPerformance)
                    {
                        parent = ((NextPerformance)o).Parent;
                    }
                    else if (o is AbstractPerformanceRecord)
                    {
                        parent = ((AbstractPerformanceRecord)o).Parent;
                    }
                    else
                    {
                        parent = o;
                    }

                    Directive dir = null;
                    if (parent is Directive)
                    {
                        dir = (Directive)parent;
                    }

                    if (dir != null)
                    {
                        _toolStripMenuItemShowEOFile.Enabled = dir.EngineeringOrderFile != null;
                        _toolStripMenuItemShowSBFile.Enabled = dir.ServiceBulletinFile != null;
                        _toolStripMenuItemShowADFile.Enabled = dir.ADNoFile != null;
                    }
                }

                if (_directivesViewer.SelectedItems.Count > 0)
                {
                    _toolStripMenuItemOpen.Enabled      = true;
                    _toolStripMenuItemHighlight.Enabled = true;
                }
            };

            panel1.Controls.Add(_directivesViewer);
        }
Example #60
0
 static string Render(Directive dir)
 {
     return Render(dir, 0);
 }