W3SpecSparqlParser

Hierarchy

BaseSparqlParser
- W3SpecSparqlParser

Implements

IStardogParser

Index

Constructors

constructor

Properties

Constructors

constructor

new W3SpecSparqlParser(options?: any): W3SpecSparqlParser

Overrides BaseSparqlParser.constructor
- Defined in sparql/W3SpecSparqlParser.ts:5
Parameters
- Optional options: any
Returns W3SpecSparqlParser

Properties

Add

Add: function = this.RULE('Add', () => {log('Add');this.CONSUME(sparqlTokenMap.ADD);this.OPTION(() => this.CONSUME(sparqlTokenMap.SILENT));this.SUBRULE(this.GraphOrDefault);this.CONSUME(sparqlTokenMap.TO);this.SUBRULE1(this.GraphOrDefault);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

AdditiveExpression

AdditiveExpression: function = this.RULE('AdditiveExpression', () => {log('AdditiveExpression');this.SUBRULE(this.MultiplicativeExpression);this.MANY(() =>this.OR([{ALT: () => {this.OR1([{ ALT: () => this.CONSUME(sparqlTokenMap.Plus) },{ ALT: () => this.CONSUME(sparqlTokenMap.Minus) },]);this.SUBRULE1(this.MultiplicativeExpression);},},{ALT: () => {this.OR2([{ ALT: () => this.SUBRULE(this.NumericLiteralPositive) },{ ALT: () => this.SUBRULE(this.NumericLiteralNegative) },]);this.MANY1(() =>this.OR3([{ALT: () => {this.OR4([{ ALT: () => this.CONSUME(sparqlTokenMap.Star) },{ALT: () => this.CONSUME(sparqlTokenMap.ForwardSlash),},]);this.SUBRULE1(this.UnaryExpression);},},]));},},]));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Aggregate

Aggregate: function = this.RULE('Aggregate', () => {log('Aggregate');this.OR([{ ALT: () => this.SUBRULE(this.Count) },{ ALT: () => this.SUBRULE(this.Sum) },{ ALT: () => this.SUBRULE(this.Min) },{ ALT: () => this.SUBRULE(this.Max) },{ ALT: () => this.SUBRULE(this.Avg) },{ ALT: () => this.SUBRULE(this.Sample) },{ ALT: () => this.SUBRULE(this.GroupConcat) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ArgList

ArgList: function = this.RULE('ArgList', () => {log('ArgList');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.NIL) },{ALT: () => {this.CONSUME(sparqlTokenMap.LParen);this.OPTION(() => this.CONSUME(sparqlTokenMap.DISTINCT));this.SUBRULE(this.Expression);this.MANY(() => {this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);});this.CONSUME(sparqlTokenMap.RParen);},},]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

AskQuery

AskQuery: function = this.RULE('AskQuery', () => {log('AskQuery');this.CONSUME(sparqlTokenMap.ASK);this.MANY(() => this.SUBRULE(this.DatasetClause));this.SUBRULE(this.WhereClause);this.SUBRULE(this.SolutionModifier);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Avg

Avg: function = this.RULE('Avg', () => {log('Avg');this.CONSUME(sparqlTokenMap.AVG);this.CONSUME1(sparqlTokenMap.LParen);this.OPTION(() => this.CONSUME2(sparqlTokenMap.DISTINCT));this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BaseDecl

BaseDecl: function = this.RULE('BaseDecl', () => {log('BaseDecl');this.CONSUME(sparqlTokenMap.BASE);this.CONSUME(sparqlTokenMap.IRIREF);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Bind

Bind: function = this.RULE('Bind', () => {log('Bind');this.CONSUME(sparqlTokenMap.BIND);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.AS);this.SUBRULE(this.Var);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BlankNode

BlankNode: function = this.RULE('BlankNode', () => {log('BlankNode');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.BLANK_NODE_LABEL) },{ ALT: () => this.CONSUME(sparqlTokenMap.ANON) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BlankNodePropertyList

BlankNodePropertyList: function = this.RULE('BlankNodePropertyList', () => {log('BlankNodePropertyList');this.CONSUME(sparqlTokenMap.LBracket);this.SUBRULE(this.PropertyListNotEmpty);this.CONSUME(sparqlTokenMap.RBracket);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BlankNodePropertyListPath

BlankNodePropertyListPath: function = this.RULE('BlankNodePropertyListPath', () => {log('BlankNodePropertyListPath');this.CONSUME(sparqlTokenMap.LBracket);this.SUBRULE(this.PropertyListPathNotEmpty);this.CONSUME(sparqlTokenMap.RBracket);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BooleanLiteral

BooleanLiteral: function = this.RULE('BooleanLiteral', () => {log('BooleanLiteral');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.TRUE) },{ ALT: () => this.CONSUME(sparqlTokenMap.FALSE) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BrackettedExpression

BrackettedExpression: function = this.RULE('BrackettedExpression', () => {log('BrackettedExpression');this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall

BuiltInCall: function = this.RULE('BuiltInCall', () => {log('BuiltInCall');this.OR([{ ALT: () => this.SUBRULE(this.Aggregate) },{ ALT: () => this.SUBRULE(this.BuiltInCall_STR) },{ ALT: () => this.SUBRULE(this.BuiltInCall_LANG) },{ ALT: () => this.SUBRULE(this.BuiltInCall_LANGMATCHES) },{ ALT: () => this.SUBRULE(this.BuiltInCall_DATATYPE) },{ ALT: () => this.SUBRULE(this.BuiltInCall_BOUND) },{ ALT: () => this.SUBRULE(this.BuiltInCall_IRI) },{ ALT: () => this.SUBRULE(this.BuiltInCall_URI) },{ ALT: () => this.SUBRULE(this.BuiltInCall_BNODE) },{ ALT: () => this.SUBRULE(this.BuiltInCall_RAND) },{ ALT: () => this.SUBRULE(this.BuiltInCall_ABS) },{ ALT: () => this.SUBRULE(this.BuiltInCall_CEIL) },{ ALT: () => this.SUBRULE(this.BuiltInCall_FLOOR) },{ ALT: () => this.SUBRULE(this.BuiltInCall_ROUND) },{ ALT: () => this.SUBRULE(this.BuiltInCall_CONCAT) },{ ALT: () => this.SUBRULE(this.SubstringExpression) },{ ALT: () => this.SUBRULE(this.BuiltInCall_STRLEN) },{ ALT: () => this.SUBRULE(this.StrReplaceExpression) },{ ALT: () => this.SUBRULE(this.BuiltInCall_UCASE) },{ ALT: () => this.SUBRULE(this.BuiltInCall_LCASE) },{ ALT: () => this.SUBRULE(this.BuiltInCall_ENCODE_FOR_URI) },{ ALT: () => this.SUBRULE(this.BuiltInCall_CONTAINS) },{ ALT: () => this.SUBRULE(this.BuiltInCall_STRSTARTS) },{ ALT: () => this.SUBRULE(this.BuiltInCall_STRENDS) },{ ALT: () => this.SUBRULE(this.BuiltInCall_STRBEFORE) },{ ALT: () => this.SUBRULE(this.BuiltInCall_STRAFTER) },{ ALT: () => this.SUBRULE(this.BuiltInCall_YEAR) },{ ALT: () => this.SUBRULE(this.BuiltInCall_MONTH) },{ ALT: () => this.SUBRULE(this.BuiltInCall_DAY) },{ ALT: () => this.SUBRULE(this.BuiltInCall_HOURS) },{ ALT: () => this.SUBRULE(this.BuiltInCall_MINUTES) },{ ALT: () => this.SUBRULE(this.BuiltInCall_SECONDS) },{ ALT: () => this.SUBRULE(this.BuiltInCall_TIMEZONE) },{ ALT: () => this.SUBRULE(this.BuiltInCall_TZ) },{ ALT: () => this.SUBRULE(this.BuiltInCall_NOW) },{ ALT: () => this.SUBRULE(this.BuiltInCall_UUID) },{ ALT: () => this.SUBRULE(this.BuiltInCall_STRUUID) },{ ALT: () => this.SUBRULE(this.BuiltInCall_MD5) },{ ALT: () => this.SUBRULE(this.BuiltInCall_SHA1) },{ ALT: () => this.SUBRULE(this.BuiltInCall_SHA256) },{ ALT: () => this.SUBRULE(this.BuiltInCall_SHA384) },{ ALT: () => this.SUBRULE(this.BuiltInCall_SHA512) },{ ALT: () => this.SUBRULE(this.BuiltInCall_COALESCE) },{ ALT: () => this.SUBRULE(this.BuiltInCall_IF) },{ ALT: () => this.SUBRULE(this.BuiltInCall_STRLANG) },{ ALT: () => this.SUBRULE(this.BuiltInCall_STRDT) },{ ALT: () => this.SUBRULE(this.BuiltInCall_sameTerm) },{ ALT: () => this.SUBRULE(this.BuiltInCall_isIRI) },{ ALT: () => this.SUBRULE(this.BuiltInCall_isURI) },{ ALT: () => this.SUBRULE(this.BuiltInCall_isBLANK) },{ ALT: () => this.SUBRULE(this.BuiltInCall_isLITERAL) },{ ALT: () => this.SUBRULE(this.BuiltInCall_isNUMERIC) },{ ALT: () => this.SUBRULE(this.RegexExpression) },{ ALT: () => this.SUBRULE(this.ExistsFunction) },{ ALT: () => this.SUBRULE(this.NotExistsFunction) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_ABS

BuiltInCall_ABS: function = this.RULE('BuiltInCall_ABS', () => {log('BuiltInCall_ABS');this.CONSUME(sparqlTokenMap.ABS);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_BNODE

BuiltInCall_BNODE: function = this.RULE('BuiltInCall_BNODE', () => {log('BuiltInCall_BNODE');this.CONSUME(sparqlTokenMap.BNODE);this.OR([{ALT: () => {this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);},},{ ALT: () => this.CONSUME(sparqlTokenMap.NIL) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_BOUND

BuiltInCall_BOUND: function = this.RULE('BuiltInCall_BOUND', () => {log('BuiltInCall_BOUND');this.CONSUME(sparqlTokenMap.BOUND);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Var);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_CEIL

BuiltInCall_CEIL: function = this.RULE('BuiltInCall_CEIL', () => {log('BuiltInCall_CEIL');this.CONSUME(sparqlTokenMap.CEIL);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_COALESCE

BuiltInCall_COALESCE: function = this.RULE('BuiltInCall_COALESCE', () => {log('BuiltInCall_COALESCE');this.CONSUME(sparqlTokenMap.COALESCE);this.SUBRULE(this.ExpressionList);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_CONCAT

BuiltInCall_CONCAT: function = this.RULE('BuiltInCall_CONCAT', () => {log('BuiltInCall_CONCAT');this.CONSUME(sparqlTokenMap.CONCAT);this.SUBRULE(this.ExpressionList);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_CONTAINS

BuiltInCall_CONTAINS: function = this.RULE('BuiltInCall_CONTAINS', () => {log('BuiltInCall_CONTAINS');this.CONSUME(sparqlTokenMap.CONTAINS);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_DATATYPE

BuiltInCall_DATATYPE: function = this.RULE('BuiltInCall_DATATYPE', () => {log('BuiltInCall_DATATYPE');this.CONSUME(sparqlTokenMap.DATATYPE);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_DAY

BuiltInCall_DAY: function = this.RULE('BuiltInCall_DAY', () => {log('BuiltInCall_DAY');this.CONSUME(sparqlTokenMap.DAY);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_ENCODE_FOR_URI

BuiltInCall_ENCODE_FOR_URI: function = this.RULE('BuiltInCall_ENCODE_FOR_URI', () => {log('BuiltInCall_ENCODE_FOR_URI');this.CONSUME(sparqlTokenMap.ENCODE_FOR_URI);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_FLOOR

BuiltInCall_FLOOR: function = this.RULE('BuiltInCall_FLOOR', () => {log('BuiltInCall_FLOOR');this.CONSUME(sparqlTokenMap.FLOOR);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_HOURS

BuiltInCall_HOURS: function = this.RULE('BuiltInCall_HOURS', () => {log('BuiltInCall_HOURS');this.CONSUME(sparqlTokenMap.HOURS);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_IF

BuiltInCall_IF: function = this.RULE('BuiltInCall_IF', () => {log('BuiltInCall_IF');this.CONSUME(sparqlTokenMap.IF);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME1(sparqlTokenMap.Comma);this.SUBRULE2(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_IRI

BuiltInCall_IRI: function = this.RULE('BuiltInCall_IRI', () => {log('BuiltInCall_IRI');this.CONSUME(sparqlTokenMap.IRI);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_LANG

BuiltInCall_LANG: function = this.RULE('BuiltInCall_LANG', () => {log('BuiltInCall_LANG');this.CONSUME(sparqlTokenMap.LANG);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_LANGMATCHES

BuiltInCall_LANGMATCHES: function = this.RULE('BuiltInCall_LANGMATCHES', () => {log('BuiltInCall_LANGMATCHES');this.CONSUME(sparqlTokenMap.LANGMATCHES);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_LCASE

BuiltInCall_LCASE: function = this.RULE('BuiltInCall_LCASE', () => {log('BuiltInCall_LCASE');this.CONSUME(sparqlTokenMap.LCASE);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_MD5

BuiltInCall_MD5: function = this.RULE('BuiltInCall_MD5', () => {log('BuiltInCall_MD5');this.CONSUME(sparqlTokenMap.MD5);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_MINUTES

BuiltInCall_MINUTES: function = this.RULE('BuiltInCall_MINUTES', () => {log('BuiltInCall_MINUTES');this.CONSUME(sparqlTokenMap.MINUTES);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_MONTH

BuiltInCall_MONTH: function = this.RULE('BuiltInCall_MONTH', () => {log('BuiltInCall_MONTH');this.CONSUME(sparqlTokenMap.MONTH);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_NOW

BuiltInCall_NOW: function = this.RULE('BuiltInCall_NOW', () => {log('BuiltInCall_NOW');this.CONSUME(sparqlTokenMap.NOW);this.CONSUME(sparqlTokenMap.NIL);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_RAND

BuiltInCall_RAND: function = this.RULE('BuiltInCall_RAND', () => {log('BuiltInCall_RAND');this.CONSUME(sparqlTokenMap.RAND);this.CONSUME(sparqlTokenMap.NIL);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_ROUND

BuiltInCall_ROUND: function = this.RULE('BuiltInCall_ROUND', () => {log('BuiltInCall_ROUND');this.CONSUME(sparqlTokenMap.ROUND);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_SECONDS

BuiltInCall_SECONDS: function = this.RULE('BuiltInCall_SECONDS', () => {log('BuiltInCall_SECONDS');this.CONSUME(sparqlTokenMap.SECONDS);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_SHA1

BuiltInCall_SHA1: function = this.RULE('BuiltInCall_SHA1', () => {log('BuiltInCall_SHA1');this.CONSUME(sparqlTokenMap.SHA1);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_SHA256

BuiltInCall_SHA256: function = this.RULE('BuiltInCall_SHA256', () => {log('BuiltInCall_SHA256');this.CONSUME(sparqlTokenMap.SHA256);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_SHA384

BuiltInCall_SHA384: function = this.RULE('BuiltInCall_SHA384', () => {log('BuiltInCall_SHA384');this.CONSUME(sparqlTokenMap.SHA384);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_SHA512

BuiltInCall_SHA512: function = this.RULE('BuiltInCall_SHA512', () => {log('BuiltInCall_SHA512');this.CONSUME(sparqlTokenMap.SHA512);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_STR

BuiltInCall_STR: function = this.RULE('BuiltInCall_STR', () => {log('BuiltInCall_STR');this.CONSUME(sparqlTokenMap.STR);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_STRAFTER

BuiltInCall_STRAFTER: function = this.RULE('BuiltInCall_STRAFTER', () => {log('BuiltInCall_STRAFTER');this.CONSUME(sparqlTokenMap.STRAFTER);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_STRBEFORE

BuiltInCall_STRBEFORE: function = this.RULE('BuiltInCall_STRBEFORE', () => {log('BuiltInCall_STRBEFORE');this.CONSUME(sparqlTokenMap.STRBEFORE);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_STRDT

BuiltInCall_STRDT: function = this.RULE('BuiltInCall_STRDT', () => {log('BuiltInCall_STRDT');this.CONSUME(sparqlTokenMap.STRDT);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_STRENDS

BuiltInCall_STRENDS: function = this.RULE('BuiltInCall_STRENDS', () => {log('BuiltInCall_STRENDS');this.CONSUME(sparqlTokenMap.STRENDS);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_STRLANG

BuiltInCall_STRLANG: function = this.RULE('BuiltInCall_STRLANG', () => {log('BuiltInCall_STRLANG');this.CONSUME(sparqlTokenMap.STRLANG);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_STRLEN

BuiltInCall_STRLEN: function = this.RULE('BuiltInCall_STRLEN', () => {log('BuiltInCall_STRLEN');this.CONSUME(sparqlTokenMap.STRLEN);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_STRSTARTS

BuiltInCall_STRSTARTS: function = this.RULE('BuiltInCall_STRSTARTS', () => {log('BuiltInCall_STRSTARTS');this.CONSUME(sparqlTokenMap.STRSTARTS);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_STRUUID

BuiltInCall_STRUUID: function = this.RULE('BuiltInCall_STRUUID', () => {log('BuiltInCall_STRUUID');this.CONSUME(sparqlTokenMap.STRUUID);this.CONSUME(sparqlTokenMap.NIL);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_TIMEZONE

BuiltInCall_TIMEZONE: function = this.RULE('BuiltInCall_TIMEZONE', () => {log('BuiltInCall_TIMEZONE');this.CONSUME(sparqlTokenMap.TIMEZONE);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_TZ

BuiltInCall_TZ: function = this.RULE('BuiltInCall_TZ', () => {log('BuiltInCall_TZ');this.CONSUME(sparqlTokenMap.TZ);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_UCASE

BuiltInCall_UCASE: function = this.RULE('BuiltInCall_UCASE', () => {log('BuiltInCall_UCASE');this.CONSUME(sparqlTokenMap.UCASE);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_URI

BuiltInCall_URI: function = this.RULE('BuiltInCall_URI', () => {log('BuiltInCall_URI');this.CONSUME(sparqlTokenMap.URI);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_UUID

BuiltInCall_UUID: function = this.RULE('BuiltInCall_UUID', () => {log('BuiltInCall_UUID');this.CONSUME(sparqlTokenMap.UUID);this.CONSUME(sparqlTokenMap.NIL);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_YEAR

BuiltInCall_YEAR: function = this.RULE('BuiltInCall_YEAR', () => {log('BuiltInCall_YEAR');this.CONSUME(sparqlTokenMap.YEAR);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_isBLANK

BuiltInCall_isBLANK: function = this.RULE('BuiltInCall_isBLANK', () => {log('BuiltInCall_isBLANK');this.CONSUME(sparqlTokenMap.isBLANK);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_isIRI

BuiltInCall_isIRI: function = this.RULE('BuiltInCall_isIRI', () => {log('BuiltInCall_isIRI');this.CONSUME(sparqlTokenMap.isIRI);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_isLITERAL

BuiltInCall_isLITERAL: function = this.RULE('BuiltInCall_isLITERAL', () => {log('BuiltInCall_isLITERAL');this.CONSUME(sparqlTokenMap.isLITERAL);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_isNUMERIC

BuiltInCall_isNUMERIC: function = this.RULE('BuiltInCall_isNUMERIC', () => {log('BuiltInCall_isNUMERIC');this.CONSUME(sparqlTokenMap.isNUMERIC);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_isURI

BuiltInCall_isURI: function = this.RULE('BuiltInCall_isURI', () => {log('BuiltInCall_isURI');this.CONSUME(sparqlTokenMap.isURI);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

BuiltInCall_sameTerm

BuiltInCall_sameTerm: function = this.RULE('BuiltInCall_sameTerm', () => {log('BuiltInCall_sameTerm');this.CONSUME(sparqlTokenMap.sameTerm);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Clear

Clear: function = this.RULE('Clear', () => {log('Clear');this.CONSUME(sparqlTokenMap.CLEAR);this.OPTION(() => this.CONSUME(sparqlTokenMap.SILENT));this.SUBRULE(this.GraphRefAll);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Collection

Collection: function = this.RULE('Collection', () => {log('Collection');this.CONSUME(sparqlTokenMap.LParen);this.AT_LEAST_ONE(() => this.SUBRULE(this.GraphNode));this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

CollectionPath

CollectionPath: function = this.RULE('CollectionPath', () => {log('CollectionPath');this.CONSUME(sparqlTokenMap.LParen);this.AT_LEAST_ONE(() => this.SUBRULE(this.GraphNodePath));this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ConditionalAndExpression

ConditionalAndExpression: function = this.RULE('ConditionalAndExpression', () => {log('ConditionalAndExpression');this.AT_LEAST_ONE_SEP({SEP: sparqlTokenMap.LogicalAnd,DEF: () => this.SUBRULE(this.ValueLogical),});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ConditionalOrExpression

ConditionalOrExpression: function = this.RULE('ConditionalOrExpression', () => {log('ConditionalOrExpression');this.AT_LEAST_ONE_SEP({SEP: sparqlTokenMap.LogicalOr,DEF: () => this.SUBRULE(this.ConditionalAndExpression),});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Constant

Constant: function = this.RULE('Constant', () => {this.OR([{ ALT: () => this.SUBRULE(this.iri) },{ ALT: () => this.SUBRULE(this.RDFLiteral) },{ ALT: () => this.SUBRULE(this.NumericLiteral) },{ ALT: () => this.SUBRULE(this.BooleanLiteral) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Constraint

Constraint: function = this.RULE('Constraint', () => {log('Constraint');this.OR([{ ALT: () => this.SUBRULE(this.BrackettedExpression) },{ ALT: () => this.SUBRULE(this.BuiltInCall) },{ ALT: () => this.SUBRULE(this.FunctionCall) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ConstructQuery

ConstructQuery: function = this.RULE('ConstructQuery', () => {this.CONSUME(sparqlTokenMap.CONSTRUCT);this.OR([{ALT: () => {this.SUBRULE(this.ConstructTemplate);this.MANY(() => this.SUBRULE(this.DatasetClause));this.SUBRULE(this.WhereClause);},},{ALT: () => {this.MANY1(() => this.SUBRULE1(this.DatasetClause));this.CONSUME(sparqlTokenMap.WHERE);this.CONSUME(sparqlTokenMap.LCurly);this.OPTION(() => this.SUBRULE(this.TriplesTemplate));this.CONSUME(sparqlTokenMap.RCurly);},},]);this.SUBRULE(this.SolutionModifier);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ConstructTemplate

ConstructTemplate: function = this.RULE('ConstructTemplate', () => {log('ConstructTemplate');this.CONSUME(sparqlTokenMap.LCurly);this.OPTION(() => this.SUBRULE(this.ConstructTriples));this.CONSUME(sparqlTokenMap.RCurly);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ConstructTriples

ConstructTriples: function = this.RULE('ConstructTriples', () => {log('ConstructTriples');this.SUBRULE(this.TriplesSameSubject);this.OPTION(() => {this.CONSUME(sparqlTokenMap.Period);this.OPTION1(() => this.SUBRULE(this.ConstructTriples));});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Copy

Copy: function = this.RULE('Copy', () => {log('Copy');this.CONSUME(sparqlTokenMap.COPY);this.OPTION(() => this.CONSUME(sparqlTokenMap.SILENT));this.SUBRULE(this.GraphOrDefault);this.CONSUME(sparqlTokenMap.TO);this.SUBRULE1(this.GraphOrDefault);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Count

Count: function = this.RULE('Count', () => {log('Count');this.CONSUME(sparqlTokenMap.COUNT);this.CONSUME1(sparqlTokenMap.LParen);this.OPTION(() => this.CONSUME2(sparqlTokenMap.DISTINCT));this.OR([{ ALT: () => this.CONSUME3(sparqlTokenMap.Star) },{ ALT: () => this.SUBRULE(this.Expression) },]);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Create

Create: function = this.RULE('Create', () => {log('Create');this.CONSUME(sparqlTokenMap.CREATE);this.OPTION(() => this.CONSUME(sparqlTokenMap.SILENT));this.SUBRULE(this.GraphRefAll);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

DataBlock

DataBlock: function = this.RULE('DataBlock', () => {log('DataBlock');this.OR([{ ALT: () => this.SUBRULE(this.InlineDataOneVar) },{ ALT: () => this.SUBRULE(this.InlineDataFull) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

DataBlockValue

DataBlockValue: function = this.RULE('DataBlockValue', () => {log('DataBlockValue');this.OR([{ ALT: () => this.SUBRULE(this.iri) },{ ALT: () => this.SUBRULE(this.RDFLiteral) },{ ALT: () => this.SUBRULE(this.NumericLiteral) },{ ALT: () => this.SUBRULE(this.BooleanLiteral) },{ ALT: () => this.CONSUME(sparqlTokenMap.UNDEF) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

DatasetClause

DatasetClause: function = this.RULE('DatasetClause', () => {log('DatasetClause');this.CONSUME(sparqlTokenMap.FROM);this.OR([{ ALT: () => this.SUBRULE(this.DefaultGraphClause) },{ ALT: () => this.SUBRULE(this.NamedGraphClause) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

DefaultGraphClause

DefaultGraphClause: function = this.RULE('DefaultGraphClause', () => {log('DefaultGraphClause');this.SUBRULE(this.SourceSelector);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

DeleteClause

DeleteClause: function = this.RULE('DeleteClause', () => {log('DeleteClause');this.CONSUME(sparqlTokenMap.DELETE);this.SUBRULE(this.QuadPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

DeleteData

DeleteData: function = this.RULE('DeleteData', () => {log('DeleteData');this.CONSUME(sparqlTokenMap.DELETE_DATA);this.SUBRULE(this.QuadData);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

DeleteWhere

DeleteWhere: function = this.RULE('DeleteWhere', () => {log('DeleteWhere');this.CONSUME(sparqlTokenMap.DELETE_WHERE);this.SUBRULE(this.QuadPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

DescribeQuery

DescribeQuery: function = this.RULE('DescribeQuery', () => {log('DescribeQuery');this.CONSUME(sparqlTokenMap.DESCRIBE);this.OR([{ALT: () => {this.AT_LEAST_ONE(() => this.SUBRULE(this.VarOrIri));},},{ ALT: () => this.CONSUME(sparqlTokenMap.Star) },]);this.MANY(() => this.SUBRULE(this.DatasetClause));this.OPTION(() => this.SUBRULE(this.WhereClause));this.SUBRULE(this.SolutionModifier);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Drop

Drop: function = this.RULE('Drop', () => {log('Drop');this.CONSUME(sparqlTokenMap.DROP);this.OPTION(() => this.CONSUME(sparqlTokenMap.SILENT));this.SUBRULE(this.GraphRefAll);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ExistsFunction

ExistsFunction: function = this.RULE('ExistsFunction', () => {log('ExistsFunction');this.CONSUME(sparqlTokenMap.EXISTS);this.SUBRULE(this.GroupGraphPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Expression

Expression: function = this.RULE('Expression', () => {log('Expression');this.SUBRULE(this.ConditionalOrExpression);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ExpressionList

ExpressionList: function = this.RULE('ExpressionList', () => {log('ExpressionList');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.NIL) },{ALT: () => {this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.MANY(() => {this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);});this.CONSUME(sparqlTokenMap.RParen);},},]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Filter

Filter: function = this.RULE('Filter', () => {log('Filter');this.CONSUME(sparqlTokenMap.FILTER);this.SUBRULE(this.Constraint);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

FunctionCall

FunctionCall: function = this.RULE('FunctionCall', () => {log('FunctionCall');this.SUBRULE(this.iri);this.SUBRULE(this.ArgList);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GraphGraphPattern

GraphGraphPattern: function = this.RULE('GraphGraphPattern', () => {log('GraphGraphPattern');this.CONSUME(sparqlTokenMap.GRAPH);this.SUBRULE(this.VarOrIri);this.SUBRULE(this.GroupGraphPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GraphNode

GraphNode: function = this.RULE('GraphNode', () => {log('GraphNode');this.OR([{ ALT: () => this.SUBRULE(this.VarOrTerm) },{ ALT: () => this.SUBRULE(this.TriplesNode) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GraphNodePath

GraphNodePath: function = this.RULE('GraphNodePath', () => {log('GraphNodePath');this.OR([{ ALT: () => this.SUBRULE(this.VarOrTerm) },{ ALT: () => this.SUBRULE(this.TriplesNodePath) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GraphOrDefault

GraphOrDefault: function = this.RULE('GraphOrDefault', () => {log('GraphOrDefault');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.DEFAULT) },{ALT: () => {this.OPTION(() => this.CONSUME(sparqlTokenMap.GRAPH));this.SUBRULE(this.iri);},},]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GraphPatternNotTriples

GraphPatternNotTriples: function = this.RULE('GraphPatternNotTriples', () => {log('GraphPatternNotTriples');this.OR([{ ALT: () => this.SUBRULE(this.GroupOrUnionGraphPattern) },{ ALT: () => this.SUBRULE(this.OptionalGraphPattern) },{ ALT: () => this.SUBRULE(this.MinusGraphPattern) },{ ALT: () => this.SUBRULE(this.GraphGraphPattern) },{ ALT: () => this.SUBRULE(this.ServiceGraphPattern) },{ ALT: () => this.SUBRULE(this.Filter) },{ ALT: () => this.SUBRULE(this.Bind) },{ ALT: () => this.SUBRULE(this.InlineData) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GraphRef

GraphRef: function = this.RULE('GraphRef', () => {log('GraphRef');this.CONSUME(sparqlTokenMap.GRAPH);this.SUBRULE(this.iri);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GraphRefAll

GraphRefAll: function = this.RULE('GraphRefAll', () => {log('GraphRefAll');this.OR([{ ALT: () => this.SUBRULE(this.GraphRef) },{ ALT: () => this.CONSUME(sparqlTokenMap.DEFAULT) },{ ALT: () => this.CONSUME(sparqlTokenMap.NAMED) },{ ALT: () => this.CONSUME(sparqlTokenMap.ALL) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GraphTerm

GraphTerm: function = this.RULE('GraphTerm', () => {log('GraphTerm');this.OR([{ ALT: () => this.SUBRULE(this.iri) },{ ALT: () => this.SUBRULE(this.RDFLiteral) },{ ALT: () => this.SUBRULE(this.NumericLiteral) },{ ALT: () => this.SUBRULE(this.BooleanLiteral) },{ ALT: () => this.SUBRULE(this.BlankNode) },{ ALT: () => this.CONSUME(sparqlTokenMap.NIL) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GroupClause

GroupClause: function = this.RULE('GroupClause', () => {log('GroupClause');this.CONSUME(sparqlTokenMap.GROUP_BY);this.AT_LEAST_ONE(() => this.SUBRULE(this.GroupCondition));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GroupConcat

GroupConcat: function = this.RULE('GroupConcat', () => {log('GroupConcat');this.CONSUME(sparqlTokenMap.GROUP_CONCAT);this.CONSUME1(sparqlTokenMap.LParen);this.OPTION(() => this.CONSUME2(sparqlTokenMap.DISTINCT));this.SUBRULE(this.Expression);this.OPTION1(() => {this.CONSUME(sparqlTokenMap.Semicolon);this.CONSUME(sparqlTokenMap.SEPARATOR);this.CONSUME(sparqlTokenMap.Equals);this.SUBRULE(this.String);});this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GroupCondition

GroupCondition: function = this.RULE('GroupCondition', () => {log('GroupCondition');this.OR([{ ALT: () => this.SUBRULE(this.BuiltInCall) },{ ALT: () => this.SUBRULE(this.FunctionCall) },{ALT: () => {this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.OPTION(() => {this.CONSUME(sparqlTokenMap.AS);this.SUBRULE(this.Var);});this.CONSUME(sparqlTokenMap.RParen);},},{ ALT: () => this.SUBRULE1(this.Var) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GroupGraphPattern

GroupGraphPattern: function = this.RULE('GroupGraphPattern', () => {log('GroupGraphPattern');this.CONSUME(sparqlTokenMap.LCurly);this.OR([{ ALT: () => this.SUBRULE(this.SubSelect) },{ ALT: () => this.SUBRULE(this.GroupGraphPatternSub) },]);this.CONSUME(sparqlTokenMap.RCurly);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GroupGraphPatternSub

GroupGraphPatternSub: function = this.RULE('GroupGraphPatternSub', () => {log('GroupGraphPatternSub');this.OPTION(() => this.SUBRULE(this.TriplesBlock));this.MANY(() => {this.SUBRULE(this.GraphPatternNotTriples);this.OPTION1(() => this.CONSUME(sparqlTokenMap.Period));this.OPTION2(() => this.SUBRULE1(this.TriplesBlock));});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

GroupOrUnionGraphPattern

GroupOrUnionGraphPattern: function = this.RULE('GroupOrUnionGraphPattern', () => {log('GroupOrUnionGraphPattern');this.SUBRULE(this.GroupGraphPattern);this.MANY(() => {this.CONSUME(sparqlTokenMap.UNION);this.SUBRULE1(this.GroupGraphPattern);});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

HavingClause

HavingClause: function = this.RULE('HavingClause', () => {log('HavingClause');this.CONSUME(sparqlTokenMap.HAVING);this.SUBRULE(this.HavingCondition);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

HavingCondition

HavingCondition: function = this.RULE('HavingCondition', () => {log('HavingCondition');this.SUBRULE(this.Constraint);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

InlineData

InlineData: function = this.RULE('InlineData', () => {log('InlineData');this.CONSUME(sparqlTokenMap.VALUES);this.SUBRULE(this.DataBlock);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

InlineDataFull

InlineDataFull: function = this.RULE('InlineDataFull', () => {log('InlineDataFull');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.NIL) },{ALT: () => {this.CONSUME(sparqlTokenMap.LParen);this.MANY(() => this.SUBRULE(this.Var));this.CONSUME(sparqlTokenMap.RParen);},},]);this.CONSUME(sparqlTokenMap.LCurly);this.MANY1(() =>this.OR1([{ALT: () => {this.CONSUME1(sparqlTokenMap.LParen);this.MANY2(() => this.SUBRULE(this.DataBlockValue));this.CONSUME1(sparqlTokenMap.RParen);},},{ ALT: () => this.CONSUME1(sparqlTokenMap.NIL) },]));this.CONSUME(sparqlTokenMap.RCurly);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

InlineDataOneVar

InlineDataOneVar: function = this.RULE('InlineDataOneVar', () => {log('InlineDataOneVar');this.SUBRULE(this.Var);this.CONSUME(sparqlTokenMap.LCurly);this.MANY(() => this.SUBRULE(this.DataBlockValue));this.CONSUME(sparqlTokenMap.RCurly);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

InsertClause

InsertClause: function = this.RULE('InsertClause', () => {log('InsertClause');this.CONSUME(sparqlTokenMap.INSERT);this.SUBRULE(this.QuadPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

InsertData

InsertData: function = this.RULE('InsertData', () => {log('InsertData');this.CONSUME(sparqlTokenMap.INSERT_DATA);this.SUBRULE(this.QuadData);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Integer

Integer: function = this.RULE('Integer', () => {log('Integer');this.CONSUME(sparqlTokenMap.INTEGER);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

LimitClause

LimitClause: function = this.RULE('LimitClause', () => {log('LimitClause');this.CONSUME(sparqlTokenMap.LIMIT);this.CONSUME(sparqlTokenMap.INTEGER);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

LimitOffsetClause

LimitOffsetClause: function = this.RULE('LimitOffsetClause', () => {log('LimitOffsetClause');this.OR([{ALT: () => {this.SUBRULE(this.LimitClause);this.OPTION(() => this.SUBRULE(this.OffsetClause));},},{ALT: () => {this.SUBRULE1(this.OffsetClause);this.OPTION1(() => this.SUBRULE1(this.LimitClause));},},]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Load

Load: function = this.RULE('Load', () => {log('Load');this.CONSUME(sparqlTokenMap.LOAD);this.OPTION(() => this.CONSUME(sparqlTokenMap.SILENT));this.SUBRULE(this.iri);this.OPTION1(() => {this.CONSUME(sparqlTokenMap.INTO);this.SUBRULE(this.GraphRef);});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Max

Max: function = this.RULE('Max', () => {log('Max');this.CONSUME(sparqlTokenMap.MAX);this.CONSUME1(sparqlTokenMap.LParen);this.OPTION(() => this.CONSUME2(sparqlTokenMap.DISTINCT));this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

MaxLength

MaxLength: function = this.RULE('MaxLength', () => {this.CONSUME(sparqlTokenMap.MAX_LENGTH);this.CONSUME(sparqlTokenMap.INTEGER);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Min

Min: function = this.RULE('Min', () => {log('Min');this.CONSUME(sparqlTokenMap.MIN);this.CONSUME1(sparqlTokenMap.LParen);this.OPTION(() => this.CONSUME2(sparqlTokenMap.DISTINCT));this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

MinusGraphPattern

MinusGraphPattern: function = this.RULE('MinusGraphPattern', () => {log('MinusGraphPattern');this.CONSUME(sparqlTokenMap.MINUS);this.SUBRULE(this.GroupGraphPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Modify

Modify: function = this.RULE('Modify', () => {log('Modify');this.OPTION(() => {this.CONSUME(sparqlTokenMap.WITH);this.SUBRULE(this.iri);});this.OR([{ALT: () => {this.SUBRULE(this.DeleteClause);this.OPTION1(() => this.SUBRULE(this.InsertClause));},},{ ALT: () => this.SUBRULE1(this.InsertClause) },]);this.MANY(() => this.SUBRULE(this.UsingClause));this.CONSUME(sparqlTokenMap.WHERE);this.SUBRULE(this.GroupGraphPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Move

Move: function = this.RULE('Move', () => {log('Move');this.CONSUME(sparqlTokenMap.MOVE);this.OPTION(() => this.CONSUME(sparqlTokenMap.SILENT));this.SUBRULE(this.GraphOrDefault);this.CONSUME(sparqlTokenMap.TO);this.SUBRULE1(this.GraphOrDefault);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

MultiplicativeExpression

MultiplicativeExpression: function = this.RULE('MultiplicativeExpression', () => {log('MultiplicativeExpression');this.SUBRULE(this.UnaryExpression);this.MANY(() =>this.OR([{ALT: () => {this.CONSUME(sparqlTokenMap.Star);this.SUBRULE1(this.UnaryExpression);},},{ALT: () => {this.CONSUME(sparqlTokenMap.ForwardSlash);this.SUBRULE2(this.UnaryExpression);},},]));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

NamedGraphClause

NamedGraphClause: function = this.RULE('NamedGraphClause', () => {log('NamedGraphClause');this.CONSUME(sparqlTokenMap.NAMED);this.SUBRULE(this.SourceSelector);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

NotExistsFunction

NotExistsFunction: function = this.RULE('NotExistsFunction', () => {log('NotExistsFunction');this.CONSUME(sparqlTokenMap.NOT_EXISTS);this.SUBRULE(this.GroupGraphPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

NumericExpression

NumericExpression: function = this.RULE('NumericExpression', () => {log('NumericExpression');this.SUBRULE(this.AdditiveExpression);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

NumericLiteral

NumericLiteral: function = this.RULE('NumericLiteral', () => {log('NumericLiteral');this.OR([{ ALT: () => this.SUBRULE(this.NumericLiteralUnsigned) },{ ALT: () => this.SUBRULE(this.NumericLiteralPositive) },{ ALT: () => this.SUBRULE(this.NumericLiteralNegative) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

NumericLiteralNegative

NumericLiteralNegative: function = this.RULE('NumericLiteralNegative', () => {log('NumericLiteralNegative');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.INTEGER_NEGATIVE) },{ ALT: () => this.CONSUME(sparqlTokenMap.DECIMAL_NEGATIVE) },{ ALT: () => this.CONSUME(sparqlTokenMap.DOUBLE_NEGATIVE) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

NumericLiteralPositive

NumericLiteralPositive: function = this.RULE('NumericLiteralPositive', () => {log('NumericLiteralPositive');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.INTEGER_POSITIVE) },{ ALT: () => this.CONSUME(sparqlTokenMap.DECIMAL_POSITIVE) },{ ALT: () => this.CONSUME(sparqlTokenMap.DOUBLE_POSITIVE) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

NumericLiteralUnsigned

NumericLiteralUnsigned: function = this.RULE('NumericLiteralUnsigned', () => {log('NumericLiteralUnsigned');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.INTEGER) },{ ALT: () => this.CONSUME(sparqlTokenMap.DECIMAL) },{ ALT: () => this.CONSUME(sparqlTokenMap.DOUBLE) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Object

Object: function = this.RULE('Object', () => {log('Object');this.SUBRULE(this.GraphNode);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ObjectList

ObjectList: function = this.RULE('ObjectList', () => {log('ObjectList');this.AT_LEAST_ONE_SEP({SEP: sparqlTokenMap.Comma,DEF: () => this.SUBRULE(this.Object),});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ObjectListPath

ObjectListPath: function = this.RULE('ObjectListPath', () => {log('ObjectListPath');this.AT_LEAST_ONE_SEP({SEP: sparqlTokenMap.Comma,DEF: () => this.SUBRULE(this.ObjectPath),});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ObjectPath

ObjectPath: function = this.RULE('ObjectPath', () => {log('ObjectPath');this.SUBRULE(this.GraphNodePath);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

OffsetClause

OffsetClause: function = this.RULE('OffsetClause', () => {log('OffsetClause');this.CONSUME(sparqlTokenMap.OFFSET);this.CONSUME(sparqlTokenMap.INTEGER);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

OptionalGraphPattern

OptionalGraphPattern: function = this.RULE('OptionalGraphPattern', () => {log('OptionalGraphPattern');this.CONSUME(sparqlTokenMap.OPTIONAL);this.SUBRULE(this.GroupGraphPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

OrderClause

OrderClause: function = this.RULE('OrderClause', () => {log('OrderClause');this.CONSUME(sparqlTokenMap.ORDER_BY);this.AT_LEAST_ONE(() => this.SUBRULE(this.OrderCondition));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

OrderCondition

OrderCondition: function = this.RULE('OrderCondition', () => {log('OrderCondition');this.OR([{ALT: () => {this.OR1([{ ALT: () => this.CONSUME(sparqlTokenMap.ASC) },{ ALT: () => this.CONSUME(sparqlTokenMap.DESC) },]);this.SUBRULE(this.BrackettedExpression);},},{ ALT: () => this.SUBRULE(this.Constraint) },{ ALT: () => this.SUBRULE(this.Var) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Path

Path: function = this.RULE('Path', () => {log('Path');this.SUBRULE(this.PathAlternative);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PathAlternative

PathAlternative: function = this.RULE('PathAlternative', () => {log('PathAlternative');this.AT_LEAST_ONE_SEP({SEP: sparqlTokenMap.Pipe,DEF: () => this.SUBRULE(this.PathSequence),});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PathElt

PathElt: function = this.RULE('PathElt', () => {log('PathElt');this.SUBRULE(this.PathPrimary);this.OPTION(() => this.SUBRULE(this.PathMod));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PathEltOrInverse

PathEltOrInverse: function = this.RULE('PathEltOrInverse', () => {log('PathEltOrInverse');this.OPTION(() => this.CONSUME(sparqlTokenMap.Caret));this.SUBRULE(this.PathElt);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PathMod

PathMod: function = this.RULE('PathMod', () => {log('PathMod');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.QuestionMark) },{ ALT: () => this.CONSUME(sparqlTokenMap.Star) },{ ALT: () => this.CONSUME(sparqlTokenMap.Plus) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PathNegatedPropertySet

PathNegatedPropertySet: function = this.RULE('PathNegatedPropertySet', () => {log('PathNegatedPropertySet');this.OR([{ ALT: () => this.SUBRULE(this.PathOneInPropertySet) },{ALT: () => {this.CONSUME(sparqlTokenMap.LParen);this.MANY_SEP({SEP: sparqlTokenMap.Pipe,DEF: () => this.SUBRULE1(this.PathOneInPropertySet),});this.CONSUME(sparqlTokenMap.RParen);},},]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PathOneInPropertySet

PathOneInPropertySet: function = this.RULE('PathOneInPropertySet', () => {log('PathOneInPropertySet');this.OPTION(() => this.CONSUME(sparqlTokenMap.Caret));this.OR([{ ALT: () => this.SUBRULE(this.iri) },{ ALT: () => this.CONSUME(sparqlTokenMap.A) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PathPrimary

PathPrimary: function = this.RULE('PathPrimary', () => {log('PathPrimary');this.OR([{ ALT: () => this.SUBRULE(this.iri) },{ ALT: () => this.CONSUME(sparqlTokenMap.A) },{ALT: () => {this.CONSUME(sparqlTokenMap.Bang);this.SUBRULE(this.PathNegatedPropertySet);},},{ALT: () => {this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Path);this.CONSUME(sparqlTokenMap.RParen);},},]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PathSequence

PathSequence: function = this.RULE('PathSequence', () => {log('PathSequence');this.AT_LEAST_ONE_SEP({SEP: sparqlTokenMap.ForwardSlash,DEF: () => this.SUBRULE(this.PathEltOrInverse),});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PrefixDecl

PrefixDecl: function = this.RULE('PrefixDecl', () => {log('PrefixDecl');this.CONSUME(sparqlTokenMap.PREFIX);this.CONSUME(sparqlTokenMap.PNAME_NS);this.CONSUME(sparqlTokenMap.IRIREF);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PrefixedName

PrefixedName: function = this.RULE('PrefixedName', () => {log('PrefixedName');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.PNAME_LN) },{ ALT: () => this.CONSUME(sparqlTokenMap.PNAME_NS) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PrimaryExpression

PrimaryExpression: function = this.RULE('PrimaryExpression', () => {log('PrimaryExpression');this.OR([{ ALT: () => this.SUBRULE(this.BrackettedExpression) },{ ALT: () => this.SUBRULE(this.BuiltInCall) },{ ALT: () => this.SUBRULE(this.iriOrFunction) },{ ALT: () => this.SUBRULE(this.RDFLiteral) },{ ALT: () => this.SUBRULE(this.NumericLiteral) },{ ALT: () => this.SUBRULE(this.BooleanLiteral) },{ ALT: () => this.SUBRULE(this.Var) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Prologue

Prologue: function = this.RULE('Prologue', () => {log('Prologue');this.AT_LEAST_ONE(() =>this.OR([{ ALT: () => this.SUBRULE(this.BaseDecl) },{ ALT: () => this.SUBRULE(this.PrefixDecl) },]));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PropertyList

PropertyList: function = this.RULE('PropertyList', () => {log('PropertyList');this.OPTION(() => this.SUBRULE(this.PropertyListNotEmpty));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PropertyListNotEmpty

PropertyListNotEmpty: function = this.RULE('PropertyListNotEmpty', () => {log('PropertyListNotEmpty');this.SUBRULE(this.Verb);this.SUBRULE(this.ObjectList);this.MANY(() => {this.CONSUME(sparqlTokenMap.Semicolon);this.OPTION(() => {this.SUBRULE1(this.Verb);this.SUBRULE1(this.ObjectList);});});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PropertyListPath

PropertyListPath: function = this.RULE('PropertyListPath', () => {log('PropertyListPath');this.OPTION(() => this.SUBRULE(this.PropertyListPathNotEmpty));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

PropertyListPathNotEmpty

PropertyListPathNotEmpty: function = this.RULE('PropertyListPathNotEmpty', () => {log('PropertyListPathNotEmpty');this.OR([{ ALT: () => this.SUBRULE(this.VerbPath) },{ ALT: () => this.SUBRULE(this.VerbSimple) },]);this.SUBRULE(this.ObjectListPath);this.MANY(() => {this.CONSUME(sparqlTokenMap.Semicolon);this.OPTION(() => {this.OR1([{ ALT: () => this.SUBRULE1(this.VerbPath) },{ ALT: () => this.SUBRULE1(this.VerbSimple) },]);this.SUBRULE1(this.ObjectListPath);});});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

QuadData

QuadData: function = this.RULE('QuadData', () => {log('QuadData');this.CONSUME(sparqlTokenMap.LCurly);this.SUBRULE(this.Quads);this.CONSUME(sparqlTokenMap.RCurly);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

QuadPattern

QuadPattern: function = this.RULE('QuadPattern', () => {log('QuadPattern');this.CONSUME(sparqlTokenMap.LCurly);this.SUBRULE(this.Quads);this.CONSUME(sparqlTokenMap.RCurly);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Quads

Quads: function = this.RULE('Quads', () => {log('Quads');this.OPTION(() => this.SUBRULE(this.TriplesTemplate));this.MANY(() => {this.SUBRULE(this.QuadsNotTriples);this.OPTION1(() => this.CONSUME(sparqlTokenMap.Period));this.OPTION2(() => this.SUBRULE1(this.TriplesTemplate));});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

QuadsNotTriples

QuadsNotTriples: function = this.RULE('QuadsNotTriples', () => {log('QuadsNotTriples');this.CONSUME(sparqlTokenMap.GRAPH);this.SUBRULE(this.VarOrIri);this.CONSUME(sparqlTokenMap.LCurly);this.OPTION(() => this.SUBRULE(this.TriplesTemplate));this.CONSUME(sparqlTokenMap.RCurly);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Query

Query: function = this.RULE('Query', () => {log('Query');this.OR([{ ALT: () => this.SUBRULE(this.SelectQuery) },{ ALT: () => this.SUBRULE(this.ConstructQuery) },{ ALT: () => this.SUBRULE(this.DescribeQuery) },{ ALT: () => this.SUBRULE(this.AskQuery) },]);this.SUBRULE(this.ValuesClause);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

QueryUnit

QueryUnit: function = this.RULE('QueryUnit', () => {log('QueryUnit');this.SUBRULE(this.Query);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

RDFLiteral

RDFLiteral: function = this.RULE('RDFLiteral', () => {log('RDFLiteral');this.SUBRULE(this.String);this.OPTION(() =>this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.LANGTAG) },{ALT: () => {this.CONSUME(sparqlTokenMap.DoubleCaret);this.SUBRULE(this.iri);},},]));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

RegexExpression

RegexExpression: function = this.RULE('RegexExpression', () => {log('RegexExpression');this.CONSUME(sparqlTokenMap.REGEX);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.OPTION(() => {this.CONSUME1(sparqlTokenMap.Comma);this.SUBRULE2(this.Expression);});this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

RelationalExpression

RelationalExpression: function = this.RULE('RelationalExpression', () => {log('RelationalExpression');this.SUBRULE(this.NumericExpression);this.OPTION(() =>this.OR([{ALT: () => {this.OR1([{ ALT: () => this.CONSUME(sparqlTokenMap.Equals) },{ ALT: () => this.CONSUME(sparqlTokenMap.NotEquals) },{ ALT: () => this.CONSUME(sparqlTokenMap.LessThan) },{ ALT: () => this.CONSUME(sparqlTokenMap.GreaterThan) },{ ALT: () => this.CONSUME(sparqlTokenMap.LessThanEquals) },{ ALT: () => this.CONSUME(sparqlTokenMap.GreaterThanEquals) },]);this.SUBRULE1(this.NumericExpression);},},{ALT: () => {this.CONSUME(sparqlTokenMap.IN);this.SUBRULE(this.ExpressionList);},},{ALT: () => {this.CONSUME(sparqlTokenMap.NOT_IN);this.SUBRULE1(this.ExpressionList);},},]));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Sample

Sample: function = this.RULE('Sample', () => {log('Sample');this.CONSUME(sparqlTokenMap.SAMPLE);this.CONSUME1(sparqlTokenMap.LParen);this.OPTION(() => this.CONSUME2(sparqlTokenMap.DISTINCT));this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

SelectClause

SelectClause: function = this.RULE('SelectClause', () => {log('SelectClause');this.CONSUME(sparqlTokenMap.SELECT);this.OPTION(() =>this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.DISTINCT) },{ ALT: () => this.CONSUME(sparqlTokenMap.REDUCED) },]));this.OR1([{ALT: () => {this.AT_LEAST_ONE(() =>this.OR2([{ ALT: () => this.SUBRULE(this.Var) },{ALT: () => {this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.AS);this.SUBRULE1(this.Var);this.CONSUME(sparqlTokenMap.RParen);},},]));},},{ ALT: () => this.CONSUME(sparqlTokenMap.Star) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

SelectQuery

SelectQuery: function = this.RULE('SelectQuery', () => {log('SelectQuery');this.SUBRULE(this.SelectClause);this.MANY(() => this.SUBRULE(this.DatasetClause));this.SUBRULE(this.WhereClause);this.SUBRULE(this.SolutionModifier);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ServiceGraphPattern

ServiceGraphPattern: function = this.RULE('ServiceGraphPattern', () => {log('ServiceGraphPattern');this.CONSUME(sparqlTokenMap.SERVICE);this.OPTION(() => this.CONSUME(sparqlTokenMap.SILENT));this.SUBRULE(this.VarOrIri);this.SUBRULE(this.GroupGraphPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

SolutionModifier

SolutionModifier: function = this.RULE('SolutionModifier', () => {log('SolutionModifier');this.OPTION(() => this.SUBRULE(this.GroupClause));this.OPTION1(() => this.SUBRULE(this.HavingClause));this.OPTION2(() => this.SUBRULE(this.OrderClause));this.OPTION3(() => this.SUBRULE(this.LimitOffsetClause));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

SourceSelector

SourceSelector: function = this.RULE('SourceSelector', () => {log('SourceSelector');this.SUBRULE(this.iri);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

SparqlDoc

SparqlDoc: function = this.RULE('SparqlDoc', () => {log('SparqlDoc');this.MANY(() =>this.OR([{ ALT: () => this.SUBRULE(this.Prologue) },{ ALT: () => this.SUBRULE(this.QueryUnit) },{ ALT: () => this.SUBRULE(this.UpdateUnit) },]));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

StrReplaceExpression

StrReplaceExpression: function = this.RULE('StrReplaceExpression', () => {log('StrReplaceExpression');this.CONSUME(sparqlTokenMap.REPLACE);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.CONSUME1(sparqlTokenMap.Comma);this.SUBRULE2(this.Expression);this.OPTION(() => {this.CONSUME2(sparqlTokenMap.Comma);this.SUBRULE3(this.Expression);});this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

String

String: function = this.RULE('String', () => {log('String');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.STRING_LITERAL1) },{ ALT: () => this.CONSUME(sparqlTokenMap.STRING_LITERAL2) },{ ALT: () => this.CONSUME(sparqlTokenMap.STRING_LITERAL_LONG1) },{ ALT: () => this.CONSUME(sparqlTokenMap.STRING_LITERAL_LONG2) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

SubSelect

SubSelect: function = this.RULE('SubSelect', () => {log('SubSelect');this.SUBRULE(this.SelectClause);this.SUBRULE(this.WhereClause);this.SUBRULE(this.SolutionModifier);this.SUBRULE(this.ValuesClause);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

SubstringExpression

SubstringExpression: function = this.RULE('SubstringExpression', () => {log('SubstringExpression');this.CONSUME(sparqlTokenMap.SUBSTR);this.CONSUME(sparqlTokenMap.LParen);this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.Comma);this.SUBRULE1(this.Expression);this.OPTION(() => {this.CONSUME1(sparqlTokenMap.Comma);this.SUBRULE2(this.Expression);});this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Sum

Sum: function = this.RULE('Sum', () => {log('Sum');this.CONSUME(sparqlTokenMap.SUM);this.CONSUME1(sparqlTokenMap.LParen);this.OPTION(() => this.CONSUME2(sparqlTokenMap.DISTINCT));this.SUBRULE(this.Expression);this.CONSUME(sparqlTokenMap.RParen);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

TriplesBlock

TriplesBlock: function = this.RULE('TriplesBlock', () => {log('TriplesBlock');this.SUBRULE(this.TriplesSameSubjectPath);this.OPTION(() => {this.CONSUME(sparqlTokenMap.Period);this.OPTION1(() => this.SUBRULE(this.TriplesBlock));});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

TriplesNode

TriplesNode: function = this.RULE('TriplesNode', () => {log('TriplesNode');this.OR([{ ALT: () => this.SUBRULE(this.Collection) },{ ALT: () => this.SUBRULE(this.BlankNodePropertyList) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

TriplesNodePath

TriplesNodePath: function = this.RULE('TriplesNodePath', () => {log('TriplesNodePath');this.OR([{ ALT: () => this.SUBRULE(this.CollectionPath) },{ ALT: () => this.SUBRULE(this.BlankNodePropertyListPath) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

TriplesSameSubject

TriplesSameSubject: function = this.RULE('TriplesSameSubject', () => {log('TriplesSameSubject');this.OR([{ALT: () => {this.SUBRULE(this.VarOrTerm);this.SUBRULE(this.PropertyListNotEmpty);},},{ALT: () => {this.SUBRULE(this.TriplesNode);this.SUBRULE(this.PropertyList);},},]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

TriplesSameSubjectPath

TriplesSameSubjectPath: function = this.RULE('TriplesSameSubjectPath', () => {log('TriplesSameSubjectPath');this.OR([{ALT: () => {this.SUBRULE(this.VarOrTerm);this.SUBRULE(this.PropertyListPathNotEmpty);},},{ALT: () => {this.SUBRULE(this.TriplesNodePath);this.SUBRULE(this.PropertyListPath);},},]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

TriplesTemplate

TriplesTemplate: function = this.RULE('TriplesTemplate', () => {log('TriplesTemplate');this.SUBRULE(this.TriplesSameSubject);this.OPTION(() => {this.CONSUME(sparqlTokenMap.Period);this.OPTION1(() => this.SUBRULE(this.TriplesTemplate));});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

UnaryExpression

UnaryExpression: function = this.RULE('UnaryExpression', () => {log('UnaryExpression');this.OR([{ALT: () => {this.CONSUME(sparqlTokenMap.Bang);this.SUBRULE(this.PrimaryExpression);},},{ALT: () => {this.CONSUME(sparqlTokenMap.Plus);this.SUBRULE1(this.PrimaryExpression);},},{ALT: () => {this.CONSUME(sparqlTokenMap.Minus);this.SUBRULE2(this.PrimaryExpression);},},{ ALT: () => this.SUBRULE3(this.PrimaryExpression) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Update

Update: function = this.RULE('Update', () => {log('Update');this.SUBRULE(this.Update1);this.OPTION(() => {this.CONSUME(sparqlTokenMap.Semicolon);this.SUBRULE(this.Update);});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Update1

Update1: function = this.RULE('Update1', () => {log('Update1');this.OR([{ ALT: () => this.SUBRULE(this.Load) },{ ALT: () => this.SUBRULE(this.Clear) },{ ALT: () => this.SUBRULE(this.Drop) },{ ALT: () => this.SUBRULE(this.Add) },{ ALT: () => this.SUBRULE(this.Move) },{ ALT: () => this.SUBRULE(this.Copy) },{ ALT: () => this.SUBRULE(this.Create) },{ ALT: () => this.SUBRULE(this.InsertData) },{ ALT: () => this.SUBRULE(this.DeleteData) },{ ALT: () => this.SUBRULE(this.DeleteWhere) },{ ALT: () => this.SUBRULE(this.Modify) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

UpdateUnit

UpdateUnit: function = this.RULE('UpdateUnit', () => {log('UpdateUnit');this.SUBRULE(this.Update);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

UsingClause

UsingClause: function = this.RULE('UsingClause', () => {log('UsingClause');this.CONSUME(sparqlTokenMap.USING);this.OR([{ ALT: () => this.SUBRULE(this.iri) },{ALT: () => {this.CONSUME(sparqlTokenMap.NAMED);this.SUBRULE1(this.iri);},},]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ValueLogical

ValueLogical: function = this.RULE('ValueLogical', () => {log('ValueLogical');this.SUBRULE(this.RelationalExpression);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

ValuesClause

ValuesClause: function = this.RULE('ValuesClause', () => {log('ValuesClause');this.OPTION(() => {this.CONSUME(sparqlTokenMap.VALUES);this.SUBRULE(this.DataBlock);});})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Var

Var: function = this.RULE('Var', () => {log('Var');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.VAR1) },{ ALT: () => this.CONSUME(sparqlTokenMap.VAR2) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

VarOrIri

VarOrIri: function = this.RULE('VarOrIri', () => {log('VarOrIri');this.OR([{ ALT: () => this.SUBRULE(this.Var) },{ ALT: () => this.SUBRULE(this.iri) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

VarOrTerm

VarOrTerm: function = this.RULE('VarOrTerm', () => {log('VarOrTerm');this.OR([{ ALT: () => this.SUBRULE(this.Var) },{ ALT: () => this.SUBRULE(this.GraphTerm) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Verb

Verb: function = this.RULE('Verb', () => {log('Verb');this.OR([{ ALT: () => this.SUBRULE(this.VarOrIri) },{ ALT: () => this.CONSUME(sparqlTokenMap.A) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

VerbPath

VerbPath: function = this.RULE('VerbPath', () => {log('VerbPath');this.SUBRULE(this.Path);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

VerbSimple

VerbSimple: function = this.RULE('VerbSimple', () => {log('VerbSimple');this.SUBRULE(this.Var);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

WhereClause

WhereClause: function = this.RULE('WhereClause', () => {log('WhereClause');this.OPTION(() => this.CONSUME(sparqlTokenMap.WHERE));this.SUBRULE(this.GroupGraphPattern);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

errors

errors: IRecognitionException[]

input

input: IToken[]

iri

iri: function = this.RULE('iri', () => {log('iri');this.OR([{ ALT: () => this.CONSUME(sparqlTokenMap.IRIREF) },{ ALT: () => this.SUBRULE(this.PrefixedName) },]);})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

iriOrFunction

iriOrFunction: function = this.RULE('iriOrFunction', () => {log('iriOrFunction');this.SUBRULE(this.iri);this.OPTION(() => this.SUBRULE(this.ArgList));})

Type declaration

- (idxInCallingRule?: number, ...args: any[]): T | any
- Parameters
  - Optional idxInCallingRule: number
  - Rest ...args: any[]
  Returns T | any

Methods

Protected AT_LEAST_ONE

AT_LEAST_ONE(actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>): void

Inherited from BaseParser.AT_LEAST_ONE
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:616
Convenience method, same as MANY but the repetition is of one or more. failing to match at least one repetition will result in a parsing error and cause a parsing error.

see

MANY

Parameters
- actionORMethodDef: GrammarAction<any> | DSLMethodOptsWithErr<any>
  
  The grammar action to optionally invoke multiple times or an "OPTIONS" object describing the grammar action and optional properties.
Returns void

Protected AT_LEAST_ONE_SEP

AT_LEAST_ONE_SEP(options: AtLeastOneSepMethodOpts<any>): void

Inherited from BaseParser.AT_LEAST_ONE_SEP
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:705
Convenience method, same as MANY_SEP but the repetition is of one or more. failing to match at least one repetition will result in a parsing error and cause the parser to attempt error recovery.

Note that an additional optional property ERR_MSG can be used to provide custom error messages.

see

MANY_SEP

Parameters
- options: AtLeastOneSepMethodOpts<any>
  
  An object defining the grammar of each iteration and the separator between iterations
Returns void

Protected BACKTRACK

BACKTRACK<T>(grammarRule: function, args?: any[]): function

Inherited from BaseParser.BACKTRACK
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:63
Type parameters
- T
Parameters
- grammarRule: function
  
  The rule to try and parse in backtracking mode.
  - - (...args: any[]): T
    - Parameters
      - Rest ...args: any[]
      Returns T
- Optional args: any[]
  
  argumens to be passed to the grammar rule execution
Returns function

a lookahead function that will try to parse the given grammarRule and will return true if succeed.
- - (): boolean
  - Returns boolean

Protected CONSUME

CONSUME(tokType: TokenType, options?: ConsumeMethodOpts): IToken

Inherited from BaseParser.CONSUME
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:99
A Parsing DSL method use to consume a single Token. In EBNF terms this is equivalent to a Terminal.

A Token will be consumed, IFF the next token in the token vector matches . otherwise the parser may attempt to perform error recovery (if enabled).

The index in the method name indicates the unique occurrence of a terminal consumption inside a the top level rule. What this means is that if a terminal appears more than once in a single rule, each appearance must have a different index.

For example:
```
  this.RULE("qualifiedName", () => {
  this.CONSUME1(Identifier);
    this.MANY(() => {
      this.CONSUME1(Dot);
      // here we use CONSUME2 because the terminal
      // 'Identifier' has already appeared previously in the
      // the rule 'parseQualifiedName'
      this.CONSUME2(Identifier);
    });
  })
```
- See more details on the unique suffixes requirement.
Parameters
- tokType: TokenType
  
  The Type of the token to be consumed.
- Optional options: ConsumeMethodOpts
  
  optional properties to modify the behavior of CONSUME.
Returns IToken

Protected LA

LA(howMuch: number): IToken

Inherited from BaseParser.LA
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:810
Parameters
- howMuch: number
Returns IToken

Protected MANY

MANY(actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>): void

Inherited from BaseParser.MANY
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:442
Parsing DSL method, that indicates a repetition of zero or more. This is equivalent to EBNF repetition {...}.

Note that there are two syntax forms:
- Passing the grammar action directly:
```
  this.MANY(() => {
    this.CONSUME(Comma)
    this.CONSUME(Digit)
   })
```
- using an "options" object:
```
  this.MANY({
    GATE: predicateFunc,
    DEF: () => {
           this.CONSUME(Comma)
           this.CONSUME(Digit)
         }
  });
```
The optional 'GATE' property in "options" object form can be used to add constraints to invoking the grammar action.

As in CONSUME the index in the method name indicates the occurrence of the repetition production in it's top rule.
Parameters
- actionORMethodDef: GrammarAction<any> | DSLMethodOpts<any>
  
  The grammar action to optionally invoke multiple times or an "OPTIONS" object describing the grammar action and optional properties.
Returns void

Protected MANY_SEP

MANY_SEP(options: ManySepMethodOpts<any>): void

Inherited from BaseParser.MANY_SEP
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:549
Parsing DSL method, that indicates a repetition of zero or more with a separator Token between the repetitions.

Example:
```
    this.MANY_SEP({
        SEP:Comma,
        DEF: () => {
            this.CONSUME(Number};
            // ...
        })
```
Note that because this DSL method always requires more than one argument the options object is always required and it is not possible to use a shorter form like in the MANY DSL method.

Note that for the purposes of deciding on whether or not another iteration exists Only a single Token is examined (The separator). Therefore if the grammar being implemented is so "crazy" to require multiple tokens to identify an item separator please use the more basic DSL methods to implement it.

As in CONSUME the index in the method name indicates the occurrence of the repetition production in it's top rule.

Note that due to current limitations in the implementation the "SEP" property must appear before the "DEF" property.
Parameters
- options: ManySepMethodOpts<any>
  
  An object defining the grammar of each iteration and the separator between iterations
Returns void

Protected OPTION

OPTION<OUT>(actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>): OUT

Inherited from BaseParser.OPTION
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:216
Parsing DSL Method that Indicates an Optional production. in EBNF notation this is equivalent to: "[...]".

Note that there are two syntax forms:
- Passing the grammar action directly:
```
  this.OPTION(() => {
    this.CONSUME(Digit)}
  );
```
- using an "options" object:
```
  this.OPTION({
    GATE:predicateFunc,
    DEF: () => {
      this.CONSUME(Digit)
  }});
```
The optional 'GATE' property in "options" object form can be used to add constraints to invoking the grammar action.

As in CONSUME the index in the method name indicates the occurrence of the optional production in it's top rule.
Type parameters
- OUT
Parameters
- actionORMethodDef: GrammarAction<OUT> | DSLMethodOpts<OUT>
  
  The grammar action to optionally invoke once or an "OPTIONS" object describing the grammar action and optional properties.
Returns OUT

Protected OR

OR(altsOrOpts: IAnyOrAlt[] | OrMethodOpts): any

Inherited from BaseParser.OR
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:352
Parsing DSL method that indicates a choice between a set of alternatives must be made. This is equivalent to an EBNF alternation (A | B | C | D ...), except that the alternatives are ordered like in a PEG grammar. This means that the first matching alternative is always chosen.

There are several forms for the inner alternatives array:
- Passing alternatives array directly:
```
  this.OR([
    { ALT:() => { this.CONSUME(One) }},
    { ALT:() => { this.CONSUME(Two) }},
    { ALT:() => { this.CONSUME(Three) }}
  ])
```
- Passing alternative array directly with predicates (GATE):
```
  this.OR([
    { GATE: predicateFunc1, ALT:() => { this.CONSUME(One) }},
    { GATE: predicateFuncX, ALT:() => { this.CONSUME(Two) }},
    { GATE: predicateFuncX, ALT:() => { this.CONSUME(Three) }}
  ])
```
- These syntax forms can also be mixed:
```
  this.OR([
    {
      GATE: predicateFunc1,
      ALT:() => { this.CONSUME(One) }
    },
    { ALT:() => { this.CONSUME(Two) }},
    { ALT:() => { this.CONSUME(Three) }}
  ])
```
- Additionally an "options" object may be used:
```
  this.OR({
    DEF:[
      { ALT:() => { this.CONSUME(One) }},
      { ALT:() => { this.CONSUME(Two) }},
      { ALT:() => { this.CONSUME(Three) }}
    ],
    // OPTIONAL property
    ERR_MSG: "A Number"
  })
```
The 'predicateFuncX' in the long form can be used to add constraints to choosing the alternative.

As in CONSUME the index in the method name indicates the occurrence of the alternation production in it's top rule.
Parameters
- altsOrOpts: IAnyOrAlt[] | OrMethodOpts
  
  A set of alternatives or an "OPTIONS" object describing the alternatives and optional properties.
Returns any

The result of invoking the chosen alternative.

Protected OVERRIDE_RULE

OVERRIDE_RULE<T>(name: string, impl: function, config?: IRuleConfig<T>): function

Inherited from Parser.OVERRIDE_RULE
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:844
Same as {@link Parser.RULE}, but should only be used in "extending" grammars to override rules/productions from the super grammar. See Parser Inheritance Example.

Type parameters
- T
Parameters
- name: string
- impl: function
  - - (...implArgs: any[]): T
    - Parameters
      - Rest ...implArgs: any[]
      Returns T
- Optional config: IRuleConfig<T>
Returns function
- - (idxInCallingRule?: number, ...args: any[]): T | any
  - Parameters
    - Optional idxInCallingRule: number
    - Rest ...args: any[]
    Returns T | any

Protected RULE

RULE<T>(name: string, implementation: function, config?: IRuleConfig<T>): function

Inherited from Parser.RULE
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:833
Type parameters
- T
Parameters
- name: string
  
  The name of the rule.
- implementation: function
  
  The implementation of the rule.
  - - (...implArgs: any[]): T
    - Parameters
      - Rest ...implArgs: any[]
      Returns T
- Optional config: IRuleConfig<T>
Returns function
- The parsing rule which is the production implementation wrapped with the parsing logic that handles
```
              Parser state / error recovery&reporting/ ...
```
- - (idxInCallingRule?: number, ...args: any[]): T | any
  - Parameters
    - Optional idxInCallingRule: number
    - Rest ...args: any[]
    Returns T | any

Protected SKIP_TOKEN

SKIP_TOKEN(): IToken

Inherited from BaseParser.SKIP_TOKEN
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:808
Returns IToken

Protected SUBRULE

SUBRULE<T>(ruleToCall: function, options?: SubruleMethodOpts): T

Inherited from Parser.SUBRULE
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:870
The Parsing DSL Method is used by one rule to call another. It is equivalent to a non-Terminal in EBNF notation.

This may seem redundant as it does not actually do much. However using it is mandatory for all sub rule invocations.

Calling another rule without wrapping in SUBRULE(...) will cause errors/mistakes in the Parser's self analysis phase, which will lead to errors in error recovery/automatic lookahead calculation and any other functionality relying on the Parser's self analysis output.

As in CONSUME the index in the method name indicates the occurrence of the sub rule invocation in its rule.

Type parameters
- T
Parameters
- ruleToCall: function
  
  The rule to invoke.
  - - (idx: number): T
    - Parameters
      - idx: number
      Returns T
- Optional options: SubruleMethodOpts
  
  optional properties to modify the behavior of SUBRULE.
Returns T

The result of invoking ruleToCall.

Protected canTokenTypeBeInsertedInRecovery

canTokenTypeBeInsertedInRecovery(tokType: TokenType): boolean

Inherited from BaseParser.canTokenTypeBeInsertedInRecovery
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:795
By default all tokens type may be inserted. This behavior may be overridden in inheriting Recognizers for example: One may decide that only punctuation tokens may be inserted automatically as they have no additional semantic value. (A mandatory semicolon has no additional semantic meaning, but an Integer may have additional meaning depending on its int value and context (Inserting an integer 0 in cardinality: "[1..]" will cause semantic issues as the max of the cardinality will be greater than the min value (and this is a false error!).

Parameters
- tokType: TokenType
Returns boolean

computeContentAssist

computeContentAssist(startRuleName: string, precedingInput: IToken[]): ISyntacticContentAssistPath[]

Inherited from BaseParser.computeContentAssist
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:52
Parameters
- startRuleName: string
- precedingInput: IToken[]
  
  The token vector up to (not including) the content assist point
Returns ISyntacticContentAssistPath[]

getBaseCstVisitorConstructor

getBaseCstVisitorConstructor(): object

Inherited from BaseParser.getBaseCstVisitorConstructor
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:36
Returns object
- constructor: function
  - new __type(...args: any[]): ICstVisitor<any, any>
  - - Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:36
    Parameters
    - Rest ...args: any[]
    Returns ICstVisitor<any, any>

getBaseCstVisitorConstructorWithDefaults

getBaseCstVisitorConstructorWithDefaults(): object

Inherited from BaseParser.getBaseCstVisitorConstructorWithDefaults
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:40
Returns object
- constructor: function
  - new __type(...args: any[]): ICstVisitor<any, any>
  - - Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:40
    Parameters
    - Rest ...args: any[]
    Returns ICstVisitor<any, any>

getGAstProductions

getGAstProductions(): HashTable<Rule>

Inherited from BaseParser.getGAstProductions
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:44
Returns HashTable<Rule>

Protected getNextPossibleTokenTypes

getNextPossibleTokenTypes(grammarPath: ITokenGrammarPath): TokenType[]

Inherited from BaseParser.getNextPossibleTokenTypes
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:802
deprecated
- will be removed in the future
Parameters
- grammarPath: ITokenGrammarPath
Returns TokenType[]

getSerializedGastProductions

getSerializedGastProductions(): ISerializedGast[]

Inherited from BaseParser.getSerializedGastProductions
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:46
Returns ISerializedGast[]

Protected getTokenToInsert

getTokenToInsert(tokType: TokenType): IToken

Inherited from BaseParser.getTokenToInsert
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:786
Returns an "imaginary" Token to insert when Single Token Insertion is done Override this if you require special behavior in your grammar. For example if an IntegerToken is required provide one with the image '0' so it would be valid syntactically.

Parameters
- tokType: TokenType
Returns IToken

parse

parse(document: string, entryRule?: function): object

Inherited from BaseSparqlParser.parse
- Defined in sparql/BaseSparqlParser.ts:24
Parameters
- document: string
- Default value entryRule: function = this.SparqlDoc
  - - (idxInCallingRule?: number, ...args: any[]): T | any
    - Parameters
      - Optional idxInCallingRule: number
      - Rest ...args: any[]
      Returns T | any
Returns object
- Optional comments?: IToken[]
- cst: CstNode
- errors: IRecognitionException[]

parseGroupGraphPattern

parseGroupGraphPattern(document: string): object

Inherited from BaseSparqlParser.parseGroupGraphPattern
- Defined in sparql/BaseSparqlParser.ts:45
Parameters
- document: string
Returns object
- Optional comments?: IToken[]
- cst: CstNode
- errors: IRecognitionException[]

parseTriplesBlock

parseTriplesBlock(document: string): object

Inherited from BaseSparqlParser.parseTriplesBlock
- Defined in sparql/BaseSparqlParser.ts:48
Parameters
- document: string
Returns object
- Optional comments?: IToken[]
- cst: CstNode
- errors: IRecognitionException[]

Protected performSelfAnalysis

performSelfAnalysis(): void

Inherited from BaseParser.performSelfAnalysis
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:15
This must be called at the end of a Parser constructor. See: http://sap.github.io/chevrotain/docs/tutorial/step2_parsing.html#under-the-hood

Returns void

reset

reset(): void

Inherited from BaseParser.reset
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:34
Resets the parser state, should be overridden for custom parsers which "carry" additional state. When overriding, remember to also invoke the super implementation!

Returns void

tokenize

tokenize(document: string): IToken[]

Inherited from BaseSparqlParser.tokenize
- Defined in sparql/BaseSparqlParser.ts:21
Parameters
- document: string
Returns IToken[]

Static Protected performSelfAnalysis

performSelfAnalysis(parserInstance: Parser): void

Inherited from Parser.performSelfAnalysis
- Defined in /Users/anneebarrett/code/millan/node_modules/chevrotain/lib/chevrotain.d.ts:822
deprecated

use {@link Parser.performSelfAnalysis} instance method instead.

Parameters
- parserInstance: Parser
Returns void

Hierarchy

Implements

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Optional options: any

Returns W3SpecSparqlParser

Properties

Add

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

AdditiveExpression

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

Aggregate

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

ArgList

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

AskQuery

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

Avg

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

BaseDecl

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

Bind

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

BlankNode

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

BlankNodePropertyList

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

BlankNodePropertyListPath

Type declaration

Parameters

Optional idxInCallingRule: number

Rest ...args: any[]

Returns T | any

BooleanLiteral

Type declaration