Class SequenceRule

Namespace

NMF.AnyText.Rules

Assembly

NMF.AnyText.Core.dll

Denotes a rule that other rules occur in sequence

public class SequenceRule : Rule

Inheritance

object

Rule

SequenceRule

Derived

ElementRule<TElement>

ParanthesesRule

Inherited Members

Rule.Name

Rule.OnActivate(RuleApplication, ParseContext)

Rule.OnDeactivate(RuleApplication, ParseContext)

Rule.OnValueChange(RuleApplication, ParseContext, RuleApplication)

Rule.IsLiteral

Rule.IsComment

Rule.IsImports()

Rule.TrailingWhitespaces

Rule.Initialize(GrammarContext)

Rule.PostInitialize(GrammarContext)

Rule.TokenType

Rule.IsDefinition

Rule.IsReference

Rule.IsIdentifier

Rule.SymbolKind

Rule.SymbolTags(RuleApplication)

Rule.PassAlongDocumentSymbols

Rule.Invalidate(RuleApplication, ParseContext)

Rule.IsLeftRecursive

Rule.CanSynthesize(object, ParseContext)

Rule.Synthesize(object, ParseContext, string)

Rule.Synthesize(object, ParseContext, TextWriter, string)

Rule.IsEpsilonAllowed()

Rule.CreateEpsilonRuleApplication(RuleApplication)

Rule.CanStartWith(Rule)

Rule.TokenModifiers

Rule.GetInlayHintText(RuleApplication)

Rule.SuggestCompletions(ParseContext, RuleApplication, string, ParsePosition)

Rule.TokenTypeIndex

Rule.TokenModifierIndex

Rule.GetHoverText(RuleApplication, Parser, ParsePosition)

Rule.RegisterSymbolKind(Dictionary<Type, SymbolKind>)

object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

Constructors

SequenceRule()

Creates a new instance

public SequenceRule()

SequenceRule(params FormattedRule[])

Creates a new instance

public SequenceRule(params FormattedRule[] rules)

Parameters

rules FormattedRule[]

The rules that should occur in sequence

Properties

Rules

The rules that should occur in sequence

public FormattedRule[] Rules { get; set; }

Property Value

FormattedRule[]

Methods

Accept(ref RuleApplication, List<RuleApplication>, ParseContext)

Decides whether the provided rule application shall be accepted

protected bool Accept(ref RuleApplication ruleApplication, List<RuleApplication> ruleApplications, ParseContext context)

Parameters

ruleApplication RuleApplication

the rule application that shall be accepted

ruleApplications List<RuleApplication>

the rule applications accepted so far

context ParseContext

the parse context in which the rule applications shall be accepted

Returns

bool

true, if the rule application shall be accepted, otherwise false

CanStartWith(Rule, List<Rule>)

Indicates whether the rule could start with the given other rule

protected override bool CanStartWith(Rule rule, List<Rule> trace)

Parameters

rule Rule

the other rule

trace List<Rule>

a list of rules visited so far

Returns

bool

true, if the rule could start with the given other rule, otherwise false

CanSynthesize(object, ParseContext, SynthesisPlan)

Determines whether the current rule can synthesize rule applications for the given semantic element

public override bool CanSynthesize(object semanticElement, ParseContext context, SynthesisPlan synthesisPlan)

Parameters

semanticElement object

the semantic element

context ParseContext

the context in which the rule is synthesized

synthesisPlan SynthesisPlan

the plan of the synthesis

Returns

bool

true, if a rule application can be synthesized, otherwise false

CreateRuleApplication(ParsePosition, List<RuleApplication>, ParsePositionDelta, ParsePositionDelta)

Creates a rule application for a success

protected virtual RuleApplication CreateRuleApplication(ParsePosition currentPosition, List<RuleApplication> inner, ParsePositionDelta length, ParsePositionDelta examined)

Parameters

currentPosition ParsePosition

the current parser position

inner List<RuleApplication>

the inner list of rule applications

length ParsePositionDelta

the length of the match

examined ParsePositionDelta

the amount of text examined

Returns

RuleApplication

a new rule application

CreateSynthesisRequirements()

Creates a collection of requirements for synthesis

public override IEnumerable<SynthesisRequirement> CreateSynthesisRequirements()

Returns

IEnumerable<SynthesisRequirement>

A collection of synthesis requirements

GetOrCreateSynthesisRequirements()

Gets or creates synthesis requirements for the individual rules

protected IEnumerable<SynthesisRequirement>[] GetOrCreateSynthesisRequirements()

Returns

IEnumerable<SynthesisRequirement>[]

An array with the synthesis requirements for the individual rules of the sequence

HasFoldingKind(out string)

Returns the folding kind for a rule if one is defined for the rule

public override bool HasFoldingKind(out string kind)

Parameters

kind string

The folding kind of the rule

Returns

bool

True, if a folding kind is defined for the rule

IsEpsilonAllowed(List<Rule>)

Determines whether the rule could capture empty input

protected override bool IsEpsilonAllowed(List<Rule> trace)

Parameters

trace List<Rule>

Returns

bool

true, if the rule can be expanded to an empty string, otherwise false

IsFoldable()

True, if the application of this rule can be folded away (hidden)

public override bool IsFoldable()

Returns

bool

IsMatchingEndLiteral(string, string)

Checks if a given pair of start and end literal match

public virtual bool IsMatchingEndLiteral(string literal, string startLiteral)

Parameters

literal string

The end literal

startLiteral string

The start literal

Returns

bool

True, if the given literal is a matching end literal for a given start literal

IsRangeStartLiteral(string)

Checks if a given literal denotes the start of a generic folding range

public virtual bool IsRangeStartLiteral(string literal)

Parameters

literal string

Returns

bool

True, if the given literal denotes the start of a generic foldable range

IsRegion()

Determines whether the current rule represents a region

public virtual bool IsRegion()

Returns

bool

true, if it represents a region, otherwise false

IsRegionStartLiteral(string)

Checks if a literal denotes the start of a region

public virtual bool IsRegionStartLiteral(string literal)

Parameters

literal string

The start literal

Returns

bool

True, if the given literal denotes the start of a region

Match(ParseContext, RecursionContext, ref ParsePosition)

Matches the the context at the provided position

public override RuleApplication Match(ParseContext context, RecursionContext recursionContext, ref ParsePosition position)

Parameters

context ParseContext

the context in which the rule is matched

recursionContext RecursionContext

the recursion context of the matching

position ParsePosition

the position in the input

Returns

RuleApplication

the rule application for the provided position

Synthesize(object, ParsePosition, ParseContext)

Synthesizes a rule application for the given semantic element

public override RuleApplication Synthesize(object semanticElement, ParsePosition position, ParseContext context)

Parameters

semanticElement object

position ParsePosition

the parse position at which the element should be synthesized

context ParseContext

the parse context

Returns

RuleApplication

a rule application

ToString()

Returns a string that represents the current object.

public override string ToString()

Returns

string

A string that represents the current object.