From bf9a8e4374ab45b015577553588a627d892415e5 Mon Sep 17 00:00:00 2001 From: Michael Pizzo Date: Wed, 26 Jul 2023 21:40:33 -0700 Subject: [PATCH] Add Capabilities to RSDL (#441) * Initial commit -add capabilities to abnf -add new section on rsdl-capabilities * -add section on paging -add capabilities to abnf * Add support for data modification capabilities Add support for operation capabilities Misc clean-up * fixed ABNF syntax errors * Update rsdl-testcases.yaml * Add tools/rsdl/abnf to workspaces * Allow "paths" anywhere multiple times - add first test case for paths - VS Code tasks for ABNF in mono-repo * Add initial set of test cases * update prettier in settings.json. * Merge Ralf's changes * Extract ABNF: ignore CR characters in Markdown source * Use LF as default line ending in repo to enable non-windows users to participate See https://prettier.io/docs/en/options.html#end-of-line for explanation * Fixed rule collectionRefProperty * Fixed paths rule * No CRLF * Update .editorconfig * Only contains default values after removing crlf * Remove .prettierrc as it only contained default values * Update docs/rsdl/rapid-rsdl-intro.md * Update docs/rsdl/rapid-rsdl-paths.md * Update rapid-rsdl-paths.md * Update docs/rsdl/rapid-rsdl-paths.md * Formatting * Update docs/rsdl/rapid-rsdl-capabilities.md Co-authored-by: Ralf Handl * Change Reference to Navigation Fix Paths Simplify Nullable types in grammar Address other comments * Improve abnf; add test cases. * Apply fixes from 2023-7-26 TC discussion: -Replace use of parens with curly braces for filter, expand, orderby -Support appending cast segment to a single valued property segment * Updated prose to use curly braces rather than parens (thanks for the catch ralf!) Also, removed ability to mark a collection property as a key. --------- Co-authored-by: Ralf Handl --- .gitattributes | 1 + docs/rapid-pro-operations.md | 3 + docs/rapid-pro.md | 4 +- docs/rsdl/rapid-rsdl-abnf.md | 162 ++- docs/rsdl/rapid-rsdl-capabilities.md | 496 +++++++ docs/rsdl/rapid-rsdl-intro.md | 49 +- docs/rsdl/rapid-rsdl-paths.md | 103 ++ docs/rsdl/rapid-rsdl-semantics.mdx | 4 +- package-lock.json | 1 + tools/rsdl/abnf/lib/grammar.js | 1780 +++++++++++++++++++------- tools/rsdl/abnf/rsdl-testcases.yaml | 231 +++- tools/rsdl/abnf/rsdl.abnf | 155 ++- website/sidebars.js | 2 +- 13 files changed, 2487 insertions(+), 504 deletions(-) create mode 100644 docs/rsdl/rapid-rsdl-capabilities.md create mode 100644 docs/rsdl/rapid-rsdl-paths.md diff --git a/.gitattributes b/.gitattributes index 51f22ad1..32c30dd6 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1,2 @@ +* text=auto eol=lf *.abnf text eol=crlf diff --git a/docs/rapid-pro-operations.md b/docs/rapid-pro-operations.md index 87f422d7..2697d229 100644 --- a/docs/rapid-pro-operations.md +++ b/docs/rapid-pro-operations.md @@ -6,11 +6,14 @@ sidebar_label: Actions and Functions Although a pure REST service would perform operations through manipulating the state of resources, we have found that many services require the ability to encapsulate complex processing logic into atomic operations. + Rather than requiring services to expose a separate endpoint for such business logic, RAPID allows services to support Operations. + Operations are exposed as resources at the root of the service or "bound" to the resource on which they operate. Operations bound to a resource are invoked by appending a segment containing the name of the operation to the URL of the resource. + The name of the operation must not conflict with the name of any properties or other operations bound to that resource. diff --git a/docs/rapid-pro.md b/docs/rapid-pro.md index 1343eea2..d68623ab 100644 --- a/docs/rapid-pro.md +++ b/docs/rapid-pro.md @@ -14,12 +14,12 @@ import Request from '../website/src/components/documentation-queries/Request.js' --> RAPID is a simple profile for building well-designed APIs that can scale to the level of functionality required for any situation. + By following RAPID conventions, services are able to leverage common libraries and tools, and can share their information in a discoverable and interoperable way. Because the RAPID profile is based on, and compatible with, the industry standard OData protocol, -services following RAPID conventions know that, as their needs grow, -there are well defined conventions and semantics that allow them to seamlessly and incrementally grow without having to rewrite as their needs evolve. +services following RAPID conventions know that, as their needs grow, there are well defined conventions and semantics that allow them to seamlessly and incrementally grow without having to rewrite as their needs evolve. ## What makes a RAPID service? diff --git a/docs/rsdl/rapid-rsdl-abnf.md b/docs/rsdl/rapid-rsdl-abnf.md index 647d9cd2..4a985c5e 100644 --- a/docs/rsdl/rapid-rsdl-abnf.md +++ b/docs/rsdl/rapid-rsdl-abnf.md @@ -3,10 +3,7 @@ id: rsdl-abnf title: RSDL ABNF --- -# RAPID Pro Syntax - -> DRAFT -> March 2021 +# RAPID Schema Definition Language (RSDL) Syntax ## Overview @@ -16,7 +13,7 @@ Note: to increase readability of the grammar, whitespace is not reflected ## Syntax rules -- [RAPID Pro Syntax](#rapid-pro-syntax) +- [RAPID Schema Definition Language (RSDL) Syntax](<#rapid-schema-definition-language-(RSDL)-Syntax>) - [Overview](#overview) - [Syntax rules](#syntax-rules) - [Model](#model) @@ -25,18 +22,22 @@ Note: to increase readability of the grammar, whitespace is not reflected - [Type Definition](#type-definition) - [Service](#service) - [Annotations](#annotations) + - [Model Capabilities](#model-capabilities) + - [Paths](#paths) + - [Path Capabilities](#path-capabilities) + - [Capability Elements](#capability-elements) - [Core Syntax Elements](#core-syntax-elements) ### Model ```ABNF -model = OWS [ namespace RWS ] *include [ modelElement *( RWS modelElement ) ] OWS +model = OWS [ namespace RWS ] *include [ modelElement *( RWS modelElement ) ] [ OWS service ] [ OWS paths ] OWS namespace = %s"namespace" RWS qualifiedName include = %s"include" RWS DQUOTE 1*CHAR DQUOTE RWS %s"as" RWS identifier RWS -modelElement = ( structuredType / enumType / typeDefinition / service ) +modelElement = ( structuredType / enumType / typeDefinition ) ``` ### Structured Type @@ -46,11 +47,20 @@ structuredType = annotations [ %s"abstract" RWS ] %s"type" RWS identifier structuredTypeMember = property / operation ; property, action, or function -property = annotations [propertyModifier RWS] identifier OWS ":" OWS typeReference +property = singlePropertyDefinition [ OWS (primitivePropertyCapabilities / singleNavigationCapabilities) ] + / collectionPropertyDefinition [ OWS ( collectionCapabilities / collectionNavigationCapabilities) ] + +singlePropertyDefinition = annotations [propertyModifier RWS] identifier OWS ":" OWS singleTypeReference + +collectionPropertyDefinition = annotations identifier OWS ":" OWS collectionTypeReference propertyModifier = %s"key" -typeReference = typeName [ "?" ] / "[" typeName [ "?" ] "]" +singleTypeReference = typeName [ "?" ] + +collectionTypeReference = "[" typeName [ "?" ] "]" + +typeReference = singleTypeReference / collectionTypeReference typeName = builtInType / edmType / qualifiedName @@ -69,6 +79,7 @@ edmType = %s"Edm" "." identifier operation = annotations operationKind RWS identifier OWS "(" OWS [ parameter *( OWS "," OWS parameter) OWS ] ")" [ OWS ":" OWS annotations typeReference ] + [ separator collectionNavCapabilities ] operationKind = %s"action" / %s"function" @@ -96,9 +107,9 @@ service = annotations %s"service" [ RWS identifier ] OWS "{" OWS se serviceMember = annotations ( entitySet / singleton / serviceOperation ) -entitySet = identifier OWS ":" OWS "[" qualifiedName "]" +entitySet = identifier OWS ":" OWS "[" qualifiedName "]" [ OWS collectionNavigationCapabilities ] -singleton = identifier OWS ":" OWS qualifiedName +singleton = identifier OWS ":" OWS qualifiedName [ OWS singleNavigationCapabilities ] serviceOperation = operationKind RWS identifier OWS "(" OWS [ parameter *(OWS "," OWS parameter) OWS ] ")" @@ -117,8 +128,8 @@ annotationValue = %s"true" / %s"null" / number / DQUOTE *CHAR DQUOTE - / "[" OWS [ annotationValue *( ( OWS "," OWS / RWS ) annotationValue ) OWS [ "," OWS ] ] "]" - / "{" OWS [ annotationProperty *( ( OWS "," OWS /RWS ) annotationProperty ) OWS [ "," OWS ] ] "}" + / "[" OWS [ annotationValue *( separator annotationValue ) OWS [ "," OWS ] ] "]" + / "{" OWS [ annotationProperty *( separator annotationProperty ) OWS [ "," OWS ] ] "}" / "." *( "/" identifier ) annotationProperty = propertyName OWS ":" OWS annotationValue @@ -126,9 +137,130 @@ annotationProperty = propertyName OWS ":" OWS annotationValue propertyName = identifier / DQUOTE 1*CHAR DQUOTE / "@" qualifiedName [ "#" identifier ] ``` +### Model Capabilities + +```ABNF +primitivePropertyCapability = "filterable" [ OWS filterOptions ] / "orderable" [ OWS orderByDirection ] + +primitivePropertyCapabilities = "{" OWS [ primitivePropertyCapability *( separator primitivePropertyCapability )] OWS "}" + +singleNavigationCapability = ("READ" / "UPDATE" / "REPLACE") [ OWS navCapabilities ] / "DELETE" noOptions + +singleNavigationCapabilities = "{" OWS [ singleNavigationCapability *( separator singleNavigationCapability )] OWS "}" + +collectionNavigationCapability = "DELETE" OWS noOptions + / "LIST" [ OWS collectionNavCapabilities ] + / ("READ" / "CREATE" / "REPLACE" / "UPDATE") [ OWS navCapabilities ] + +collectionNavigationCapabilities = "{" OWS [ collectionNavigationCapability *( separator collectionNavigationCapability )] OWS "}" + +``` + +### Paths + +```ABNF +paths = %s"paths" OWS "{" *( OWS "/" path ) OWS "}" + +path = propertySegment "/" keySegment [ pathSegment / ( RWS singleNavPathCapabilities ) ] + / serviceOperationSegment "/" keySegment [ pathSegment / ( RWS singleNavPathCapabilities ) ] + / serviceOperationSegment [ pathSegment / ( RWS capabilities ) ] + / castSegment [ pathSegment / ( RWS capabilities ) ] + / propertySegment [ pathSegment / ( RWS capabilities ) ] + +propertySegment = identifier; structural or navigation property + +pathSegment = "/" path + +castSegment = identifier 1*( "." identifier ) ; qualified type name + +keySegment = "{" keyProperty "}" + +keyProperty = identifier ; name of the key property + +serviceOperationSegment = identifier parameters [ "/" castSegment ] [ "/" keySegment ] + +parameters = "(" OWS [ parameterSpecification *( "," OWS parameterSpecification ) OWS ] ")" + +parameterSpecification = identifier OWS "=" OWS "{" identifier "}" + +capabilities = singlePathCapabilities / collectionPathCapabilities / singleNavPathCapabilities / collectionNavPathCapabilities + +``` + +### Path Capabilities + +```ABNF + +singlePathCapability = ("GET" / "PUT" / "PATCH" / "DELETE") [noOptions] + +singlePathCapabilities = "{" OWS [singlePathCapability *( separator singlePathCapability) OWS] "}" + +collectionPathCapability = "GET" [ collectionCapabilities ] / "POST" [noOptions] + +collectionPathCapabilities = "{" OWS [ collectionPathCapability *( separator collectionPathCapability ) OWS ] "}" + +singleNavPathCapability = ("GET" / "PATCH" / "PUT") [ OWS navCapabilities ] / "DELETE" noOptions + +singleNavPathCapabilities = "{" OWS [singleNavPathCapability *( separator singleNavPathCapability ) OWS ] "}" + +collectionNavPathCapability = "GET" [ OWS collectionNavCapabilities ] / "POST" [ OWS navCapabilities ] + +collectionNavPathCapabilities = "{" OWS [ collectionNavPathCapability *( separator collectionNavPathCapability ) OWS ] "}" + +``` + +### Capability Elements + +```ABNF + +collectionCapability = filterCapability / orderByCapability / "top" / "skip" / "count" + +collectionCapabilities = "{" OWS [ collectionCapability *( separator collectionCapability ) OWS ] "}" + +collectionNavCapability = collectionCapability / navCapability + +collectionNavCapabilities = "{" OWS [ collectionNavCapability *( separator collectionNavCapability ) OWS ] "}" + +navCapability = "expand" [ OWS "{" OWS [ expandProperty *( OWS "," OWS expandProperty OWS ) ] OWS "}" ] + +navCapabilities = "{" OWS [ navCapability OWS ] "}" + +expandProperty = star / [ castSegment "/" ] navigationProperty ( [ OWS collectionNavCapabilities ] / [ OWS navCapabilities ] ) + +navigationProperty = identifier ; single or collection valued navigation property + +filterCapability = "filter" [ "{" [ OWS filterProperty *( "," OWS filterProperty OWS ) ] "}" ] + +filterProperty = ( ( [ typeName "/" ] propertyName ) / allProperties) [ OWS filterOptions ] + +allProperties = star [ "/" typeName ] ; all properties, optionally of a given type + +filterOptions = "{" OWS [ filterOperations OWS ] "}" + +filterOperations = "none" ; not filterable + / "eq" ; eq + / "comp" ; eq, gt, ge, lt, le + / "stringComp" ; eq, gt, ge, lt, le, startswith, endswith, contains + / "string" ; eq, startswith, endswith, contains + +orderByCapability = "orderby" [ OWS orderByProperties ] + +orderByProperties = "{" OWS [ orderByProperty *( "," OWS orderByProperty OWS ) ] "}" + +orderByProperty = allProperties / propertyName [ OWS orderByDirection ] + +orderByDirection ="{" [ OWS ascOrDesc [ "," OWS ascOrDesc OWS ] ] "}" + +ascOrDesc = "asc" / "desc" + +noOptions = OWS "{" OWS "}" + +``` + ### Core Syntax Elements ```ABNF + qualifiedName = identifier *( "." identifier ) identifier = identInitial *identSubsequent @@ -137,6 +269,10 @@ identInitial = ALPHA / "_" ; Note: actually all Unicode letters identSubsequent = identInitial / DIGIT +separator = OWS "," OWS / RWS + +star = "*" + number = integer [ "." 1*DIGIT ] [ "e" integer ] integer = [ "+" / "-" ] ( %x30 / %x31-39 *DIGIT ) diff --git a/docs/rsdl/rapid-rsdl-capabilities.md b/docs/rsdl/rapid-rsdl-capabilities.md new file mode 100644 index 00000000..99634f8a --- /dev/null +++ b/docs/rsdl/rapid-rsdl-capabilities.md @@ -0,0 +1,496 @@ +--- +id: rsdl-capabilities +title: RSDL Capabilities +--- + +# Expressing Capabilities in RAPID Schema Definition Language (RSDL) + +RAPID uses a Schema Definition Language ([RSDL](./rsdl-intro)) to describe the structure of a REST service. Developers can be annotate their schema model with [capabilities](./rsdl-abnf#model-capabilities) in order to describe the capabilities of their service. + +- [Annotating Model Elements](#annotating-model-elements) + - [Reading Data](#support-for-reading-data) + - [Read Options](#read-options) + - [expand Option](#expand-option) + - [Listing Collections](#listing-collections) + - [List Options](#list-options) + - [filter Option](#filter-option) + - [orderby Option](#orderby-option) + - [top/skip Options](#top-and-skip-options) + - [count Option](#count-option) + - [Modifying Data](#support-for-modifying-data) + - [Creating Resources](#create-support) + - [Create options](#create-options) + - [Updating Resources](#update-support) + - [Update options](#update-options) + - [Replacing Resources](#replace-support) + - [Replace Options](#replace-options) + - [Deleting Resources](#delete-support) + - [Delete Options](#delete-options) + - [Invoking Operations](#operation-support) + - [Default Capabilities](#default-capabilities) +- [Annotating Paths](#annotating-paths) + +# Annotating Model Elements + +Model elements are the service, operations, types, and properties defined in in an RSDL Schema. + +Capabilities applied to model elements determine the set of paths and capabilities implemented by the service. The developer can generate a set of paths and capabilities from the annotated model to explore or further refine the supported functionality. + +Capabilities for a model element are specified in curly braces following the model element definition. Omitting a capability within the curly braces means that capability is not supported. If no curly braces follow the model element, a [default set of capabilities](#default-capabilities) is assumed. + +## Support for reading data + +A top level singleton or single-valued navigation property can be annotated with the `READ` capability to show that it supports reading. + +```rsdl +service { + company: Company { READ } +} +``` + +States that the path `GET /company` is supported. + +Applying the `READ` capability to a top-level collection or collection valued navigation property states that individual members of the collection can be read using their key value. + +```rsdl +service { + competitors: [Company] { READ } +} + +type Company +{ + key stockSymbol: String + ... +} + +``` + +States that the path `GET /competitors/{stockSymbol}` is supported. + +### Read Options + +The `READ` capability can be further refined to specify the specific read capabilities that are supported. If no curly braces follow the `READ` capability then a default set of capabilities is assumed. If empty curly braces follow the `READ` capability then the value can be read, but none of the read options are supported. + +#### Expand Option + +The `expand` option within the `READ` capability specifies that navigation properties within the referenced type can be expanded. + +```rsdl +service { + company: Company { READ { expand } } +} +``` + +The `expand` option alone means that all navigation properties within the referenced type can be expanded. So, for example, the user can specify `GET /company?$expand=employees`. + +The `expand` option may be followed by a list of individual navigation properties that can be expanded. + +```rsdl +service { + company: Company { READ { expand { employees } } } +} +``` + +Means that only the employees navigation property can be expanded. + +##### Nested Expand Options + +The `expand` option followed by an empty set of curly braces means that no properties can be expanded. + +Collection-valued navigation properties can include nested expand [expand](#expand-option), [filter](#filter-option), [orderBy](#orderby-option), [top/skip](#top-and-skip-options) and [count](#count-option) options, as appropriate. + +In the example: + +```rsdl +service { + company: Company { READ { expand { employees { top, skip, count, filter, orderby } } } } +} +``` + +`top`, `skip`, `count`, `filter`, and `orderby` query options are supported when expanding employees from company: + +`GET /company?expand=employees(top=10;skip=1;count=true;filter=lastName eq 'Jetson';orderby=firstName)` + +Expand options can be applied to all navigation properties not otherwise specified using the `*` + +```rsdl +service { + company: Company { READ { expand { * { top, skip, count, filter, orderby } } } } +} +``` + +`top`, `skip`, `count`, `filter`, and `orderby` query options are supported when expanding all navigation properties from company. + +If no curly braces follow a collection-valued navigation property, then top, skip, count, filter, and orderby are all assumed to be supported. + +Additionally, if no curly braces follow a navigation property or `*`, then it is assumed that `expand` supports nested expands according to the capabilities of each navigation property of the target type, recursively. + +If the navigation property or `*` is suffixed by empty curly braces, then no expand options are supported when expanding the property. + +## Listing Collections + +A [top level collection](./rsdl-intro#defining-a-top-level-Collection) can be annotated with the `LIST` capability to show that it supports listing members. + +```rsdl +service { + competitors: [Company] { LIST } +} +``` + +States that the path `GET /competitors` is supported. + +Similarly, a collection-valued navigation property can be annotated with the same capability: + +```rsdl +service { + company: Company { READ } + competitors: [Company] { LIST, READ } +} + +type Company +{ + key stockSymbol: String + name: String + incorporated: Date + employees: [Employee] { LIST, READ } +} +``` + +The `LIST` capability on `competitors` means that the path `GET /competitors` is supported. + +The `LIST` capability on `employees`, along with the `READ` capability on `competitors`, means that the path `GET /competitors/employees` is supported. + +The `LIST` capability on `employees`, together with the `READ` capability on `company`, means that the path `GET /company/{stockSymbol}/employees` is supported. + +If there are no curly braces following a top-level collection or collection-valued navigation property within a type, it is assumed to support `LIST` and `READ`, as well as `CREATE`, `UPDATE`, and `DELETE`. + +### List Options + +The `LIST` capability can be followed by a set of options that specify what capabilities the service supports when enumerating the collection. + +LIST options include [expand](#expand-option), [filter](#filter-option), [orderBy](#orderby-option), [top and skip](#top-and-skip-options), and [count](#count-option). If no options are supported, it is assumed that expand, filter, orderby, top, skip, and count are all supported when listing the collection. If an empty curly brace follows the LIST capability, it means that no list options are supported. + +#### Filter Option + +The `filter` option specifies that a filter can be applied when listing the collection. + +```rsdl +service { + competitors: [Company] { LIST { filter }, READ } +} +``` + +Specifies that the [`filter`](../rapid-pro-read.md#filtering-results) query option can be used when listing competitors. + +The `filter` option may be followed by a list of individual navigation properties that can be filtered, optionally followed by a [`filter option`](#filter-operations). + +```rsdl +service { + competitors: [Company] { LIST { filter { name {stringComp} } } } +} +``` + +The `competitors` collection can be filtered by name using the string comparison operators. + +If no curly braces follow the `filter` option, then the [`filterable`](#filterable-capability) capability, if present on a property, is used to determine whether or not that property can be filtered upon. If `filter` is followed by empty curly braces, then the collection does not support filtering on any properties. + +##### Filterable capability + +Individual properties of the collection type may be annotated with the `filterable` capability to show that they can be used when filtering a collection of that type. + +```rsdl +type Company +{ + key stockSymbol: String { filterable } + name: String { filterable } + incorporated: Date { filterable } + employees: [Employee] { LIST { filter }, READ } +} +``` + +Specifies that filterable collections of companies can be filtered on stockSymbol, name, and incorporated. + +###### Filter Operations + +The `filterable` capability can include a filter operation to specify the filter operators that can be applied when filtering by the property: + +```rsdl + name: String { filterable { stringComp } } +``` + +Possible values for filter operations are as follows: + +| Property Type | filter operation | supported filter operators | +| ------------- | ---------------- | ------------------------------------------------------------------ | +| any primitive | `none` | not filterable | +| any primitive | `eq` | `eq` | +| any primitive | `comp` | `eq`, `gt`, `ge`, `lt`, `le` | +| string | `string` | `eq`, `startswith`, `endswith`, `contains` | +| string | `stringComp` | `eq`, `gt`, `ge`, `lt`, `le`, `startswith`, `endswith`, `contains` | + +Properties that do not have a `filterable` capability, or that have a `filterable` capability with no specified filter option, are assumed to be filterable in collections that support filtering using the filter operators appropriate to their type. + +#### OrderBy Option + +The `orderby` option within the `LIST` capability specifies that an orderby can be applied when listing the collection. + +```rsdl +service { + competitors: [Company] { LIST { filter, orderby }, READ } +} +``` + +Specifies that the [`orderby`](../rapid-pro-read.md#ordering-results) query option can be used when listing competitors. + +The `orderby` option may be followed by a list of individual properties that can be ordered, optionally followed by a [`filter option`](#filter-operations). + +```rsdl +service { + competitors: [Company] { LIST { orderby { name {asc, desc} } } } +} +``` + +The competitors collection can be ordered by name in ascending or descending order. + +If no curly braces follow the `orderby` option, then the [`orderability`](#orderable-capability) capability, if present on a property, is used to determine whether or not that property can be ordered by. If `orderby` is followed by empty curly braces, then the collection does not support ordering on any properties. + +##### Orderable capability + +Individual properties of the collection type may be annotated with the `orderable` capability to show that they can be used when ordering a collection of that type. + +```rsdl +type Company +{ + key stockSymbol: String { orderable } + name: String { orderable } + incorporated: Date { orderable } + employees: [Employee] { LIST { filter, orderby }, READ } +} +``` + +Orderable collections of `Company` can be ordered on `stockSymbol`, `name`, and `incorporated`. + +The `orderable` capability can include the set of orderby options to specify whether the property can be ordered ascending, descending, or both. + +```rsdl + name: String { orderable { asc, desc} } +``` + +The `name` property can be ordered by ascending (`asc`) or descending (`desc`). + +Primitive properties that do not have an `orderable` capability, or that have a `orderable` capability without specifying `asc` or `desc`, are assumed to be orderable in ascending or descending order. + +#### Top and Skip Options + +The `top` and `skip` option within the `LIST` capability specify that `top` and `skip` [query options](../rapid-pro-read.md#requesting-a-range-of-members) can be used when listing the collection. + +```rsdl +service { + competitors: [Company] { LIST { top, skip }, READ } +} +``` + +The `top` and `skip` query option can be used when listing competitors. + +#### Count Option + +The `count` option within the `LIST` capability specify that the [count](../rapid-pro-read.md#requesting-a-range-of-members) query option can be used when listing the collection. + +```rsdl +service { + competitors: [Company] { LIST { count }, READ } +} +``` + +The `count` query option can be used when listing competitors. + +## Support For Modifying Data + +Capabilities can be applied to top-level collections and collection-valued navigation properties to specify whether they support [`POST`](#create-capability), [`PATCH`](#update-capability), [`PUT`](#replace-capability), or [`DELETE`](#delete-capability) operations. + +If no capabilities are applied to a top-level collection, or to a collection-valued navigation property, it is assumed to support `POST`, `PATCH`, and `DELETE`, as well as `GET`, but not `PUT`. + +### Create Support + +The `CREATE` capability can be applied to a collection of navigation values to state that members can be inserted into the collection. + +```rsdl +service { + competitors: [Company] { CREATE } +} + +type Company +{ + key stockSymbol: String + employees: [Employee] { CREATE } +} +``` + +States that the paths `POST /competitors` and `POST /competitors/{stockSymbol}/employees` are supported. + +#### Create Options + +The `CREATE` capability can be followed by the [`expand`](#expand-option) option to specify that the `expand` query option can be applied to the `POST` request in order to include related resources when returning the created item. + +```rsdl +service { + competitors: [Company] { CREATE { expand { employees } } } +} +``` + +States that the path `POST /competitors?expand=employees` is supported to return the new competitor along with related employees. + +### Update Support + +The `UPDATE` capability can be applied to a navigation property to state that the property is updatable. + +```rsdl +service { + company: Company { UPDATE } +} +``` + +States that the path `PATCH /company` is supported. + +The `UPDATE` capability can also be applied to an entity set or collection-valued navigation property to state that individual members of the collection can be updated. + +```rsdl +service { + competitors: [Company] { UPDATE } +} + +type Company +{ + key stockSymbol: String + employees: [Employee] { UPDATE } +} +``` + +States that the paths `PATCH /competitors/{stockSymbol}` and `PATCH /competitors/{stockSymbol}/employees/{id}` are supported. + +### Update Options + +The `UPDATE` capability can be followed by the [`expand`](#expand-option) option to specify that the `expand` query option can be applied to the `PATCH` request in order to include related resources when returning the updated item. + +```rsdl +service { + company: Company { UPDATE { expand { employees } } } +} +``` + +States that the path `PATCH /company?expand=employees` is supported to return the related employees along with the updated competitor. + +### Replace Support + +The `REPLACE` capability can be applied to a navigation property to state that the property can be replaced. + +```rsdl +service { + company: Company { REPLACE } +} +``` + +States that the path `PUT /company` is supported. + +The `REPLACE` capability can be applied to an entity set or collection-valued navigation property to state that individual members of the collection can be replaced. + +```rsdl +service { + competitors: [Company] { REPLACE } +} +type Company +{ + key stockSymbol: String + employees: [Employee] { REPLACE } +} +``` + +States that the paths States that the path `PUT /competitors/{stockSymbol}` and +`PUT /competitors{stockSymbol}/employees/{id}` are supported. + +#### Replace Options + +The `REPLACE` capability can be followed by the [`expand`](#expand-option) option to specify that the `expand` query option can be applied the `PUT` request in order to include related resources when returning the replaced item. + +```rsdl +service { + company: Company { REPLACE { expand { employees } } } +} +``` + +States that the path `PUT /company?expand=employees` is supported to return the related employees along with the competitor. + +### Delete Support + +The `DELETE` capability can be applied to a navigation property to state that the property can be deleted. + +```rsdl +service { + company: Company { DELETE {} } +} +``` + +States that the path `DELETE /company` is supported. + +The `DELETE` capability can also be applied to an entity set or collection-valued navigation property to state that individual members of the collection can be deleted. + +```rsdl +service { + competitors: [Company] { DELETE{} } +} +type Company +{ + key stockSymbol: String + employees: [Employee] { DELETE{} } +} +``` + +States that the paths `DELETE /competitors/{stockSymbol}` and `DELETE /competitors/{stockSymbol}/employees/{id}` are supported. + +#### Delete options + +The `DELETE` capability does not support any delete options and must be followed by empty braces `{}` to denote that no query options are supported. + +## Operation Support + +Operations that return a single result can be followed by [`expand`](#expand-option) to specify that the `expand` query option can be applied the request in order to include related resources when returning the result. + +```rsdl +service { + topCompany() : Company { expand { employees } } +} +type Company +{ + key stockSymbol: String + employees: [Employee] +} +``` + +States that the path `GET /topCompany?expand=employees` is supported to return the related employees along with the top company. + +In addition to [`expand`](#expand-option), operations that return a collection can be followed by any of the [`LIST`](#list-options) capability options to specify [`filter`](#filter-option), [`orderby`](#orderby-option), [`top`, `skip`](#top-and-skip-options), and [`count`](#count-option) support. + +```rsdl +service { + topCompanies( num: Integer ) : [Company] { filter, orderby, top, skip, count, expand } +} +``` + +States that query options `filter`, `orderby`, `top`, `skip`, `count`, and `expand` are all supported when calling `topCompanies`. + +## Default Capabilities + +Not applying capabilities to a model element means that you support the default capabilities for that element, as defined in the following table: + +| Model Element | Default Capabilities | +| ------------------------------------------------------------- | ---------------------------------- | +| Top-level collection or collection-valued navigation property | LIST, READ, CREATE, UPDATE, DELETE | +| Singleton or single-valued navigation property | READ | + +# Annotating Paths + +**todo...** + +``` + +``` diff --git a/docs/rsdl/rapid-rsdl-intro.md b/docs/rsdl/rapid-rsdl-intro.md index 2470c78c..bd08569b 100644 --- a/docs/rsdl/rapid-rsdl-intro.md +++ b/docs/rsdl/rapid-rsdl-intro.md @@ -7,7 +7,7 @@ title: RSDL Intro RAPID Schema Definition Language (RSDL) is a language to define Web APIs. -RSDL is based on the [RAPID Profile]() of the +RSDL is based on the RAPID [Profile]() of the [OData](https://en.wikipedia.org/wiki/Open_Data_Protocol) specification. RAPID provides an easy way to envision, create, and consume a Web API that is compatible with the OData Standard and can evolve over time to support more advanced scenarios. @@ -189,7 +189,7 @@ RAPID supports actions and functions. An action takes zero or more input parameters and may or may not return a value. Actions may have side effects. -We can define a "youAreFired" action on our company that takes a string parameter "reason": +We can define a "youreFired" action on our company that takes a string parameter "reason": ```rsdl type Company @@ -199,7 +199,7 @@ type Company incorporated: Date employees: [Employee] topEmployees(num: Integer): [Employee] - action youAreFired(reason: String) + action youreFired(reason: String) } ``` @@ -249,3 +249,46 @@ Functions are invoked using a GET request. Function parameters are passed in the | Request | Comment | | :-------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------- | | GET [http://rapid-pro.org/company/topEmployees?num=10]() | get the company's top 10 employees | + +#### Explicit Paths + +The set of paths supported by a RAPID service generally do not need to be explicitly enumerated in the RSDL because they are defined by the model. However, in some cases you may want to be explicit about the set of paths supported, either because the service supports only a subset of paths or because you want to specify [capabilities](rapid-rsdl-capabilities.md#annotating-paths) that are specific to that path. + +The set of paths supported by a RAPID service can be explicitly enumerated in the RSDL specification: + +```rsdl +paths : +{ + /company + /company/employees + /company/employees/{id} + /competitors + /competitors/{stockSymbol} + /competitors/{stockSymbol}/employees + /competitors/{stockSymbol}/employees/{id} + /company/topEmployees(num={num}) + /company/topEmployees(num={num})/{id} + /company/youreFired +} +``` + +Paths that are omitted are not supported, even if valid according to the model. + +A nice way of documenting that a path is not supported is by it by adding it as a comment. From a syntax perspective this is equivalent to omitting that path: + +```rsdl + +paths : +{ + /company + /company/employees + /company/employees/{id} + /competitors + /competitors/{stockSymbol} +# /competitors/{stockSymbol}/employees +# /competitors/{stockSymbol}/employees/{id} + /company/topEmployees(num={num}) +# /company/topEmployees(num={num})/{id} + /company/youreFired +} +``` diff --git a/docs/rsdl/rapid-rsdl-paths.md b/docs/rsdl/rapid-rsdl-paths.md new file mode 100644 index 00000000..300f2b1e --- /dev/null +++ b/docs/rsdl/rapid-rsdl-paths.md @@ -0,0 +1,103 @@ +--- +id: rsdl-paths +title: RAPID Paths +--- + +# Paths in a RAPID Service + +The set of valid paths for a RAPID service is the result of applying common path conventions to the model, as described below. You can optionally specify a subset of these paths that are supported by your service using [explicit paths](rapid-rsdl-intro.md#explicit-paths) in your RSDL. + +- [Service Root](#service-root) +- [Key Segment](#key-segment) +- [Structured Properties](#structured-properties) +- [Nested Operations](#nested-operations) + +## Service Root + +The [service](./rapid-rsdl-intro.md#defining-a-service) element in RSDL defines the segments that are available at the service root: + +```rsdl +service { + company: Company +} +``` + +### Supported Path + +`/company` + +## Key Segment + +Path segments that represent a collection of [structured types](rapid-rsdl-intro.md#defining-a-structured-type) with identity may be followed by a segment containing the name of the key property enclosed in parens as a placeholder for the key value of an instance within the collection. + +```rsdl +service { + competitors: [Company] +} + +type Company +{ + key stockSymbol: String +} +``` + +### Supported Paths + +`/competitors` +`/competitors/{stockSymbol}` + +where `{stockSymbol}` is a placeholder for the stock symbol of a competitor. + +## Structured Properties + +Path segments that represent a single [structured type](rapid-rsdl-intro.md#defining-a-structured-type) can be followed by the name of a property defined on that structured type: + +```rsdl +service { + company: Company +} + +type Company +{ + key stockSymbol: String + employees: [Employee] +} + +type Employee +{ + key id: Integer +} +``` + +### Supported Paths + +`/company` +`/company/employees` +`/company/employees/{id}` + +where `{id}` is placeholder for an employee's id. + +## Nested Operations + +The name of a [nested operation](rapid-rsdl-intro.md#defining-methods) may follow a segment of the specified type in which the operation is defined: + +```rsdl +service { + company: Company +} + +type Company +{ + topEmployees(num: Integer): [Employee] + action youreFired(reason: String) +} +``` + +### Supported Paths + +`/company` +`/company/topEmployees(num={num})` +`/company/topEmployees(num={num})/{id}` +`/company/youreFired(reason='{reason}')` + +where `{num}` is a placeholder for a number, `{id}` is a placeholder for an employee's id, and `{reason}` is a placeholder for a reason. diff --git a/docs/rsdl/rapid-rsdl-semantics.mdx b/docs/rsdl/rapid-rsdl-semantics.mdx index c13cd00d..10c16918 100644 --- a/docs/rsdl/rapid-rsdl-semantics.mdx +++ b/docs/rsdl/rapid-rsdl-semantics.mdx @@ -527,7 +527,7 @@ type Employee { An [Enumeration Type](rsdl-abnf#enumeration-type) is mapped to a CSDL EnumType. The enumeration members' values are automatically assigned. -```json +```rsdl enum employmentType { salaried hourly } ``` @@ -567,7 +567,7 @@ enum employmentType { salaried hourly } A [Flags Type](rsdl-abnf#enumeration-type), i.e an enumeration that starts with the keyword flags, is mapped to an CSDL EnumType with the `IsFlags` property set to `true`. The members' values are automatically assigned to powers of 2. -```json +```rsdl flags PhoneService { LandLine Cell Fax Internet Other } ``` diff --git a/package-lock.json b/package-lock.json index 1035d329..a966cf37 100644 --- a/package-lock.json +++ b/package-lock.json @@ -20421,6 +20421,7 @@ } }, "tools/rsdl/abnf": { + "name": "rsdl-abnf", "version": "0.0.0", "license": "Apache-2.0", "dependencies": { diff --git a/tools/rsdl/abnf/lib/grammar.js b/tools/rsdl/abnf/lib/grammar.js index 6317d331..8f3dfd70 100644 --- a/tools/rsdl/abnf/lib/grammar.js +++ b/tools/rsdl/abnf/lib/grammar.js @@ -5,16 +5,16 @@ module.exports = function grammar(){ // ``` // SUMMARY - // rules = 46 + // rules = 96 // udts = 0 - // opcodes = 411 + // opcodes = 910 // --- ABNF original opcodes - // ALT = 22 - // CAT = 68 - // REP = 44 - // RNM = 180 - // TLS = 54 - // TBS = 33 + // ALT = 49 + // CAT = 182 + // REP = 111 + // RNM = 376 + // TLS = 148 + // TBS = 34 // TRG = 10 // --- SABNF superset opcodes // UDT = 0 @@ -39,45 +39,95 @@ module.exports = function grammar(){ this.rules[4] = {name: 'structuredType', lower: 'structuredtype', index: 4, isBkr: false}; this.rules[5] = {name: 'structuredTypeMember', lower: 'structuredtypemember', index: 5, isBkr: false}; this.rules[6] = {name: 'property', lower: 'property', index: 6, isBkr: false}; - this.rules[7] = {name: 'propertyModifier', lower: 'propertymodifier', index: 7, isBkr: false}; - this.rules[8] = {name: 'typeReference', lower: 'typereference', index: 8, isBkr: false}; - this.rules[9] = {name: 'typeName', lower: 'typename', index: 9, isBkr: false}; - this.rules[10] = {name: 'builtInType', lower: 'builtintype', index: 10, isBkr: false}; - this.rules[11] = {name: 'edmType', lower: 'edmtype', index: 11, isBkr: false}; - this.rules[12] = {name: 'operation', lower: 'operation', index: 12, isBkr: false}; - this.rules[13] = {name: 'operationKind', lower: 'operationkind', index: 13, isBkr: false}; - this.rules[14] = {name: 'parameter', lower: 'parameter', index: 14, isBkr: false}; - this.rules[15] = {name: 'enumType', lower: 'enumtype', index: 15, isBkr: false}; - this.rules[16] = {name: 'enumMember', lower: 'enummember', index: 16, isBkr: false}; - this.rules[17] = {name: 'typeDefinition', lower: 'typedefinition', index: 17, isBkr: false}; - this.rules[18] = {name: 'service', lower: 'service', index: 18, isBkr: false}; - this.rules[19] = {name: 'serviceMember', lower: 'servicemember', index: 19, isBkr: false}; - this.rules[20] = {name: 'entitySet', lower: 'entityset', index: 20, isBkr: false}; - this.rules[21] = {name: 'singleton', lower: 'singleton', index: 21, isBkr: false}; - this.rules[22] = {name: 'serviceOperation', lower: 'serviceoperation', index: 22, isBkr: false}; - this.rules[23] = {name: 'annotations', lower: 'annotations', index: 23, isBkr: false}; - this.rules[24] = {name: 'annotation', lower: 'annotation', index: 24, isBkr: false}; - this.rules[25] = {name: 'annotationValue', lower: 'annotationvalue', index: 25, isBkr: false}; - this.rules[26] = {name: 'annotationProperty', lower: 'annotationproperty', index: 26, isBkr: false}; - this.rules[27] = {name: 'propertyName', lower: 'propertyname', index: 27, isBkr: false}; - this.rules[28] = {name: 'qualifiedName', lower: 'qualifiedname', index: 28, isBkr: false}; - this.rules[29] = {name: 'identifier', lower: 'identifier', index: 29, isBkr: false}; - this.rules[30] = {name: 'identInitial', lower: 'identinitial', index: 30, isBkr: false}; - this.rules[31] = {name: 'identSubsequent', lower: 'identsubsequent', index: 31, isBkr: false}; - this.rules[32] = {name: 'number', lower: 'number', index: 32, isBkr: false}; - this.rules[33] = {name: 'integer', lower: 'integer', index: 33, isBkr: false}; - this.rules[34] = {name: 'precision', lower: 'precision', index: 34, isBkr: false}; - this.rules[35] = {name: 'scale', lower: 'scale', index: 35, isBkr: false}; - this.rules[36] = {name: 'maxLength', lower: 'maxlength', index: 36, isBkr: false}; - this.rules[37] = {name: 'DOC-COMMENT', lower: 'doc-comment', index: 37, isBkr: false}; - this.rules[38] = {name: 'ALPHA', lower: 'alpha', index: 38, isBkr: false}; - this.rules[39] = {name: 'DIGIT', lower: 'digit', index: 39, isBkr: false}; - this.rules[40] = {name: 'CHAR', lower: 'char', index: 40, isBkr: false}; - this.rules[41] = {name: 'DQUOTE', lower: 'dquote', index: 41, isBkr: false}; - this.rules[42] = {name: 'ESCAPE', lower: 'escape', index: 42, isBkr: false}; - this.rules[43] = {name: 'OWS', lower: 'ows', index: 43, isBkr: false}; - this.rules[44] = {name: 'RWS', lower: 'rws', index: 44, isBkr: false}; - this.rules[45] = {name: 'WS', lower: 'ws', index: 45, isBkr: false}; + this.rules[7] = {name: 'singlePropertyDefinition', lower: 'singlepropertydefinition', index: 7, isBkr: false}; + this.rules[8] = {name: 'collectionPropertyDefinition', lower: 'collectionpropertydefinition', index: 8, isBkr: false}; + this.rules[9] = {name: 'propertyModifier', lower: 'propertymodifier', index: 9, isBkr: false}; + this.rules[10] = {name: 'singleTypeReference', lower: 'singletypereference', index: 10, isBkr: false}; + this.rules[11] = {name: 'collectionTypeReference', lower: 'collectiontypereference', index: 11, isBkr: false}; + this.rules[12] = {name: 'typeReference', lower: 'typereference', index: 12, isBkr: false}; + this.rules[13] = {name: 'typeName', lower: 'typename', index: 13, isBkr: false}; + this.rules[14] = {name: 'builtInType', lower: 'builtintype', index: 14, isBkr: false}; + this.rules[15] = {name: 'edmType', lower: 'edmtype', index: 15, isBkr: false}; + this.rules[16] = {name: 'operation', lower: 'operation', index: 16, isBkr: false}; + this.rules[17] = {name: 'operationKind', lower: 'operationkind', index: 17, isBkr: false}; + this.rules[18] = {name: 'parameter', lower: 'parameter', index: 18, isBkr: false}; + this.rules[19] = {name: 'enumType', lower: 'enumtype', index: 19, isBkr: false}; + this.rules[20] = {name: 'enumMember', lower: 'enummember', index: 20, isBkr: false}; + this.rules[21] = {name: 'typeDefinition', lower: 'typedefinition', index: 21, isBkr: false}; + this.rules[22] = {name: 'service', lower: 'service', index: 22, isBkr: false}; + this.rules[23] = {name: 'serviceMember', lower: 'servicemember', index: 23, isBkr: false}; + this.rules[24] = {name: 'entitySet', lower: 'entityset', index: 24, isBkr: false}; + this.rules[25] = {name: 'singleton', lower: 'singleton', index: 25, isBkr: false}; + this.rules[26] = {name: 'serviceOperation', lower: 'serviceoperation', index: 26, isBkr: false}; + this.rules[27] = {name: 'annotations', lower: 'annotations', index: 27, isBkr: false}; + this.rules[28] = {name: 'annotation', lower: 'annotation', index: 28, isBkr: false}; + this.rules[29] = {name: 'annotationValue', lower: 'annotationvalue', index: 29, isBkr: false}; + this.rules[30] = {name: 'annotationProperty', lower: 'annotationproperty', index: 30, isBkr: false}; + this.rules[31] = {name: 'propertyName', lower: 'propertyname', index: 31, isBkr: false}; + this.rules[32] = {name: 'primitivePropertyCapability', lower: 'primitivepropertycapability', index: 32, isBkr: false}; + this.rules[33] = {name: 'primitivePropertyCapabilities', lower: 'primitivepropertycapabilities', index: 33, isBkr: false}; + this.rules[34] = {name: 'singleNavigationCapability', lower: 'singlenavigationcapability', index: 34, isBkr: false}; + this.rules[35] = {name: 'singleNavigationCapabilities', lower: 'singlenavigationcapabilities', index: 35, isBkr: false}; + this.rules[36] = {name: 'collectionNavigationCapability', lower: 'collectionnavigationcapability', index: 36, isBkr: false}; + this.rules[37] = {name: 'collectionNavigationCapabilities', lower: 'collectionnavigationcapabilities', index: 37, isBkr: false}; + this.rules[38] = {name: 'paths', lower: 'paths', index: 38, isBkr: false}; + this.rules[39] = {name: 'path', lower: 'path', index: 39, isBkr: false}; + this.rules[40] = {name: 'propertySegment', lower: 'propertysegment', index: 40, isBkr: false}; + this.rules[41] = {name: 'pathSegment', lower: 'pathsegment', index: 41, isBkr: false}; + this.rules[42] = {name: 'castSegment', lower: 'castsegment', index: 42, isBkr: false}; + this.rules[43] = {name: 'keySegment', lower: 'keysegment', index: 43, isBkr: false}; + this.rules[44] = {name: 'keyProperty', lower: 'keyproperty', index: 44, isBkr: false}; + this.rules[45] = {name: 'serviceOperationSegment', lower: 'serviceoperationsegment', index: 45, isBkr: false}; + this.rules[46] = {name: 'parameters', lower: 'parameters', index: 46, isBkr: false}; + this.rules[47] = {name: 'parameterSpecification', lower: 'parameterspecification', index: 47, isBkr: false}; + this.rules[48] = {name: 'capabilities', lower: 'capabilities', index: 48, isBkr: false}; + this.rules[49] = {name: 'singlePathCapability', lower: 'singlepathcapability', index: 49, isBkr: false}; + this.rules[50] = {name: 'singlePathCapabilities', lower: 'singlepathcapabilities', index: 50, isBkr: false}; + this.rules[51] = {name: 'collectionPathCapability', lower: 'collectionpathcapability', index: 51, isBkr: false}; + this.rules[52] = {name: 'collectionPathCapabilities', lower: 'collectionpathcapabilities', index: 52, isBkr: false}; + this.rules[53] = {name: 'singleNavPathCapability', lower: 'singlenavpathcapability', index: 53, isBkr: false}; + this.rules[54] = {name: 'singleNavPathCapabilities', lower: 'singlenavpathcapabilities', index: 54, isBkr: false}; + this.rules[55] = {name: 'collectionNavPathCapability', lower: 'collectionnavpathcapability', index: 55, isBkr: false}; + this.rules[56] = {name: 'collectionNavPathCapabilities', lower: 'collectionnavpathcapabilities', index: 56, isBkr: false}; + this.rules[57] = {name: 'collectionCapability', lower: 'collectioncapability', index: 57, isBkr: false}; + this.rules[58] = {name: 'collectionCapabilities', lower: 'collectioncapabilities', index: 58, isBkr: false}; + this.rules[59] = {name: 'collectionNavCapability', lower: 'collectionnavcapability', index: 59, isBkr: false}; + this.rules[60] = {name: 'collectionNavCapabilities', lower: 'collectionnavcapabilities', index: 60, isBkr: false}; + this.rules[61] = {name: 'navCapability', lower: 'navcapability', index: 61, isBkr: false}; + this.rules[62] = {name: 'navCapabilities', lower: 'navcapabilities', index: 62, isBkr: false}; + this.rules[63] = {name: 'expandProperty', lower: 'expandproperty', index: 63, isBkr: false}; + this.rules[64] = {name: 'navigationProperty', lower: 'navigationproperty', index: 64, isBkr: false}; + this.rules[65] = {name: 'filterCapability', lower: 'filtercapability', index: 65, isBkr: false}; + this.rules[66] = {name: 'filterProperty', lower: 'filterproperty', index: 66, isBkr: false}; + this.rules[67] = {name: 'allProperties', lower: 'allproperties', index: 67, isBkr: false}; + this.rules[68] = {name: 'filterOptions', lower: 'filteroptions', index: 68, isBkr: false}; + this.rules[69] = {name: 'filterOperations', lower: 'filteroperations', index: 69, isBkr: false}; + this.rules[70] = {name: 'orderByCapability', lower: 'orderbycapability', index: 70, isBkr: false}; + this.rules[71] = {name: 'orderByProperties', lower: 'orderbyproperties', index: 71, isBkr: false}; + this.rules[72] = {name: 'orderByProperty', lower: 'orderbyproperty', index: 72, isBkr: false}; + this.rules[73] = {name: 'orderByDirection', lower: 'orderbydirection', index: 73, isBkr: false}; + this.rules[74] = {name: 'ascOrDesc', lower: 'ascordesc', index: 74, isBkr: false}; + this.rules[75] = {name: 'noOptions', lower: 'nooptions', index: 75, isBkr: false}; + this.rules[76] = {name: 'qualifiedName', lower: 'qualifiedname', index: 76, isBkr: false}; + this.rules[77] = {name: 'identifier', lower: 'identifier', index: 77, isBkr: false}; + this.rules[78] = {name: 'identInitial', lower: 'identinitial', index: 78, isBkr: false}; + this.rules[79] = {name: 'identSubsequent', lower: 'identsubsequent', index: 79, isBkr: false}; + this.rules[80] = {name: 'separator', lower: 'separator', index: 80, isBkr: false}; + this.rules[81] = {name: 'star', lower: 'star', index: 81, isBkr: false}; + this.rules[82] = {name: 'number', lower: 'number', index: 82, isBkr: false}; + this.rules[83] = {name: 'integer', lower: 'integer', index: 83, isBkr: false}; + this.rules[84] = {name: 'precision', lower: 'precision', index: 84, isBkr: false}; + this.rules[85] = {name: 'scale', lower: 'scale', index: 85, isBkr: false}; + this.rules[86] = {name: 'maxLength', lower: 'maxlength', index: 86, isBkr: false}; + this.rules[87] = {name: 'DOC-COMMENT', lower: 'doc-comment', index: 87, isBkr: false}; + this.rules[88] = {name: 'ALPHA', lower: 'alpha', index: 88, isBkr: false}; + this.rules[89] = {name: 'DIGIT', lower: 'digit', index: 89, isBkr: false}; + this.rules[90] = {name: 'CHAR', lower: 'char', index: 90, isBkr: false}; + this.rules[91] = {name: 'DQUOTE', lower: 'dquote', index: 91, isBkr: false}; + this.rules[92] = {name: 'ESCAPE', lower: 'escape', index: 92, isBkr: false}; + this.rules[93] = {name: 'OWS', lower: 'ows', index: 93, isBkr: false}; + this.rules[94] = {name: 'RWS', lower: 'rws', index: 94, isBkr: false}; + this.rules[95] = {name: 'WS', lower: 'ws', index: 95, isBkr: false}; /* UDTS */ this.udts = []; @@ -85,12 +135,12 @@ module.exports = function grammar(){ /* OPCODES */ /* model */ this.rules[0].opcodes = []; - this.rules[0].opcodes[0] = {type: 2, children: [1,2,6,8,15]};// CAT - this.rules[0].opcodes[1] = {type: 4, index: 43};// RNM(OWS) + this.rules[0].opcodes[0] = {type: 2, children: [1,2,6,8,15,19,23]};// CAT + this.rules[0].opcodes[1] = {type: 4, index: 93};// RNM(OWS) this.rules[0].opcodes[2] = {type: 3, min: 0, max: 1};// REP this.rules[0].opcodes[3] = {type: 2, children: [4,5]};// CAT this.rules[0].opcodes[4] = {type: 4, index: 1};// RNM(namespace) - this.rules[0].opcodes[5] = {type: 4, index: 44};// RNM(RWS) + this.rules[0].opcodes[5] = {type: 4, index: 94};// RNM(RWS) this.rules[0].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP this.rules[0].opcodes[7] = {type: 4, index: 2};// RNM(include) this.rules[0].opcodes[8] = {type: 3, min: 0, max: 1};// REP @@ -98,539 +148,1188 @@ module.exports = function grammar(){ this.rules[0].opcodes[10] = {type: 4, index: 3};// RNM(modelElement) this.rules[0].opcodes[11] = {type: 3, min: 0, max: Infinity};// REP this.rules[0].opcodes[12] = {type: 2, children: [13,14]};// CAT - this.rules[0].opcodes[13] = {type: 4, index: 44};// RNM(RWS) + this.rules[0].opcodes[13] = {type: 4, index: 94};// RNM(RWS) this.rules[0].opcodes[14] = {type: 4, index: 3};// RNM(modelElement) - this.rules[0].opcodes[15] = {type: 4, index: 43};// RNM(OWS) + this.rules[0].opcodes[15] = {type: 3, min: 0, max: 1};// REP + this.rules[0].opcodes[16] = {type: 2, children: [17,18]};// CAT + this.rules[0].opcodes[17] = {type: 4, index: 93};// RNM(OWS) + this.rules[0].opcodes[18] = {type: 4, index: 22};// RNM(service) + this.rules[0].opcodes[19] = {type: 3, min: 0, max: 1};// REP + this.rules[0].opcodes[20] = {type: 2, children: [21,22]};// CAT + this.rules[0].opcodes[21] = {type: 4, index: 93};// RNM(OWS) + this.rules[0].opcodes[22] = {type: 4, index: 38};// RNM(paths) + this.rules[0].opcodes[23] = {type: 4, index: 93};// RNM(OWS) /* namespace */ this.rules[1].opcodes = []; this.rules[1].opcodes[0] = {type: 2, children: [1,2,3]};// CAT this.rules[1].opcodes[1] = {type: 6, string: [110,97,109,101,115,112,97,99,101]};// TBS - this.rules[1].opcodes[2] = {type: 4, index: 44};// RNM(RWS) - this.rules[1].opcodes[3] = {type: 4, index: 28};// RNM(qualifiedName) + this.rules[1].opcodes[2] = {type: 4, index: 94};// RNM(RWS) + this.rules[1].opcodes[3] = {type: 4, index: 76};// RNM(qualifiedName) /* include */ this.rules[2].opcodes = []; this.rules[2].opcodes[0] = {type: 2, children: [1,2,3,4,6,7,8,9,10,11]};// CAT this.rules[2].opcodes[1] = {type: 6, string: [105,110,99,108,117,100,101]};// TBS - this.rules[2].opcodes[2] = {type: 4, index: 44};// RNM(RWS) - this.rules[2].opcodes[3] = {type: 4, index: 41};// RNM(DQUOTE) + this.rules[2].opcodes[2] = {type: 4, index: 94};// RNM(RWS) + this.rules[2].opcodes[3] = {type: 4, index: 91};// RNM(DQUOTE) this.rules[2].opcodes[4] = {type: 3, min: 1, max: Infinity};// REP - this.rules[2].opcodes[5] = {type: 4, index: 40};// RNM(CHAR) - this.rules[2].opcodes[6] = {type: 4, index: 41};// RNM(DQUOTE) - this.rules[2].opcodes[7] = {type: 4, index: 44};// RNM(RWS) + this.rules[2].opcodes[5] = {type: 4, index: 90};// RNM(CHAR) + this.rules[2].opcodes[6] = {type: 4, index: 91};// RNM(DQUOTE) + this.rules[2].opcodes[7] = {type: 4, index: 94};// RNM(RWS) this.rules[2].opcodes[8] = {type: 6, string: [97,115]};// TBS - this.rules[2].opcodes[9] = {type: 4, index: 44};// RNM(RWS) - this.rules[2].opcodes[10] = {type: 4, index: 29};// RNM(identifier) - this.rules[2].opcodes[11] = {type: 4, index: 44};// RNM(RWS) + this.rules[2].opcodes[9] = {type: 4, index: 94};// RNM(RWS) + this.rules[2].opcodes[10] = {type: 4, index: 77};// RNM(identifier) + this.rules[2].opcodes[11] = {type: 4, index: 94};// RNM(RWS) /* modelElement */ this.rules[3].opcodes = []; - this.rules[3].opcodes[0] = {type: 1, children: [1,2,3,4]};// ALT + this.rules[3].opcodes[0] = {type: 1, children: [1,2,3]};// ALT this.rules[3].opcodes[1] = {type: 4, index: 4};// RNM(structuredType) - this.rules[3].opcodes[2] = {type: 4, index: 15};// RNM(enumType) - this.rules[3].opcodes[3] = {type: 4, index: 17};// RNM(typeDefinition) - this.rules[3].opcodes[4] = {type: 4, index: 18};// RNM(service) + this.rules[3].opcodes[2] = {type: 4, index: 19};// RNM(enumType) + this.rules[3].opcodes[3] = {type: 4, index: 21};// RNM(typeDefinition) /* structuredType */ this.rules[4].opcodes = []; this.rules[4].opcodes[0] = {type: 2, children: [1,2,6,7,8,9,14,15,16,20,21]};// CAT - this.rules[4].opcodes[1] = {type: 4, index: 23};// RNM(annotations) + this.rules[4].opcodes[1] = {type: 4, index: 27};// RNM(annotations) this.rules[4].opcodes[2] = {type: 3, min: 0, max: 1};// REP this.rules[4].opcodes[3] = {type: 2, children: [4,5]};// CAT this.rules[4].opcodes[4] = {type: 6, string: [97,98,115,116,114,97,99,116]};// TBS - this.rules[4].opcodes[5] = {type: 4, index: 44};// RNM(RWS) + this.rules[4].opcodes[5] = {type: 4, index: 94};// RNM(RWS) this.rules[4].opcodes[6] = {type: 6, string: [116,121,112,101]};// TBS - this.rules[4].opcodes[7] = {type: 4, index: 44};// RNM(RWS) - this.rules[4].opcodes[8] = {type: 4, index: 29};// RNM(identifier) + this.rules[4].opcodes[7] = {type: 4, index: 94};// RNM(RWS) + this.rules[4].opcodes[8] = {type: 4, index: 77};// RNM(identifier) this.rules[4].opcodes[9] = {type: 3, min: 0, max: 1};// REP this.rules[4].opcodes[10] = {type: 2, children: [11,12,13]};// CAT this.rules[4].opcodes[11] = {type: 6, string: [101,120,116,101,110,100,115]};// TBS - this.rules[4].opcodes[12] = {type: 4, index: 44};// RNM(RWS) - this.rules[4].opcodes[13] = {type: 4, index: 28};// RNM(qualifiedName) - this.rules[4].opcodes[14] = {type: 4, index: 43};// RNM(OWS) + this.rules[4].opcodes[12] = {type: 4, index: 94};// RNM(RWS) + this.rules[4].opcodes[13] = {type: 4, index: 76};// RNM(qualifiedName) + this.rules[4].opcodes[14] = {type: 4, index: 93};// RNM(OWS) this.rules[4].opcodes[15] = {type: 7, string: [123]};// TLS this.rules[4].opcodes[16] = {type: 3, min: 0, max: Infinity};// REP this.rules[4].opcodes[17] = {type: 2, children: [18,19]};// CAT - this.rules[4].opcodes[18] = {type: 4, index: 43};// RNM(OWS) + this.rules[4].opcodes[18] = {type: 4, index: 93};// RNM(OWS) this.rules[4].opcodes[19] = {type: 4, index: 5};// RNM(structuredTypeMember) - this.rules[4].opcodes[20] = {type: 4, index: 43};// RNM(OWS) + this.rules[4].opcodes[20] = {type: 4, index: 93};// RNM(OWS) this.rules[4].opcodes[21] = {type: 7, string: [125]};// TLS /* structuredTypeMember */ this.rules[5].opcodes = []; this.rules[5].opcodes[0] = {type: 1, children: [1,2]};// ALT this.rules[5].opcodes[1] = {type: 4, index: 6};// RNM(property) - this.rules[5].opcodes[2] = {type: 4, index: 12};// RNM(operation) + this.rules[5].opcodes[2] = {type: 4, index: 16};// RNM(operation) /* property */ this.rules[6].opcodes = []; - this.rules[6].opcodes[0] = {type: 2, children: [1,2,6,7,8,9,10]};// CAT - this.rules[6].opcodes[1] = {type: 4, index: 23};// RNM(annotations) - this.rules[6].opcodes[2] = {type: 3, min: 0, max: 1};// REP - this.rules[6].opcodes[3] = {type: 2, children: [4,5]};// CAT - this.rules[6].opcodes[4] = {type: 4, index: 7};// RNM(propertyModifier) - this.rules[6].opcodes[5] = {type: 4, index: 44};// RNM(RWS) - this.rules[6].opcodes[6] = {type: 4, index: 29};// RNM(identifier) - this.rules[6].opcodes[7] = {type: 4, index: 43};// RNM(OWS) - this.rules[6].opcodes[8] = {type: 7, string: [58]};// TLS - this.rules[6].opcodes[9] = {type: 4, index: 43};// RNM(OWS) - this.rules[6].opcodes[10] = {type: 4, index: 8};// RNM(typeReference) + this.rules[6].opcodes[0] = {type: 1, children: [1,9]};// ALT + this.rules[6].opcodes[1] = {type: 2, children: [2,3]};// CAT + this.rules[6].opcodes[2] = {type: 4, index: 7};// RNM(singlePropertyDefinition) + this.rules[6].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[6].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[6].opcodes[5] = {type: 4, index: 93};// RNM(OWS) + this.rules[6].opcodes[6] = {type: 1, children: [7,8]};// ALT + this.rules[6].opcodes[7] = {type: 4, index: 33};// RNM(primitivePropertyCapabilities) + this.rules[6].opcodes[8] = {type: 4, index: 35};// RNM(singleNavigationCapabilities) + this.rules[6].opcodes[9] = {type: 2, children: [10,11]};// CAT + this.rules[6].opcodes[10] = {type: 4, index: 8};// RNM(collectionPropertyDefinition) + this.rules[6].opcodes[11] = {type: 3, min: 0, max: 1};// REP + this.rules[6].opcodes[12] = {type: 2, children: [13,14]};// CAT + this.rules[6].opcodes[13] = {type: 4, index: 93};// RNM(OWS) + this.rules[6].opcodes[14] = {type: 1, children: [15,16]};// ALT + this.rules[6].opcodes[15] = {type: 4, index: 58};// RNM(collectionCapabilities) + this.rules[6].opcodes[16] = {type: 4, index: 37};// RNM(collectionNavigationCapabilities) - /* propertyModifier */ + /* singlePropertyDefinition */ this.rules[7].opcodes = []; - this.rules[7].opcodes[0] = {type: 6, string: [107,101,121]};// TBS + this.rules[7].opcodes[0] = {type: 2, children: [1,2,6,7,8,9,10]};// CAT + this.rules[7].opcodes[1] = {type: 4, index: 27};// RNM(annotations) + this.rules[7].opcodes[2] = {type: 3, min: 0, max: 1};// REP + this.rules[7].opcodes[3] = {type: 2, children: [4,5]};// CAT + this.rules[7].opcodes[4] = {type: 4, index: 9};// RNM(propertyModifier) + this.rules[7].opcodes[5] = {type: 4, index: 94};// RNM(RWS) + this.rules[7].opcodes[6] = {type: 4, index: 77};// RNM(identifier) + this.rules[7].opcodes[7] = {type: 4, index: 93};// RNM(OWS) + this.rules[7].opcodes[8] = {type: 7, string: [58]};// TLS + this.rules[7].opcodes[9] = {type: 4, index: 93};// RNM(OWS) + this.rules[7].opcodes[10] = {type: 4, index: 10};// RNM(singleTypeReference) - /* typeReference */ + /* collectionPropertyDefinition */ this.rules[8].opcodes = []; - this.rules[8].opcodes[0] = {type: 1, children: [1,5]};// ALT - this.rules[8].opcodes[1] = {type: 2, children: [2,3]};// CAT - this.rules[8].opcodes[2] = {type: 4, index: 9};// RNM(typeName) - this.rules[8].opcodes[3] = {type: 3, min: 0, max: 1};// REP - this.rules[8].opcodes[4] = {type: 7, string: [63]};// TLS - this.rules[8].opcodes[5] = {type: 2, children: [6,7,8,10]};// CAT - this.rules[8].opcodes[6] = {type: 7, string: [91]};// TLS - this.rules[8].opcodes[7] = {type: 4, index: 9};// RNM(typeName) - this.rules[8].opcodes[8] = {type: 3, min: 0, max: 1};// REP - this.rules[8].opcodes[9] = {type: 7, string: [63]};// TLS - this.rules[8].opcodes[10] = {type: 7, string: [93]};// TLS + this.rules[8].opcodes[0] = {type: 2, children: [1,2,3,4,5,6]};// CAT + this.rules[8].opcodes[1] = {type: 4, index: 27};// RNM(annotations) + this.rules[8].opcodes[2] = {type: 4, index: 77};// RNM(identifier) + this.rules[8].opcodes[3] = {type: 4, index: 93};// RNM(OWS) + this.rules[8].opcodes[4] = {type: 7, string: [58]};// TLS + this.rules[8].opcodes[5] = {type: 4, index: 93};// RNM(OWS) + this.rules[8].opcodes[6] = {type: 4, index: 11};// RNM(collectionTypeReference) - /* typeName */ + /* propertyModifier */ this.rules[9].opcodes = []; - this.rules[9].opcodes[0] = {type: 1, children: [1,2,3]};// ALT - this.rules[9].opcodes[1] = {type: 4, index: 10};// RNM(builtInType) - this.rules[9].opcodes[2] = {type: 4, index: 11};// RNM(edmType) - this.rules[9].opcodes[3] = {type: 4, index: 28};// RNM(qualifiedName) + this.rules[9].opcodes[0] = {type: 6, string: [107,101,121]};// TBS - /* builtInType */ + /* singleTypeReference */ this.rules[10].opcodes = []; - this.rules[10].opcodes[0] = {type: 1, children: [1,2,3,4,13,14,15,16,23]};// ALT - this.rules[10].opcodes[1] = {type: 6, string: [66,111,111,108,101,97,110]};// TBS - this.rules[10].opcodes[2] = {type: 6, string: [68,97,116,101,84,105,109,101]};// TBS - this.rules[10].opcodes[3] = {type: 6, string: [68,97,116,101]};// TBS - this.rules[10].opcodes[4] = {type: 2, children: [5,6]};// CAT - this.rules[10].opcodes[5] = {type: 6, string: [68,101,99,105,109,97,108]};// TBS - this.rules[10].opcodes[6] = {type: 3, min: 0, max: 1};// REP - this.rules[10].opcodes[7] = {type: 2, children: [8,9,10,11,12]};// CAT - this.rules[10].opcodes[8] = {type: 7, string: [40]};// TLS - this.rules[10].opcodes[9] = {type: 4, index: 34};// RNM(precision) - this.rules[10].opcodes[10] = {type: 7, string: [44]};// TLS - this.rules[10].opcodes[11] = {type: 4, index: 35};// RNM(scale) - this.rules[10].opcodes[12] = {type: 7, string: [41]};// TLS - this.rules[10].opcodes[13] = {type: 6, string: [68,111,117,98,108,101]};// TBS - this.rules[10].opcodes[14] = {type: 6, string: [68,117,114,97,116,105,111,110]};// TBS - this.rules[10].opcodes[15] = {type: 6, string: [73,110,116,101,103,101,114]};// TBS - this.rules[10].opcodes[16] = {type: 2, children: [17,18]};// CAT - this.rules[10].opcodes[17] = {type: 6, string: [83,116,114,105,110,103]};// TBS - this.rules[10].opcodes[18] = {type: 3, min: 0, max: 1};// REP - this.rules[10].opcodes[19] = {type: 2, children: [20,21,22]};// CAT - this.rules[10].opcodes[20] = {type: 7, string: [40]};// TLS - this.rules[10].opcodes[21] = {type: 4, index: 36};// RNM(maxLength) - this.rules[10].opcodes[22] = {type: 7, string: [41]};// TLS - this.rules[10].opcodes[23] = {type: 6, string: [84,105,109,101,79,102,68,97,121]};// TBS + this.rules[10].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[10].opcodes[1] = {type: 4, index: 13};// RNM(typeName) + this.rules[10].opcodes[2] = {type: 3, min: 0, max: 1};// REP + this.rules[10].opcodes[3] = {type: 7, string: [63]};// TLS - /* edmType */ + /* collectionTypeReference */ this.rules[11].opcodes = []; - this.rules[11].opcodes[0] = {type: 2, children: [1,2,3]};// CAT - this.rules[11].opcodes[1] = {type: 6, string: [69,100,109]};// TBS - this.rules[11].opcodes[2] = {type: 7, string: [46]};// TLS - this.rules[11].opcodes[3] = {type: 4, index: 29};// RNM(identifier) + this.rules[11].opcodes[0] = {type: 2, children: [1,2,3,5]};// CAT + this.rules[11].opcodes[1] = {type: 7, string: [91]};// TLS + this.rules[11].opcodes[2] = {type: 4, index: 13};// RNM(typeName) + this.rules[11].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[11].opcodes[4] = {type: 7, string: [63]};// TLS + this.rules[11].opcodes[5] = {type: 7, string: [93]};// TLS - /* operation */ + /* typeReference */ this.rules[12].opcodes = []; - this.rules[12].opcodes[0] = {type: 2, children: [1,2,3,4,5,6,7,8,18,19]};// CAT - this.rules[12].opcodes[1] = {type: 4, index: 23};// RNM(annotations) - this.rules[12].opcodes[2] = {type: 4, index: 13};// RNM(operationKind) - this.rules[12].opcodes[3] = {type: 4, index: 44};// RNM(RWS) - this.rules[12].opcodes[4] = {type: 4, index: 29};// RNM(identifier) - this.rules[12].opcodes[5] = {type: 4, index: 43};// RNM(OWS) - this.rules[12].opcodes[6] = {type: 7, string: [40]};// TLS - this.rules[12].opcodes[7] = {type: 4, index: 43};// RNM(OWS) - this.rules[12].opcodes[8] = {type: 3, min: 0, max: 1};// REP - this.rules[12].opcodes[9] = {type: 2, children: [10,11,17]};// CAT - this.rules[12].opcodes[10] = {type: 4, index: 14};// RNM(parameter) - this.rules[12].opcodes[11] = {type: 3, min: 0, max: Infinity};// REP - this.rules[12].opcodes[12] = {type: 2, children: [13,14,15,16]};// CAT - this.rules[12].opcodes[13] = {type: 4, index: 43};// RNM(OWS) - this.rules[12].opcodes[14] = {type: 7, string: [44]};// TLS - this.rules[12].opcodes[15] = {type: 4, index: 43};// RNM(OWS) - this.rules[12].opcodes[16] = {type: 4, index: 14};// RNM(parameter) - this.rules[12].opcodes[17] = {type: 4, index: 43};// RNM(OWS) - this.rules[12].opcodes[18] = {type: 7, string: [41]};// TLS - this.rules[12].opcodes[19] = {type: 3, min: 0, max: 1};// REP - this.rules[12].opcodes[20] = {type: 2, children: [21,22,23,24,25]};// CAT - this.rules[12].opcodes[21] = {type: 4, index: 43};// RNM(OWS) - this.rules[12].opcodes[22] = {type: 7, string: [58]};// TLS - this.rules[12].opcodes[23] = {type: 4, index: 43};// RNM(OWS) - this.rules[12].opcodes[24] = {type: 4, index: 23};// RNM(annotations) - this.rules[12].opcodes[25] = {type: 4, index: 8};// RNM(typeReference) + this.rules[12].opcodes[0] = {type: 1, children: [1,2]};// ALT + this.rules[12].opcodes[1] = {type: 4, index: 10};// RNM(singleTypeReference) + this.rules[12].opcodes[2] = {type: 4, index: 11};// RNM(collectionTypeReference) - /* operationKind */ + /* typeName */ this.rules[13].opcodes = []; - this.rules[13].opcodes[0] = {type: 1, children: [1,2]};// ALT - this.rules[13].opcodes[1] = {type: 6, string: [97,99,116,105,111,110]};// TBS - this.rules[13].opcodes[2] = {type: 6, string: [102,117,110,99,116,105,111,110]};// TBS + this.rules[13].opcodes[0] = {type: 1, children: [1,2,3]};// ALT + this.rules[13].opcodes[1] = {type: 4, index: 14};// RNM(builtInType) + this.rules[13].opcodes[2] = {type: 4, index: 15};// RNM(edmType) + this.rules[13].opcodes[3] = {type: 4, index: 76};// RNM(qualifiedName) - /* parameter */ + /* builtInType */ this.rules[14].opcodes = []; - this.rules[14].opcodes[0] = {type: 2, children: [1,2,3,4,5,6]};// CAT - this.rules[14].opcodes[1] = {type: 4, index: 23};// RNM(annotations) - this.rules[14].opcodes[2] = {type: 4, index: 29};// RNM(identifier) - this.rules[14].opcodes[3] = {type: 4, index: 43};// RNM(OWS) - this.rules[14].opcodes[4] = {type: 7, string: [58]};// TLS - this.rules[14].opcodes[5] = {type: 4, index: 43};// RNM(OWS) - this.rules[14].opcodes[6] = {type: 4, index: 8};// RNM(typeReference) + this.rules[14].opcodes[0] = {type: 1, children: [1,2,3,4,13,14,15,16,23]};// ALT + this.rules[14].opcodes[1] = {type: 6, string: [66,111,111,108,101,97,110]};// TBS + this.rules[14].opcodes[2] = {type: 6, string: [68,97,116,101,84,105,109,101]};// TBS + this.rules[14].opcodes[3] = {type: 6, string: [68,97,116,101]};// TBS + this.rules[14].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[14].opcodes[5] = {type: 6, string: [68,101,99,105,109,97,108]};// TBS + this.rules[14].opcodes[6] = {type: 3, min: 0, max: 1};// REP + this.rules[14].opcodes[7] = {type: 2, children: [8,9,10,11,12]};// CAT + this.rules[14].opcodes[8] = {type: 7, string: [40]};// TLS + this.rules[14].opcodes[9] = {type: 4, index: 84};// RNM(precision) + this.rules[14].opcodes[10] = {type: 7, string: [44]};// TLS + this.rules[14].opcodes[11] = {type: 4, index: 85};// RNM(scale) + this.rules[14].opcodes[12] = {type: 7, string: [41]};// TLS + this.rules[14].opcodes[13] = {type: 6, string: [68,111,117,98,108,101]};// TBS + this.rules[14].opcodes[14] = {type: 6, string: [68,117,114,97,116,105,111,110]};// TBS + this.rules[14].opcodes[15] = {type: 6, string: [73,110,116,101,103,101,114]};// TBS + this.rules[14].opcodes[16] = {type: 2, children: [17,18]};// CAT + this.rules[14].opcodes[17] = {type: 6, string: [83,116,114,105,110,103]};// TBS + this.rules[14].opcodes[18] = {type: 3, min: 0, max: 1};// REP + this.rules[14].opcodes[19] = {type: 2, children: [20,21,22]};// CAT + this.rules[14].opcodes[20] = {type: 7, string: [40]};// TLS + this.rules[14].opcodes[21] = {type: 4, index: 86};// RNM(maxLength) + this.rules[14].opcodes[22] = {type: 7, string: [41]};// TLS + this.rules[14].opcodes[23] = {type: 6, string: [84,105,109,101,79,102,68,97,121]};// TBS - /* enumType */ + /* edmType */ this.rules[15].opcodes = []; - this.rules[15].opcodes[0] = {type: 2, children: [1,2,5,6,7,8,9,10,12]};// CAT - this.rules[15].opcodes[1] = {type: 4, index: 23};// RNM(annotations) - this.rules[15].opcodes[2] = {type: 1, children: [3,4]};// ALT - this.rules[15].opcodes[3] = {type: 6, string: [101,110,117,109]};// TBS - this.rules[15].opcodes[4] = {type: 6, string: [102,108,97,103,115]};// TBS - this.rules[15].opcodes[5] = {type: 4, index: 44};// RNM(RWS) - this.rules[15].opcodes[6] = {type: 4, index: 29};// RNM(identifier) - this.rules[15].opcodes[7] = {type: 4, index: 43};// RNM(OWS) - this.rules[15].opcodes[8] = {type: 7, string: [123]};// TLS - this.rules[15].opcodes[9] = {type: 4, index: 43};// RNM(OWS) - this.rules[15].opcodes[10] = {type: 3, min: 1, max: Infinity};// REP - this.rules[15].opcodes[11] = {type: 4, index: 16};// RNM(enumMember) - this.rules[15].opcodes[12] = {type: 7, string: [125]};// TLS + this.rules[15].opcodes[0] = {type: 2, children: [1,2,3]};// CAT + this.rules[15].opcodes[1] = {type: 6, string: [69,100,109]};// TBS + this.rules[15].opcodes[2] = {type: 7, string: [46]};// TLS + this.rules[15].opcodes[3] = {type: 4, index: 77};// RNM(identifier) - /* enumMember */ + /* operation */ this.rules[16].opcodes = []; - this.rules[16].opcodes[0] = {type: 2, children: [1,2,3]};// CAT - this.rules[16].opcodes[1] = {type: 4, index: 23};// RNM(annotations) - this.rules[16].opcodes[2] = {type: 4, index: 29};// RNM(identifier) - this.rules[16].opcodes[3] = {type: 4, index: 43};// RNM(OWS) + this.rules[16].opcodes[0] = {type: 2, children: [1,2,3,4,5,6,7,8,18,19,26]};// CAT + this.rules[16].opcodes[1] = {type: 4, index: 27};// RNM(annotations) + this.rules[16].opcodes[2] = {type: 4, index: 17};// RNM(operationKind) + this.rules[16].opcodes[3] = {type: 4, index: 94};// RNM(RWS) + this.rules[16].opcodes[4] = {type: 4, index: 77};// RNM(identifier) + this.rules[16].opcodes[5] = {type: 4, index: 93};// RNM(OWS) + this.rules[16].opcodes[6] = {type: 7, string: [40]};// TLS + this.rules[16].opcodes[7] = {type: 4, index: 93};// RNM(OWS) + this.rules[16].opcodes[8] = {type: 3, min: 0, max: 1};// REP + this.rules[16].opcodes[9] = {type: 2, children: [10,11,17]};// CAT + this.rules[16].opcodes[10] = {type: 4, index: 18};// RNM(parameter) + this.rules[16].opcodes[11] = {type: 3, min: 0, max: Infinity};// REP + this.rules[16].opcodes[12] = {type: 2, children: [13,14,15,16]};// CAT + this.rules[16].opcodes[13] = {type: 4, index: 93};// RNM(OWS) + this.rules[16].opcodes[14] = {type: 7, string: [44]};// TLS + this.rules[16].opcodes[15] = {type: 4, index: 93};// RNM(OWS) + this.rules[16].opcodes[16] = {type: 4, index: 18};// RNM(parameter) + this.rules[16].opcodes[17] = {type: 4, index: 93};// RNM(OWS) + this.rules[16].opcodes[18] = {type: 7, string: [41]};// TLS + this.rules[16].opcodes[19] = {type: 3, min: 0, max: 1};// REP + this.rules[16].opcodes[20] = {type: 2, children: [21,22,23,24,25]};// CAT + this.rules[16].opcodes[21] = {type: 4, index: 93};// RNM(OWS) + this.rules[16].opcodes[22] = {type: 7, string: [58]};// TLS + this.rules[16].opcodes[23] = {type: 4, index: 93};// RNM(OWS) + this.rules[16].opcodes[24] = {type: 4, index: 27};// RNM(annotations) + this.rules[16].opcodes[25] = {type: 4, index: 12};// RNM(typeReference) + this.rules[16].opcodes[26] = {type: 3, min: 0, max: 1};// REP + this.rules[16].opcodes[27] = {type: 2, children: [28,29]};// CAT + this.rules[16].opcodes[28] = {type: 4, index: 80};// RNM(separator) + this.rules[16].opcodes[29] = {type: 4, index: 60};// RNM(collectionNavCapabilities) - /* typeDefinition */ + /* operationKind */ this.rules[17].opcodes = []; - this.rules[17].opcodes[0] = {type: 2, children: [1,2,3,4,5,6,7,8]};// CAT - this.rules[17].opcodes[1] = {type: 4, index: 23};// RNM(annotations) - this.rules[17].opcodes[2] = {type: 6, string: [116,121,112,101,100,101,102]};// TBS - this.rules[17].opcodes[3] = {type: 4, index: 44};// RNM(RWS) - this.rules[17].opcodes[4] = {type: 4, index: 29};// RNM(identifier) - this.rules[17].opcodes[5] = {type: 4, index: 43};// RNM(OWS) - this.rules[17].opcodes[6] = {type: 7, string: [58]};// TLS - this.rules[17].opcodes[7] = {type: 4, index: 43};// RNM(OWS) - this.rules[17].opcodes[8] = {type: 1, children: [9,10]};// ALT - this.rules[17].opcodes[9] = {type: 4, index: 10};// RNM(builtInType) - this.rules[17].opcodes[10] = {type: 4, index: 11};// RNM(edmType) + this.rules[17].opcodes[0] = {type: 1, children: [1,2]};// ALT + this.rules[17].opcodes[1] = {type: 6, string: [97,99,116,105,111,110]};// TBS + this.rules[17].opcodes[2] = {type: 6, string: [102,117,110,99,116,105,111,110]};// TBS - /* service */ + /* parameter */ this.rules[18].opcodes = []; - this.rules[18].opcodes[0] = {type: 2, children: [1,2,3,7,8,9,10,11,15,16]};// CAT - this.rules[18].opcodes[1] = {type: 4, index: 23};// RNM(annotations) - this.rules[18].opcodes[2] = {type: 6, string: [115,101,114,118,105,99,101]};// TBS - this.rules[18].opcodes[3] = {type: 3, min: 0, max: 1};// REP - this.rules[18].opcodes[4] = {type: 2, children: [5,6]};// CAT - this.rules[18].opcodes[5] = {type: 4, index: 44};// RNM(RWS) - this.rules[18].opcodes[6] = {type: 4, index: 29};// RNM(identifier) - this.rules[18].opcodes[7] = {type: 4, index: 43};// RNM(OWS) - this.rules[18].opcodes[8] = {type: 7, string: [123]};// TLS - this.rules[18].opcodes[9] = {type: 4, index: 43};// RNM(OWS) - this.rules[18].opcodes[10] = {type: 4, index: 19};// RNM(serviceMember) - this.rules[18].opcodes[11] = {type: 3, min: 0, max: Infinity};// REP - this.rules[18].opcodes[12] = {type: 2, children: [13,14]};// CAT - this.rules[18].opcodes[13] = {type: 4, index: 44};// RNM(RWS) - this.rules[18].opcodes[14] = {type: 4, index: 19};// RNM(serviceMember) - this.rules[18].opcodes[15] = {type: 4, index: 43};// RNM(OWS) - this.rules[18].opcodes[16] = {type: 7, string: [125]};// TLS + this.rules[18].opcodes[0] = {type: 2, children: [1,2,3,4,5,6]};// CAT + this.rules[18].opcodes[1] = {type: 4, index: 27};// RNM(annotations) + this.rules[18].opcodes[2] = {type: 4, index: 77};// RNM(identifier) + this.rules[18].opcodes[3] = {type: 4, index: 93};// RNM(OWS) + this.rules[18].opcodes[4] = {type: 7, string: [58]};// TLS + this.rules[18].opcodes[5] = {type: 4, index: 93};// RNM(OWS) + this.rules[18].opcodes[6] = {type: 4, index: 12};// RNM(typeReference) - /* serviceMember */ + /* enumType */ this.rules[19].opcodes = []; - this.rules[19].opcodes[0] = {type: 2, children: [1,2]};// CAT - this.rules[19].opcodes[1] = {type: 4, index: 23};// RNM(annotations) - this.rules[19].opcodes[2] = {type: 1, children: [3,4,5]};// ALT - this.rules[19].opcodes[3] = {type: 4, index: 20};// RNM(entitySet) - this.rules[19].opcodes[4] = {type: 4, index: 21};// RNM(singleton) - this.rules[19].opcodes[5] = {type: 4, index: 22};// RNM(serviceOperation) + this.rules[19].opcodes[0] = {type: 2, children: [1,2,5,6,7,8,9,10,12]};// CAT + this.rules[19].opcodes[1] = {type: 4, index: 27};// RNM(annotations) + this.rules[19].opcodes[2] = {type: 1, children: [3,4]};// ALT + this.rules[19].opcodes[3] = {type: 6, string: [101,110,117,109]};// TBS + this.rules[19].opcodes[4] = {type: 6, string: [102,108,97,103,115]};// TBS + this.rules[19].opcodes[5] = {type: 4, index: 94};// RNM(RWS) + this.rules[19].opcodes[6] = {type: 4, index: 77};// RNM(identifier) + this.rules[19].opcodes[7] = {type: 4, index: 93};// RNM(OWS) + this.rules[19].opcodes[8] = {type: 7, string: [123]};// TLS + this.rules[19].opcodes[9] = {type: 4, index: 93};// RNM(OWS) + this.rules[19].opcodes[10] = {type: 3, min: 1, max: Infinity};// REP + this.rules[19].opcodes[11] = {type: 4, index: 20};// RNM(enumMember) + this.rules[19].opcodes[12] = {type: 7, string: [125]};// TLS - /* entitySet */ + /* enumMember */ this.rules[20].opcodes = []; - this.rules[20].opcodes[0] = {type: 2, children: [1,2,3,4,5,6,7]};// CAT - this.rules[20].opcodes[1] = {type: 4, index: 29};// RNM(identifier) - this.rules[20].opcodes[2] = {type: 4, index: 43};// RNM(OWS) - this.rules[20].opcodes[3] = {type: 7, string: [58]};// TLS - this.rules[20].opcodes[4] = {type: 4, index: 43};// RNM(OWS) - this.rules[20].opcodes[5] = {type: 7, string: [91]};// TLS - this.rules[20].opcodes[6] = {type: 4, index: 28};// RNM(qualifiedName) - this.rules[20].opcodes[7] = {type: 7, string: [93]};// TLS + this.rules[20].opcodes[0] = {type: 2, children: [1,2,3]};// CAT + this.rules[20].opcodes[1] = {type: 4, index: 27};// RNM(annotations) + this.rules[20].opcodes[2] = {type: 4, index: 77};// RNM(identifier) + this.rules[20].opcodes[3] = {type: 4, index: 93};// RNM(OWS) - /* singleton */ + /* typeDefinition */ this.rules[21].opcodes = []; - this.rules[21].opcodes[0] = {type: 2, children: [1,2,3,4,5]};// CAT - this.rules[21].opcodes[1] = {type: 4, index: 29};// RNM(identifier) - this.rules[21].opcodes[2] = {type: 4, index: 43};// RNM(OWS) - this.rules[21].opcodes[3] = {type: 7, string: [58]};// TLS - this.rules[21].opcodes[4] = {type: 4, index: 43};// RNM(OWS) - this.rules[21].opcodes[5] = {type: 4, index: 28};// RNM(qualifiedName) + this.rules[21].opcodes[0] = {type: 2, children: [1,2,3,4,5,6,7,8]};// CAT + this.rules[21].opcodes[1] = {type: 4, index: 27};// RNM(annotations) + this.rules[21].opcodes[2] = {type: 6, string: [116,121,112,101,100,101,102]};// TBS + this.rules[21].opcodes[3] = {type: 4, index: 94};// RNM(RWS) + this.rules[21].opcodes[4] = {type: 4, index: 77};// RNM(identifier) + this.rules[21].opcodes[5] = {type: 4, index: 93};// RNM(OWS) + this.rules[21].opcodes[6] = {type: 7, string: [58]};// TLS + this.rules[21].opcodes[7] = {type: 4, index: 93};// RNM(OWS) + this.rules[21].opcodes[8] = {type: 1, children: [9,10]};// ALT + this.rules[21].opcodes[9] = {type: 4, index: 14};// RNM(builtInType) + this.rules[21].opcodes[10] = {type: 4, index: 15};// RNM(edmType) - /* serviceOperation */ + /* service */ this.rules[22].opcodes = []; - this.rules[22].opcodes[0] = {type: 2, children: [1,2,3,4,5,6,7,17,18]};// CAT - this.rules[22].opcodes[1] = {type: 4, index: 13};// RNM(operationKind) - this.rules[22].opcodes[2] = {type: 4, index: 44};// RNM(RWS) - this.rules[22].opcodes[3] = {type: 4, index: 29};// RNM(identifier) - this.rules[22].opcodes[4] = {type: 4, index: 43};// RNM(OWS) - this.rules[22].opcodes[5] = {type: 7, string: [40]};// TLS - this.rules[22].opcodes[6] = {type: 4, index: 43};// RNM(OWS) - this.rules[22].opcodes[7] = {type: 3, min: 0, max: 1};// REP - this.rules[22].opcodes[8] = {type: 2, children: [9,10,16]};// CAT - this.rules[22].opcodes[9] = {type: 4, index: 14};// RNM(parameter) - this.rules[22].opcodes[10] = {type: 3, min: 0, max: Infinity};// REP - this.rules[22].opcodes[11] = {type: 2, children: [12,13,14,15]};// CAT - this.rules[22].opcodes[12] = {type: 4, index: 43};// RNM(OWS) - this.rules[22].opcodes[13] = {type: 7, string: [44]};// TLS - this.rules[22].opcodes[14] = {type: 4, index: 43};// RNM(OWS) - this.rules[22].opcodes[15] = {type: 4, index: 14};// RNM(parameter) - this.rules[22].opcodes[16] = {type: 4, index: 43};// RNM(OWS) - this.rules[22].opcodes[17] = {type: 7, string: [41]};// TLS - this.rules[22].opcodes[18] = {type: 3, min: 0, max: 1};// REP - this.rules[22].opcodes[19] = {type: 2, children: [20,21,22,23,24]};// CAT - this.rules[22].opcodes[20] = {type: 4, index: 43};// RNM(OWS) - this.rules[22].opcodes[21] = {type: 7, string: [58]};// TLS - this.rules[22].opcodes[22] = {type: 4, index: 43};// RNM(OWS) - this.rules[22].opcodes[23] = {type: 4, index: 23};// RNM(annotations) - this.rules[22].opcodes[24] = {type: 4, index: 8};// RNM(typeReference) + this.rules[22].opcodes[0] = {type: 2, children: [1,2,3,7,8,9,10,11,15,16]};// CAT + this.rules[22].opcodes[1] = {type: 4, index: 27};// RNM(annotations) + this.rules[22].opcodes[2] = {type: 6, string: [115,101,114,118,105,99,101]};// TBS + this.rules[22].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[22].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[22].opcodes[5] = {type: 4, index: 94};// RNM(RWS) + this.rules[22].opcodes[6] = {type: 4, index: 77};// RNM(identifier) + this.rules[22].opcodes[7] = {type: 4, index: 93};// RNM(OWS) + this.rules[22].opcodes[8] = {type: 7, string: [123]};// TLS + this.rules[22].opcodes[9] = {type: 4, index: 93};// RNM(OWS) + this.rules[22].opcodes[10] = {type: 4, index: 23};// RNM(serviceMember) + this.rules[22].opcodes[11] = {type: 3, min: 0, max: Infinity};// REP + this.rules[22].opcodes[12] = {type: 2, children: [13,14]};// CAT + this.rules[22].opcodes[13] = {type: 4, index: 94};// RNM(RWS) + this.rules[22].opcodes[14] = {type: 4, index: 23};// RNM(serviceMember) + this.rules[22].opcodes[15] = {type: 4, index: 93};// RNM(OWS) + this.rules[22].opcodes[16] = {type: 7, string: [125]};// TLS - /* annotations */ + /* serviceMember */ this.rules[23].opcodes = []; - this.rules[23].opcodes[0] = {type: 3, min: 0, max: Infinity};// REP - this.rules[23].opcodes[1] = {type: 2, children: [2,3]};// CAT - this.rules[23].opcodes[2] = {type: 4, index: 24};// RNM(annotation) - this.rules[23].opcodes[3] = {type: 4, index: 44};// RNM(RWS) + this.rules[23].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[23].opcodes[1] = {type: 4, index: 27};// RNM(annotations) + this.rules[23].opcodes[2] = {type: 1, children: [3,4,5]};// ALT + this.rules[23].opcodes[3] = {type: 4, index: 24};// RNM(entitySet) + this.rules[23].opcodes[4] = {type: 4, index: 25};// RNM(singleton) + this.rules[23].opcodes[5] = {type: 4, index: 26};// RNM(serviceOperation) - /* annotation */ + /* entitySet */ this.rules[24].opcodes = []; - this.rules[24].opcodes[0] = {type: 1, children: [1,12]};// ALT - this.rules[24].opcodes[1] = {type: 2, children: [2,3,4,8,9,10,11]};// CAT - this.rules[24].opcodes[2] = {type: 7, string: [64]};// TLS - this.rules[24].opcodes[3] = {type: 4, index: 28};// RNM(qualifiedName) - this.rules[24].opcodes[4] = {type: 3, min: 0, max: 1};// REP - this.rules[24].opcodes[5] = {type: 2, children: [6,7]};// CAT - this.rules[24].opcodes[6] = {type: 7, string: [35]};// TLS - this.rules[24].opcodes[7] = {type: 4, index: 29};// RNM(identifier) - this.rules[24].opcodes[8] = {type: 4, index: 43};// RNM(OWS) - this.rules[24].opcodes[9] = {type: 7, string: [58]};// TLS - this.rules[24].opcodes[10] = {type: 4, index: 43};// RNM(OWS) - this.rules[24].opcodes[11] = {type: 4, index: 25};// RNM(annotationValue) - this.rules[24].opcodes[12] = {type: 4, index: 37};// RNM(DOC-COMMENT) + this.rules[24].opcodes[0] = {type: 2, children: [1,2,3,4,5,6,7,8]};// CAT + this.rules[24].opcodes[1] = {type: 4, index: 77};// RNM(identifier) + this.rules[24].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[24].opcodes[3] = {type: 7, string: [58]};// TLS + this.rules[24].opcodes[4] = {type: 4, index: 93};// RNM(OWS) + this.rules[24].opcodes[5] = {type: 7, string: [91]};// TLS + this.rules[24].opcodes[6] = {type: 4, index: 76};// RNM(qualifiedName) + this.rules[24].opcodes[7] = {type: 7, string: [93]};// TLS + this.rules[24].opcodes[8] = {type: 3, min: 0, max: 1};// REP + this.rules[24].opcodes[9] = {type: 2, children: [10,11]};// CAT + this.rules[24].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[24].opcodes[11] = {type: 4, index: 37};// RNM(collectionNavigationCapabilities) - /* annotationValue */ + /* singleton */ this.rules[25].opcodes = []; - this.rules[25].opcodes[0] = {type: 1, children: [1,2,3,4,5,10,31,52]};// ALT - this.rules[25].opcodes[1] = {type: 6, string: [116,114,117,101]};// TBS - this.rules[25].opcodes[2] = {type: 6, string: [102,97,108,115,101]};// TBS - this.rules[25].opcodes[3] = {type: 6, string: [110,117,108,108]};// TBS - this.rules[25].opcodes[4] = {type: 4, index: 32};// RNM(number) - this.rules[25].opcodes[5] = {type: 2, children: [6,7,9]};// CAT - this.rules[25].opcodes[6] = {type: 4, index: 41};// RNM(DQUOTE) - this.rules[25].opcodes[7] = {type: 3, min: 0, max: Infinity};// REP - this.rules[25].opcodes[8] = {type: 4, index: 40};// RNM(CHAR) - this.rules[25].opcodes[9] = {type: 4, index: 41};// RNM(DQUOTE) - this.rules[25].opcodes[10] = {type: 2, children: [11,12,13,30]};// CAT - this.rules[25].opcodes[11] = {type: 7, string: [91]};// TLS - this.rules[25].opcodes[12] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[13] = {type: 3, min: 0, max: 1};// REP - this.rules[25].opcodes[14] = {type: 2, children: [15,16,25,26]};// CAT - this.rules[25].opcodes[15] = {type: 4, index: 25};// RNM(annotationValue) - this.rules[25].opcodes[16] = {type: 3, min: 0, max: Infinity};// REP - this.rules[25].opcodes[17] = {type: 2, children: [18,24]};// CAT - this.rules[25].opcodes[18] = {type: 1, children: [19,23]};// ALT - this.rules[25].opcodes[19] = {type: 2, children: [20,21,22]};// CAT - this.rules[25].opcodes[20] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[21] = {type: 7, string: [44]};// TLS - this.rules[25].opcodes[22] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[23] = {type: 4, index: 44};// RNM(RWS) - this.rules[25].opcodes[24] = {type: 4, index: 25};// RNM(annotationValue) - this.rules[25].opcodes[25] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[26] = {type: 3, min: 0, max: 1};// REP - this.rules[25].opcodes[27] = {type: 2, children: [28,29]};// CAT - this.rules[25].opcodes[28] = {type: 7, string: [44]};// TLS - this.rules[25].opcodes[29] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[30] = {type: 7, string: [93]};// TLS - this.rules[25].opcodes[31] = {type: 2, children: [32,33,34,51]};// CAT - this.rules[25].opcodes[32] = {type: 7, string: [123]};// TLS - this.rules[25].opcodes[33] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[34] = {type: 3, min: 0, max: 1};// REP - this.rules[25].opcodes[35] = {type: 2, children: [36,37,46,47]};// CAT - this.rules[25].opcodes[36] = {type: 4, index: 26};// RNM(annotationProperty) - this.rules[25].opcodes[37] = {type: 3, min: 0, max: Infinity};// REP - this.rules[25].opcodes[38] = {type: 2, children: [39,45]};// CAT - this.rules[25].opcodes[39] = {type: 1, children: [40,44]};// ALT - this.rules[25].opcodes[40] = {type: 2, children: [41,42,43]};// CAT - this.rules[25].opcodes[41] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[42] = {type: 7, string: [44]};// TLS - this.rules[25].opcodes[43] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[44] = {type: 4, index: 44};// RNM(RWS) - this.rules[25].opcodes[45] = {type: 4, index: 26};// RNM(annotationProperty) - this.rules[25].opcodes[46] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[47] = {type: 3, min: 0, max: 1};// REP - this.rules[25].opcodes[48] = {type: 2, children: [49,50]};// CAT - this.rules[25].opcodes[49] = {type: 7, string: [44]};// TLS - this.rules[25].opcodes[50] = {type: 4, index: 43};// RNM(OWS) - this.rules[25].opcodes[51] = {type: 7, string: [125]};// TLS - this.rules[25].opcodes[52] = {type: 2, children: [53,54]};// CAT - this.rules[25].opcodes[53] = {type: 7, string: [46]};// TLS - this.rules[25].opcodes[54] = {type: 3, min: 0, max: Infinity};// REP - this.rules[25].opcodes[55] = {type: 2, children: [56,57]};// CAT - this.rules[25].opcodes[56] = {type: 7, string: [47]};// TLS - this.rules[25].opcodes[57] = {type: 4, index: 29};// RNM(identifier) + this.rules[25].opcodes[0] = {type: 2, children: [1,2,3,4,5,6]};// CAT + this.rules[25].opcodes[1] = {type: 4, index: 77};// RNM(identifier) + this.rules[25].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[25].opcodes[3] = {type: 7, string: [58]};// TLS + this.rules[25].opcodes[4] = {type: 4, index: 93};// RNM(OWS) + this.rules[25].opcodes[5] = {type: 4, index: 76};// RNM(qualifiedName) + this.rules[25].opcodes[6] = {type: 3, min: 0, max: 1};// REP + this.rules[25].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[25].opcodes[8] = {type: 4, index: 93};// RNM(OWS) + this.rules[25].opcodes[9] = {type: 4, index: 35};// RNM(singleNavigationCapabilities) - /* annotationProperty */ + /* serviceOperation */ this.rules[26].opcodes = []; - this.rules[26].opcodes[0] = {type: 2, children: [1,2,3,4,5]};// CAT - this.rules[26].opcodes[1] = {type: 4, index: 27};// RNM(propertyName) - this.rules[26].opcodes[2] = {type: 4, index: 43};// RNM(OWS) - this.rules[26].opcodes[3] = {type: 7, string: [58]};// TLS - this.rules[26].opcodes[4] = {type: 4, index: 43};// RNM(OWS) - this.rules[26].opcodes[5] = {type: 4, index: 25};// RNM(annotationValue) + this.rules[26].opcodes[0] = {type: 2, children: [1,2,3,4,5,6,7,17,18]};// CAT + this.rules[26].opcodes[1] = {type: 4, index: 17};// RNM(operationKind) + this.rules[26].opcodes[2] = {type: 4, index: 94};// RNM(RWS) + this.rules[26].opcodes[3] = {type: 4, index: 77};// RNM(identifier) + this.rules[26].opcodes[4] = {type: 4, index: 93};// RNM(OWS) + this.rules[26].opcodes[5] = {type: 7, string: [40]};// TLS + this.rules[26].opcodes[6] = {type: 4, index: 93};// RNM(OWS) + this.rules[26].opcodes[7] = {type: 3, min: 0, max: 1};// REP + this.rules[26].opcodes[8] = {type: 2, children: [9,10,16]};// CAT + this.rules[26].opcodes[9] = {type: 4, index: 18};// RNM(parameter) + this.rules[26].opcodes[10] = {type: 3, min: 0, max: Infinity};// REP + this.rules[26].opcodes[11] = {type: 2, children: [12,13,14,15]};// CAT + this.rules[26].opcodes[12] = {type: 4, index: 93};// RNM(OWS) + this.rules[26].opcodes[13] = {type: 7, string: [44]};// TLS + this.rules[26].opcodes[14] = {type: 4, index: 93};// RNM(OWS) + this.rules[26].opcodes[15] = {type: 4, index: 18};// RNM(parameter) + this.rules[26].opcodes[16] = {type: 4, index: 93};// RNM(OWS) + this.rules[26].opcodes[17] = {type: 7, string: [41]};// TLS + this.rules[26].opcodes[18] = {type: 3, min: 0, max: 1};// REP + this.rules[26].opcodes[19] = {type: 2, children: [20,21,22,23,24]};// CAT + this.rules[26].opcodes[20] = {type: 4, index: 93};// RNM(OWS) + this.rules[26].opcodes[21] = {type: 7, string: [58]};// TLS + this.rules[26].opcodes[22] = {type: 4, index: 93};// RNM(OWS) + this.rules[26].opcodes[23] = {type: 4, index: 27};// RNM(annotations) + this.rules[26].opcodes[24] = {type: 4, index: 12};// RNM(typeReference) - /* propertyName */ + /* annotations */ this.rules[27].opcodes = []; - this.rules[27].opcodes[0] = {type: 1, children: [1,2,7]};// ALT - this.rules[27].opcodes[1] = {type: 4, index: 29};// RNM(identifier) - this.rules[27].opcodes[2] = {type: 2, children: [3,4,6]};// CAT - this.rules[27].opcodes[3] = {type: 4, index: 41};// RNM(DQUOTE) - this.rules[27].opcodes[4] = {type: 3, min: 1, max: Infinity};// REP - this.rules[27].opcodes[5] = {type: 4, index: 40};// RNM(CHAR) - this.rules[27].opcodes[6] = {type: 4, index: 41};// RNM(DQUOTE) - this.rules[27].opcodes[7] = {type: 2, children: [8,9,10]};// CAT - this.rules[27].opcodes[8] = {type: 7, string: [64]};// TLS - this.rules[27].opcodes[9] = {type: 4, index: 28};// RNM(qualifiedName) - this.rules[27].opcodes[10] = {type: 3, min: 0, max: 1};// REP - this.rules[27].opcodes[11] = {type: 2, children: [12,13]};// CAT - this.rules[27].opcodes[12] = {type: 7, string: [35]};// TLS - this.rules[27].opcodes[13] = {type: 4, index: 29};// RNM(identifier) + this.rules[27].opcodes[0] = {type: 3, min: 0, max: Infinity};// REP + this.rules[27].opcodes[1] = {type: 2, children: [2,3]};// CAT + this.rules[27].opcodes[2] = {type: 4, index: 28};// RNM(annotation) + this.rules[27].opcodes[3] = {type: 4, index: 94};// RNM(RWS) - /* qualifiedName */ + /* annotation */ this.rules[28].opcodes = []; - this.rules[28].opcodes[0] = {type: 2, children: [1,2]};// CAT - this.rules[28].opcodes[1] = {type: 4, index: 29};// RNM(identifier) - this.rules[28].opcodes[2] = {type: 3, min: 0, max: Infinity};// REP - this.rules[28].opcodes[3] = {type: 2, children: [4,5]};// CAT - this.rules[28].opcodes[4] = {type: 7, string: [46]};// TLS - this.rules[28].opcodes[5] = {type: 4, index: 29};// RNM(identifier) + this.rules[28].opcodes[0] = {type: 1, children: [1,12]};// ALT + this.rules[28].opcodes[1] = {type: 2, children: [2,3,4,8,9,10,11]};// CAT + this.rules[28].opcodes[2] = {type: 7, string: [64]};// TLS + this.rules[28].opcodes[3] = {type: 4, index: 76};// RNM(qualifiedName) + this.rules[28].opcodes[4] = {type: 3, min: 0, max: 1};// REP + this.rules[28].opcodes[5] = {type: 2, children: [6,7]};// CAT + this.rules[28].opcodes[6] = {type: 7, string: [35]};// TLS + this.rules[28].opcodes[7] = {type: 4, index: 77};// RNM(identifier) + this.rules[28].opcodes[8] = {type: 4, index: 93};// RNM(OWS) + this.rules[28].opcodes[9] = {type: 7, string: [58]};// TLS + this.rules[28].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[28].opcodes[11] = {type: 4, index: 29};// RNM(annotationValue) + this.rules[28].opcodes[12] = {type: 4, index: 87};// RNM(DOC-COMMENT) - /* identifier */ + /* annotationValue */ this.rules[29].opcodes = []; - this.rules[29].opcodes[0] = {type: 2, children: [1,2]};// CAT - this.rules[29].opcodes[1] = {type: 4, index: 30};// RNM(identInitial) - this.rules[29].opcodes[2] = {type: 3, min: 0, max: Infinity};// REP - this.rules[29].opcodes[3] = {type: 4, index: 31};// RNM(identSubsequent) + this.rules[29].opcodes[0] = {type: 1, children: [1,2,3,4,5,10,26,42]};// ALT + this.rules[29].opcodes[1] = {type: 6, string: [116,114,117,101]};// TBS + this.rules[29].opcodes[2] = {type: 6, string: [102,97,108,115,101]};// TBS + this.rules[29].opcodes[3] = {type: 6, string: [110,117,108,108]};// TBS + this.rules[29].opcodes[4] = {type: 4, index: 82};// RNM(number) + this.rules[29].opcodes[5] = {type: 2, children: [6,7,9]};// CAT + this.rules[29].opcodes[6] = {type: 4, index: 91};// RNM(DQUOTE) + this.rules[29].opcodes[7] = {type: 3, min: 0, max: Infinity};// REP + this.rules[29].opcodes[8] = {type: 4, index: 90};// RNM(CHAR) + this.rules[29].opcodes[9] = {type: 4, index: 91};// RNM(DQUOTE) + this.rules[29].opcodes[10] = {type: 2, children: [11,12,13,25]};// CAT + this.rules[29].opcodes[11] = {type: 7, string: [91]};// TLS + this.rules[29].opcodes[12] = {type: 4, index: 93};// RNM(OWS) + this.rules[29].opcodes[13] = {type: 3, min: 0, max: 1};// REP + this.rules[29].opcodes[14] = {type: 2, children: [15,16,20,21]};// CAT + this.rules[29].opcodes[15] = {type: 4, index: 29};// RNM(annotationValue) + this.rules[29].opcodes[16] = {type: 3, min: 0, max: Infinity};// REP + this.rules[29].opcodes[17] = {type: 2, children: [18,19]};// CAT + this.rules[29].opcodes[18] = {type: 4, index: 80};// RNM(separator) + this.rules[29].opcodes[19] = {type: 4, index: 29};// RNM(annotationValue) + this.rules[29].opcodes[20] = {type: 4, index: 93};// RNM(OWS) + this.rules[29].opcodes[21] = {type: 3, min: 0, max: 1};// REP + this.rules[29].opcodes[22] = {type: 2, children: [23,24]};// CAT + this.rules[29].opcodes[23] = {type: 7, string: [44]};// TLS + this.rules[29].opcodes[24] = {type: 4, index: 93};// RNM(OWS) + this.rules[29].opcodes[25] = {type: 7, string: [93]};// TLS + this.rules[29].opcodes[26] = {type: 2, children: [27,28,29,41]};// CAT + this.rules[29].opcodes[27] = {type: 7, string: [123]};// TLS + this.rules[29].opcodes[28] = {type: 4, index: 93};// RNM(OWS) + this.rules[29].opcodes[29] = {type: 3, min: 0, max: 1};// REP + this.rules[29].opcodes[30] = {type: 2, children: [31,32,36,37]};// CAT + this.rules[29].opcodes[31] = {type: 4, index: 30};// RNM(annotationProperty) + this.rules[29].opcodes[32] = {type: 3, min: 0, max: Infinity};// REP + this.rules[29].opcodes[33] = {type: 2, children: [34,35]};// CAT + this.rules[29].opcodes[34] = {type: 4, index: 80};// RNM(separator) + this.rules[29].opcodes[35] = {type: 4, index: 30};// RNM(annotationProperty) + this.rules[29].opcodes[36] = {type: 4, index: 93};// RNM(OWS) + this.rules[29].opcodes[37] = {type: 3, min: 0, max: 1};// REP + this.rules[29].opcodes[38] = {type: 2, children: [39,40]};// CAT + this.rules[29].opcodes[39] = {type: 7, string: [44]};// TLS + this.rules[29].opcodes[40] = {type: 4, index: 93};// RNM(OWS) + this.rules[29].opcodes[41] = {type: 7, string: [125]};// TLS + this.rules[29].opcodes[42] = {type: 2, children: [43,44]};// CAT + this.rules[29].opcodes[43] = {type: 7, string: [46]};// TLS + this.rules[29].opcodes[44] = {type: 3, min: 0, max: Infinity};// REP + this.rules[29].opcodes[45] = {type: 2, children: [46,47]};// CAT + this.rules[29].opcodes[46] = {type: 7, string: [47]};// TLS + this.rules[29].opcodes[47] = {type: 4, index: 77};// RNM(identifier) - /* identInitial */ + /* annotationProperty */ this.rules[30].opcodes = []; - this.rules[30].opcodes[0] = {type: 1, children: [1,2]};// ALT - this.rules[30].opcodes[1] = {type: 4, index: 38};// RNM(ALPHA) - this.rules[30].opcodes[2] = {type: 7, string: [95]};// TLS + this.rules[30].opcodes[0] = {type: 2, children: [1,2,3,4,5]};// CAT + this.rules[30].opcodes[1] = {type: 4, index: 31};// RNM(propertyName) + this.rules[30].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[30].opcodes[3] = {type: 7, string: [58]};// TLS + this.rules[30].opcodes[4] = {type: 4, index: 93};// RNM(OWS) + this.rules[30].opcodes[5] = {type: 4, index: 29};// RNM(annotationValue) - /* identSubsequent */ + /* propertyName */ this.rules[31].opcodes = []; - this.rules[31].opcodes[0] = {type: 1, children: [1,2]};// ALT - this.rules[31].opcodes[1] = {type: 4, index: 30};// RNM(identInitial) - this.rules[31].opcodes[2] = {type: 4, index: 39};// RNM(DIGIT) + this.rules[31].opcodes[0] = {type: 1, children: [1,2,7]};// ALT + this.rules[31].opcodes[1] = {type: 4, index: 77};// RNM(identifier) + this.rules[31].opcodes[2] = {type: 2, children: [3,4,6]};// CAT + this.rules[31].opcodes[3] = {type: 4, index: 91};// RNM(DQUOTE) + this.rules[31].opcodes[4] = {type: 3, min: 1, max: Infinity};// REP + this.rules[31].opcodes[5] = {type: 4, index: 90};// RNM(CHAR) + this.rules[31].opcodes[6] = {type: 4, index: 91};// RNM(DQUOTE) + this.rules[31].opcodes[7] = {type: 2, children: [8,9,10]};// CAT + this.rules[31].opcodes[8] = {type: 7, string: [64]};// TLS + this.rules[31].opcodes[9] = {type: 4, index: 76};// RNM(qualifiedName) + this.rules[31].opcodes[10] = {type: 3, min: 0, max: 1};// REP + this.rules[31].opcodes[11] = {type: 2, children: [12,13]};// CAT + this.rules[31].opcodes[12] = {type: 7, string: [35]};// TLS + this.rules[31].opcodes[13] = {type: 4, index: 77};// RNM(identifier) - /* number */ + /* primitivePropertyCapability */ this.rules[32].opcodes = []; - this.rules[32].opcodes[0] = {type: 2, children: [1,2,7]};// CAT - this.rules[32].opcodes[1] = {type: 4, index: 33};// RNM(integer) - this.rules[32].opcodes[2] = {type: 3, min: 0, max: 1};// REP - this.rules[32].opcodes[3] = {type: 2, children: [4,5]};// CAT - this.rules[32].opcodes[4] = {type: 7, string: [46]};// TLS - this.rules[32].opcodes[5] = {type: 3, min: 1, max: Infinity};// REP - this.rules[32].opcodes[6] = {type: 4, index: 39};// RNM(DIGIT) - this.rules[32].opcodes[7] = {type: 3, min: 0, max: 1};// REP - this.rules[32].opcodes[8] = {type: 2, children: [9,10]};// CAT - this.rules[32].opcodes[9] = {type: 7, string: [101]};// TLS - this.rules[32].opcodes[10] = {type: 4, index: 33};// RNM(integer) + this.rules[32].opcodes[0] = {type: 1, children: [1,7]};// ALT + this.rules[32].opcodes[1] = {type: 2, children: [2,3]};// CAT + this.rules[32].opcodes[2] = {type: 7, string: [102,105,108,116,101,114,97,98,108,101]};// TLS + this.rules[32].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[32].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[32].opcodes[5] = {type: 4, index: 93};// RNM(OWS) + this.rules[32].opcodes[6] = {type: 4, index: 68};// RNM(filterOptions) + this.rules[32].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[32].opcodes[8] = {type: 7, string: [111,114,100,101,114,97,98,108,101]};// TLS + this.rules[32].opcodes[9] = {type: 3, min: 0, max: 1};// REP + this.rules[32].opcodes[10] = {type: 2, children: [11,12]};// CAT + this.rules[32].opcodes[11] = {type: 4, index: 93};// RNM(OWS) + this.rules[32].opcodes[12] = {type: 4, index: 73};// RNM(orderByDirection) - /* integer */ + /* primitivePropertyCapabilities */ this.rules[33].opcodes = []; - this.rules[33].opcodes[0] = {type: 2, children: [1,5]};// CAT - this.rules[33].opcodes[1] = {type: 3, min: 0, max: 1};// REP - this.rules[33].opcodes[2] = {type: 1, children: [3,4]};// ALT - this.rules[33].opcodes[3] = {type: 7, string: [43]};// TLS - this.rules[33].opcodes[4] = {type: 7, string: [45]};// TLS - this.rules[33].opcodes[5] = {type: 1, children: [6,7]};// ALT - this.rules[33].opcodes[6] = {type: 6, string: [48]};// TBS + this.rules[33].opcodes[0] = {type: 2, children: [1,2,3,10,11]};// CAT + this.rules[33].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[33].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[33].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[33].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[33].opcodes[5] = {type: 4, index: 32};// RNM(primitivePropertyCapability) + this.rules[33].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP this.rules[33].opcodes[7] = {type: 2, children: [8,9]};// CAT - this.rules[33].opcodes[8] = {type: 5, min: 49, max: 57};// TRG - this.rules[33].opcodes[9] = {type: 3, min: 0, max: Infinity};// REP - this.rules[33].opcodes[10] = {type: 4, index: 39};// RNM(DIGIT) + this.rules[33].opcodes[8] = {type: 4, index: 80};// RNM(separator) + this.rules[33].opcodes[9] = {type: 4, index: 32};// RNM(primitivePropertyCapability) + this.rules[33].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[33].opcodes[11] = {type: 7, string: [125]};// TLS - /* precision */ + /* singleNavigationCapability */ this.rules[34].opcodes = []; - this.rules[34].opcodes[0] = {type: 4, index: 33};// RNM(integer) + this.rules[34].opcodes[0] = {type: 1, children: [1,10]};// ALT + this.rules[34].opcodes[1] = {type: 2, children: [2,6]};// CAT + this.rules[34].opcodes[2] = {type: 1, children: [3,4,5]};// ALT + this.rules[34].opcodes[3] = {type: 7, string: [114,101,97,100]};// TLS + this.rules[34].opcodes[4] = {type: 7, string: [117,112,100,97,116,101]};// TLS + this.rules[34].opcodes[5] = {type: 7, string: [114,101,112,108,97,99,101]};// TLS + this.rules[34].opcodes[6] = {type: 3, min: 0, max: 1};// REP + this.rules[34].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[34].opcodes[8] = {type: 4, index: 93};// RNM(OWS) + this.rules[34].opcodes[9] = {type: 4, index: 62};// RNM(navCapabilities) + this.rules[34].opcodes[10] = {type: 2, children: [11,12]};// CAT + this.rules[34].opcodes[11] = {type: 7, string: [100,101,108,101,116,101]};// TLS + this.rules[34].opcodes[12] = {type: 4, index: 75};// RNM(noOptions) - /* scale */ + /* singleNavigationCapabilities */ this.rules[35].opcodes = []; - this.rules[35].opcodes[0] = {type: 4, index: 33};// RNM(integer) + this.rules[35].opcodes[0] = {type: 2, children: [1,2,3,10,11]};// CAT + this.rules[35].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[35].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[35].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[35].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[35].opcodes[5] = {type: 4, index: 34};// RNM(singleNavigationCapability) + this.rules[35].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[35].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[35].opcodes[8] = {type: 4, index: 80};// RNM(separator) + this.rules[35].opcodes[9] = {type: 4, index: 34};// RNM(singleNavigationCapability) + this.rules[35].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[35].opcodes[11] = {type: 7, string: [125]};// TLS - /* maxLength */ + /* collectionNavigationCapability */ this.rules[36].opcodes = []; - this.rules[36].opcodes[0] = {type: 4, index: 33};// RNM(integer) + this.rules[36].opcodes[0] = {type: 1, children: [1,5,11]};// ALT + this.rules[36].opcodes[1] = {type: 2, children: [2,3,4]};// CAT + this.rules[36].opcodes[2] = {type: 7, string: [100,101,108,101,116,101]};// TLS + this.rules[36].opcodes[3] = {type: 4, index: 93};// RNM(OWS) + this.rules[36].opcodes[4] = {type: 4, index: 75};// RNM(noOptions) + this.rules[36].opcodes[5] = {type: 2, children: [6,7]};// CAT + this.rules[36].opcodes[6] = {type: 7, string: [108,105,115,116]};// TLS + this.rules[36].opcodes[7] = {type: 3, min: 0, max: 1};// REP + this.rules[36].opcodes[8] = {type: 2, children: [9,10]};// CAT + this.rules[36].opcodes[9] = {type: 4, index: 93};// RNM(OWS) + this.rules[36].opcodes[10] = {type: 4, index: 60};// RNM(collectionNavCapabilities) + this.rules[36].opcodes[11] = {type: 2, children: [12,17]};// CAT + this.rules[36].opcodes[12] = {type: 1, children: [13,14,15,16]};// ALT + this.rules[36].opcodes[13] = {type: 7, string: [114,101,97,100]};// TLS + this.rules[36].opcodes[14] = {type: 7, string: [99,114,101,97,116,101]};// TLS + this.rules[36].opcodes[15] = {type: 7, string: [114,101,112,108,97,99,101]};// TLS + this.rules[36].opcodes[16] = {type: 7, string: [117,112,100,97,116,101]};// TLS + this.rules[36].opcodes[17] = {type: 3, min: 0, max: 1};// REP + this.rules[36].opcodes[18] = {type: 2, children: [19,20]};// CAT + this.rules[36].opcodes[19] = {type: 4, index: 93};// RNM(OWS) + this.rules[36].opcodes[20] = {type: 4, index: 62};// RNM(navCapabilities) - /* DOC-COMMENT */ + /* collectionNavigationCapabilities */ this.rules[37].opcodes = []; - this.rules[37].opcodes[0] = {type: 2, children: [1,2]};// CAT - this.rules[37].opcodes[1] = {type: 7, string: [35,35]};// TLS - this.rules[37].opcodes[2] = {type: 3, min: 0, max: Infinity};// REP - this.rules[37].opcodes[3] = {type: 1, children: [4,5,6]};// ALT - this.rules[37].opcodes[4] = {type: 5, min: 0, max: 9};// TRG - this.rules[37].opcodes[5] = {type: 5, min: 11, max: 12};// TRG - this.rules[37].opcodes[6] = {type: 5, min: 14, max: 1114111};// TRG + this.rules[37].opcodes[0] = {type: 2, children: [1,2,3,10,11]};// CAT + this.rules[37].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[37].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[37].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[37].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[37].opcodes[5] = {type: 4, index: 36};// RNM(collectionNavigationCapability) + this.rules[37].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[37].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[37].opcodes[8] = {type: 4, index: 80};// RNM(separator) + this.rules[37].opcodes[9] = {type: 4, index: 36};// RNM(collectionNavigationCapability) + this.rules[37].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[37].opcodes[11] = {type: 7, string: [125]};// TLS - /* ALPHA */ + /* paths */ this.rules[38].opcodes = []; - this.rules[38].opcodes[0] = {type: 1, children: [1,2]};// ALT - this.rules[38].opcodes[1] = {type: 5, min: 65, max: 90};// TRG - this.rules[38].opcodes[2] = {type: 5, min: 97, max: 122};// TRG + this.rules[38].opcodes[0] = {type: 2, children: [1,2,3,4,9,10]};// CAT + this.rules[38].opcodes[1] = {type: 6, string: [112,97,116,104,115]};// TBS + this.rules[38].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[38].opcodes[3] = {type: 7, string: [123]};// TLS + this.rules[38].opcodes[4] = {type: 3, min: 0, max: Infinity};// REP + this.rules[38].opcodes[5] = {type: 2, children: [6,7,8]};// CAT + this.rules[38].opcodes[6] = {type: 4, index: 93};// RNM(OWS) + this.rules[38].opcodes[7] = {type: 7, string: [47]};// TLS + this.rules[38].opcodes[8] = {type: 4, index: 39};// RNM(path) + this.rules[38].opcodes[9] = {type: 4, index: 93};// RNM(OWS) + this.rules[38].opcodes[10] = {type: 7, string: [125]};// TLS - /* DIGIT */ + /* path */ this.rules[39].opcodes = []; - this.rules[39].opcodes[0] = {type: 5, min: 48, max: 57};// TRG + this.rules[39].opcodes[0] = {type: 1, children: [1,11,21,29,37]};// ALT + this.rules[39].opcodes[1] = {type: 2, children: [2,3,4,5]};// CAT + this.rules[39].opcodes[2] = {type: 4, index: 40};// RNM(propertySegment) + this.rules[39].opcodes[3] = {type: 7, string: [47]};// TLS + this.rules[39].opcodes[4] = {type: 4, index: 43};// RNM(keySegment) + this.rules[39].opcodes[5] = {type: 3, min: 0, max: 1};// REP + this.rules[39].opcodes[6] = {type: 1, children: [7,8]};// ALT + this.rules[39].opcodes[7] = {type: 4, index: 41};// RNM(pathSegment) + this.rules[39].opcodes[8] = {type: 2, children: [9,10]};// CAT + this.rules[39].opcodes[9] = {type: 4, index: 94};// RNM(RWS) + this.rules[39].opcodes[10] = {type: 4, index: 54};// RNM(singleNavPathCapabilities) + this.rules[39].opcodes[11] = {type: 2, children: [12,13,14,15]};// CAT + this.rules[39].opcodes[12] = {type: 4, index: 45};// RNM(serviceOperationSegment) + this.rules[39].opcodes[13] = {type: 7, string: [47]};// TLS + this.rules[39].opcodes[14] = {type: 4, index: 43};// RNM(keySegment) + this.rules[39].opcodes[15] = {type: 3, min: 0, max: 1};// REP + this.rules[39].opcodes[16] = {type: 1, children: [17,18]};// ALT + this.rules[39].opcodes[17] = {type: 4, index: 41};// RNM(pathSegment) + this.rules[39].opcodes[18] = {type: 2, children: [19,20]};// CAT + this.rules[39].opcodes[19] = {type: 4, index: 94};// RNM(RWS) + this.rules[39].opcodes[20] = {type: 4, index: 54};// RNM(singleNavPathCapabilities) + this.rules[39].opcodes[21] = {type: 2, children: [22,23]};// CAT + this.rules[39].opcodes[22] = {type: 4, index: 45};// RNM(serviceOperationSegment) + this.rules[39].opcodes[23] = {type: 3, min: 0, max: 1};// REP + this.rules[39].opcodes[24] = {type: 1, children: [25,26]};// ALT + this.rules[39].opcodes[25] = {type: 4, index: 41};// RNM(pathSegment) + this.rules[39].opcodes[26] = {type: 2, children: [27,28]};// CAT + this.rules[39].opcodes[27] = {type: 4, index: 94};// RNM(RWS) + this.rules[39].opcodes[28] = {type: 4, index: 48};// RNM(capabilities) + this.rules[39].opcodes[29] = {type: 2, children: [30,31]};// CAT + this.rules[39].opcodes[30] = {type: 4, index: 42};// RNM(castSegment) + this.rules[39].opcodes[31] = {type: 3, min: 0, max: 1};// REP + this.rules[39].opcodes[32] = {type: 1, children: [33,34]};// ALT + this.rules[39].opcodes[33] = {type: 4, index: 41};// RNM(pathSegment) + this.rules[39].opcodes[34] = {type: 2, children: [35,36]};// CAT + this.rules[39].opcodes[35] = {type: 4, index: 94};// RNM(RWS) + this.rules[39].opcodes[36] = {type: 4, index: 48};// RNM(capabilities) + this.rules[39].opcodes[37] = {type: 2, children: [38,39]};// CAT + this.rules[39].opcodes[38] = {type: 4, index: 40};// RNM(propertySegment) + this.rules[39].opcodes[39] = {type: 3, min: 0, max: 1};// REP + this.rules[39].opcodes[40] = {type: 1, children: [41,42]};// ALT + this.rules[39].opcodes[41] = {type: 4, index: 41};// RNM(pathSegment) + this.rules[39].opcodes[42] = {type: 2, children: [43,44]};// CAT + this.rules[39].opcodes[43] = {type: 4, index: 94};// RNM(RWS) + this.rules[39].opcodes[44] = {type: 4, index: 48};// RNM(capabilities) - /* CHAR */ + /* propertySegment */ this.rules[40].opcodes = []; - this.rules[40].opcodes[0] = {type: 1, children: [1,2,3,4,7]};// ALT - this.rules[40].opcodes[1] = {type: 5, min: 32, max: 33};// TRG - this.rules[40].opcodes[2] = {type: 5, min: 35, max: 91};// TRG - this.rules[40].opcodes[3] = {type: 5, min: 93, max: 1114111};// TRG - this.rules[40].opcodes[4] = {type: 2, children: [5,6]};// CAT - this.rules[40].opcodes[5] = {type: 4, index: 42};// RNM(ESCAPE) - this.rules[40].opcodes[6] = {type: 4, index: 42};// RNM(ESCAPE) - this.rules[40].opcodes[7] = {type: 2, children: [8,9]};// CAT - this.rules[40].opcodes[8] = {type: 4, index: 42};// RNM(ESCAPE) - this.rules[40].opcodes[9] = {type: 4, index: 41};// RNM(DQUOTE) + this.rules[40].opcodes[0] = {type: 4, index: 77};// RNM(identifier) - /* DQUOTE */ + /* pathSegment */ this.rules[41].opcodes = []; - this.rules[41].opcodes[0] = {type: 6, string: [34]};// TBS + this.rules[41].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[41].opcodes[1] = {type: 7, string: [47]};// TLS + this.rules[41].opcodes[2] = {type: 4, index: 39};// RNM(path) - /* ESCAPE */ + /* castSegment */ this.rules[42].opcodes = []; - this.rules[42].opcodes[0] = {type: 6, string: [92]};// TBS + this.rules[42].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[42].opcodes[1] = {type: 4, index: 77};// RNM(identifier) + this.rules[42].opcodes[2] = {type: 3, min: 1, max: Infinity};// REP + this.rules[42].opcodes[3] = {type: 2, children: [4,5]};// CAT + this.rules[42].opcodes[4] = {type: 7, string: [46]};// TLS + this.rules[42].opcodes[5] = {type: 4, index: 77};// RNM(identifier) - /* OWS */ + /* keySegment */ this.rules[43].opcodes = []; - this.rules[43].opcodes[0] = {type: 3, min: 0, max: Infinity};// REP - this.rules[43].opcodes[1] = {type: 4, index: 45};// RNM(WS) + this.rules[43].opcodes[0] = {type: 2, children: [1,2,3]};// CAT + this.rules[43].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[43].opcodes[2] = {type: 4, index: 44};// RNM(keyProperty) + this.rules[43].opcodes[3] = {type: 7, string: [125]};// TLS - /* RWS */ + /* keyProperty */ this.rules[44].opcodes = []; - this.rules[44].opcodes[0] = {type: 3, min: 1, max: Infinity};// REP - this.rules[44].opcodes[1] = {type: 4, index: 45};// RNM(WS) + this.rules[44].opcodes[0] = {type: 4, index: 77};// RNM(identifier) - /* WS */ + /* serviceOperationSegment */ this.rules[45].opcodes = []; - this.rules[45].opcodes[0] = {type: 1, children: [1,2,3,4]};// ALT - this.rules[45].opcodes[1] = {type: 6, string: [8]};// TBS - this.rules[45].opcodes[2] = {type: 6, string: [10]};// TBS - this.rules[45].opcodes[3] = {type: 6, string: [13]};// TBS - this.rules[45].opcodes[4] = {type: 6, string: [32]};// TBS + this.rules[45].opcodes[0] = {type: 2, children: [1,2,3,7]};// CAT + this.rules[45].opcodes[1] = {type: 4, index: 77};// RNM(identifier) + this.rules[45].opcodes[2] = {type: 4, index: 46};// RNM(parameters) + this.rules[45].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[45].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[45].opcodes[5] = {type: 7, string: [47]};// TLS + this.rules[45].opcodes[6] = {type: 4, index: 42};// RNM(castSegment) + this.rules[45].opcodes[7] = {type: 3, min: 0, max: 1};// REP + this.rules[45].opcodes[8] = {type: 2, children: [9,10]};// CAT + this.rules[45].opcodes[9] = {type: 7, string: [47]};// TLS + this.rules[45].opcodes[10] = {type: 4, index: 43};// RNM(keySegment) + + /* parameters */ + this.rules[46].opcodes = []; + this.rules[46].opcodes[0] = {type: 2, children: [1,2,3,12]};// CAT + this.rules[46].opcodes[1] = {type: 7, string: [40]};// TLS + this.rules[46].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[46].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[46].opcodes[4] = {type: 2, children: [5,6,11]};// CAT + this.rules[46].opcodes[5] = {type: 4, index: 47};// RNM(parameterSpecification) + this.rules[46].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[46].opcodes[7] = {type: 2, children: [8,9,10]};// CAT + this.rules[46].opcodes[8] = {type: 7, string: [44]};// TLS + this.rules[46].opcodes[9] = {type: 4, index: 93};// RNM(OWS) + this.rules[46].opcodes[10] = {type: 4, index: 47};// RNM(parameterSpecification) + this.rules[46].opcodes[11] = {type: 4, index: 93};// RNM(OWS) + this.rules[46].opcodes[12] = {type: 7, string: [41]};// TLS + + /* parameterSpecification */ + this.rules[47].opcodes = []; + this.rules[47].opcodes[0] = {type: 2, children: [1,2,3,4,5,6,7]};// CAT + this.rules[47].opcodes[1] = {type: 4, index: 77};// RNM(identifier) + this.rules[47].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[47].opcodes[3] = {type: 7, string: [61]};// TLS + this.rules[47].opcodes[4] = {type: 4, index: 93};// RNM(OWS) + this.rules[47].opcodes[5] = {type: 7, string: [123]};// TLS + this.rules[47].opcodes[6] = {type: 4, index: 77};// RNM(identifier) + this.rules[47].opcodes[7] = {type: 7, string: [125]};// TLS + + /* capabilities */ + this.rules[48].opcodes = []; + this.rules[48].opcodes[0] = {type: 1, children: [1,2,3,4]};// ALT + this.rules[48].opcodes[1] = {type: 4, index: 50};// RNM(singlePathCapabilities) + this.rules[48].opcodes[2] = {type: 4, index: 52};// RNM(collectionPathCapabilities) + this.rules[48].opcodes[3] = {type: 4, index: 54};// RNM(singleNavPathCapabilities) + this.rules[48].opcodes[4] = {type: 4, index: 56};// RNM(collectionNavPathCapabilities) + + /* singlePathCapability */ + this.rules[49].opcodes = []; + this.rules[49].opcodes[0] = {type: 2, children: [1,6]};// CAT + this.rules[49].opcodes[1] = {type: 1, children: [2,3,4,5]};// ALT + this.rules[49].opcodes[2] = {type: 7, string: [103,101,116]};// TLS + this.rules[49].opcodes[3] = {type: 7, string: [112,117,116]};// TLS + this.rules[49].opcodes[4] = {type: 7, string: [112,97,116,99,104]};// TLS + this.rules[49].opcodes[5] = {type: 7, string: [100,101,108,101,116,101]};// TLS + this.rules[49].opcodes[6] = {type: 3, min: 0, max: 1};// REP + this.rules[49].opcodes[7] = {type: 4, index: 75};// RNM(noOptions) + + /* singlePathCapabilities */ + this.rules[50].opcodes = []; + this.rules[50].opcodes[0] = {type: 2, children: [1,2,3,11]};// CAT + this.rules[50].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[50].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[50].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[50].opcodes[4] = {type: 2, children: [5,6,10]};// CAT + this.rules[50].opcodes[5] = {type: 4, index: 49};// RNM(singlePathCapability) + this.rules[50].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[50].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[50].opcodes[8] = {type: 4, index: 80};// RNM(separator) + this.rules[50].opcodes[9] = {type: 4, index: 49};// RNM(singlePathCapability) + this.rules[50].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[50].opcodes[11] = {type: 7, string: [125]};// TLS + + /* collectionPathCapability */ + this.rules[51].opcodes = []; + this.rules[51].opcodes[0] = {type: 1, children: [1,5]};// ALT + this.rules[51].opcodes[1] = {type: 2, children: [2,3]};// CAT + this.rules[51].opcodes[2] = {type: 7, string: [103,101,116]};// TLS + this.rules[51].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[51].opcodes[4] = {type: 4, index: 58};// RNM(collectionCapabilities) + this.rules[51].opcodes[5] = {type: 2, children: [6,7]};// CAT + this.rules[51].opcodes[6] = {type: 7, string: [112,111,115,116]};// TLS + this.rules[51].opcodes[7] = {type: 3, min: 0, max: 1};// REP + this.rules[51].opcodes[8] = {type: 4, index: 75};// RNM(noOptions) + + /* collectionPathCapabilities */ + this.rules[52].opcodes = []; + this.rules[52].opcodes[0] = {type: 2, children: [1,2,3,11]};// CAT + this.rules[52].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[52].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[52].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[52].opcodes[4] = {type: 2, children: [5,6,10]};// CAT + this.rules[52].opcodes[5] = {type: 4, index: 51};// RNM(collectionPathCapability) + this.rules[52].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[52].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[52].opcodes[8] = {type: 4, index: 80};// RNM(separator) + this.rules[52].opcodes[9] = {type: 4, index: 51};// RNM(collectionPathCapability) + this.rules[52].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[52].opcodes[11] = {type: 7, string: [125]};// TLS + + /* singleNavPathCapability */ + this.rules[53].opcodes = []; + this.rules[53].opcodes[0] = {type: 1, children: [1,10]};// ALT + this.rules[53].opcodes[1] = {type: 2, children: [2,6]};// CAT + this.rules[53].opcodes[2] = {type: 1, children: [3,4,5]};// ALT + this.rules[53].opcodes[3] = {type: 7, string: [103,101,116]};// TLS + this.rules[53].opcodes[4] = {type: 7, string: [112,97,116,99,104]};// TLS + this.rules[53].opcodes[5] = {type: 7, string: [112,117,116]};// TLS + this.rules[53].opcodes[6] = {type: 3, min: 0, max: 1};// REP + this.rules[53].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[53].opcodes[8] = {type: 4, index: 93};// RNM(OWS) + this.rules[53].opcodes[9] = {type: 4, index: 62};// RNM(navCapabilities) + this.rules[53].opcodes[10] = {type: 2, children: [11,12]};// CAT + this.rules[53].opcodes[11] = {type: 7, string: [100,101,108,101,116,101]};// TLS + this.rules[53].opcodes[12] = {type: 4, index: 75};// RNM(noOptions) + + /* singleNavPathCapabilities */ + this.rules[54].opcodes = []; + this.rules[54].opcodes[0] = {type: 2, children: [1,2,3,11]};// CAT + this.rules[54].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[54].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[54].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[54].opcodes[4] = {type: 2, children: [5,6,10]};// CAT + this.rules[54].opcodes[5] = {type: 4, index: 53};// RNM(singleNavPathCapability) + this.rules[54].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[54].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[54].opcodes[8] = {type: 4, index: 80};// RNM(separator) + this.rules[54].opcodes[9] = {type: 4, index: 53};// RNM(singleNavPathCapability) + this.rules[54].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[54].opcodes[11] = {type: 7, string: [125]};// TLS + + /* collectionNavPathCapability */ + this.rules[55].opcodes = []; + this.rules[55].opcodes[0] = {type: 1, children: [1,7]};// ALT + this.rules[55].opcodes[1] = {type: 2, children: [2,3]};// CAT + this.rules[55].opcodes[2] = {type: 7, string: [103,101,116]};// TLS + this.rules[55].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[55].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[55].opcodes[5] = {type: 4, index: 93};// RNM(OWS) + this.rules[55].opcodes[6] = {type: 4, index: 60};// RNM(collectionNavCapabilities) + this.rules[55].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[55].opcodes[8] = {type: 7, string: [112,111,115,116]};// TLS + this.rules[55].opcodes[9] = {type: 3, min: 0, max: 1};// REP + this.rules[55].opcodes[10] = {type: 2, children: [11,12]};// CAT + this.rules[55].opcodes[11] = {type: 4, index: 93};// RNM(OWS) + this.rules[55].opcodes[12] = {type: 4, index: 62};// RNM(navCapabilities) + + /* collectionNavPathCapabilities */ + this.rules[56].opcodes = []; + this.rules[56].opcodes[0] = {type: 2, children: [1,2,3,11]};// CAT + this.rules[56].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[56].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[56].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[56].opcodes[4] = {type: 2, children: [5,6,10]};// CAT + this.rules[56].opcodes[5] = {type: 4, index: 55};// RNM(collectionNavPathCapability) + this.rules[56].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[56].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[56].opcodes[8] = {type: 4, index: 80};// RNM(separator) + this.rules[56].opcodes[9] = {type: 4, index: 55};// RNM(collectionNavPathCapability) + this.rules[56].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[56].opcodes[11] = {type: 7, string: [125]};// TLS + + /* collectionCapability */ + this.rules[57].opcodes = []; + this.rules[57].opcodes[0] = {type: 1, children: [1,2,3,4,5]};// ALT + this.rules[57].opcodes[1] = {type: 4, index: 65};// RNM(filterCapability) + this.rules[57].opcodes[2] = {type: 4, index: 70};// RNM(orderByCapability) + this.rules[57].opcodes[3] = {type: 7, string: [116,111,112]};// TLS + this.rules[57].opcodes[4] = {type: 7, string: [115,107,105,112]};// TLS + this.rules[57].opcodes[5] = {type: 7, string: [99,111,117,110,116]};// TLS + + /* collectionCapabilities */ + this.rules[58].opcodes = []; + this.rules[58].opcodes[0] = {type: 2, children: [1,2,3,11]};// CAT + this.rules[58].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[58].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[58].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[58].opcodes[4] = {type: 2, children: [5,6,10]};// CAT + this.rules[58].opcodes[5] = {type: 4, index: 57};// RNM(collectionCapability) + this.rules[58].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[58].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[58].opcodes[8] = {type: 4, index: 80};// RNM(separator) + this.rules[58].opcodes[9] = {type: 4, index: 57};// RNM(collectionCapability) + this.rules[58].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[58].opcodes[11] = {type: 7, string: [125]};// TLS + + /* collectionNavCapability */ + this.rules[59].opcodes = []; + this.rules[59].opcodes[0] = {type: 1, children: [1,2]};// ALT + this.rules[59].opcodes[1] = {type: 4, index: 57};// RNM(collectionCapability) + this.rules[59].opcodes[2] = {type: 4, index: 61};// RNM(navCapability) + + /* collectionNavCapabilities */ + this.rules[60].opcodes = []; + this.rules[60].opcodes[0] = {type: 2, children: [1,2,3,11]};// CAT + this.rules[60].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[60].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[60].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[60].opcodes[4] = {type: 2, children: [5,6,10]};// CAT + this.rules[60].opcodes[5] = {type: 4, index: 59};// RNM(collectionNavCapability) + this.rules[60].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[60].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[60].opcodes[8] = {type: 4, index: 80};// RNM(separator) + this.rules[60].opcodes[9] = {type: 4, index: 59};// RNM(collectionNavCapability) + this.rules[60].opcodes[10] = {type: 4, index: 93};// RNM(OWS) + this.rules[60].opcodes[11] = {type: 7, string: [125]};// TLS + + /* navCapability */ + this.rules[61].opcodes = []; + this.rules[61].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[61].opcodes[1] = {type: 7, string: [101,120,112,97,110,100]};// TLS + this.rules[61].opcodes[2] = {type: 3, min: 0, max: 1};// REP + this.rules[61].opcodes[3] = {type: 2, children: [4,5,6,7,17,18]};// CAT + this.rules[61].opcodes[4] = {type: 4, index: 93};// RNM(OWS) + this.rules[61].opcodes[5] = {type: 7, string: [123]};// TLS + this.rules[61].opcodes[6] = {type: 4, index: 93};// RNM(OWS) + this.rules[61].opcodes[7] = {type: 3, min: 0, max: 1};// REP + this.rules[61].opcodes[8] = {type: 2, children: [9,10]};// CAT + this.rules[61].opcodes[9] = {type: 4, index: 63};// RNM(expandProperty) + this.rules[61].opcodes[10] = {type: 3, min: 0, max: Infinity};// REP + this.rules[61].opcodes[11] = {type: 2, children: [12,13,14,15,16]};// CAT + this.rules[61].opcodes[12] = {type: 4, index: 93};// RNM(OWS) + this.rules[61].opcodes[13] = {type: 7, string: [44]};// TLS + this.rules[61].opcodes[14] = {type: 4, index: 93};// RNM(OWS) + this.rules[61].opcodes[15] = {type: 4, index: 63};// RNM(expandProperty) + this.rules[61].opcodes[16] = {type: 4, index: 93};// RNM(OWS) + this.rules[61].opcodes[17] = {type: 4, index: 93};// RNM(OWS) + this.rules[61].opcodes[18] = {type: 7, string: [125]};// TLS + + /* navCapabilities */ + this.rules[62].opcodes = []; + this.rules[62].opcodes[0] = {type: 2, children: [1,2,3,7]};// CAT + this.rules[62].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[62].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[62].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[62].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[62].opcodes[5] = {type: 4, index: 61};// RNM(navCapability) + this.rules[62].opcodes[6] = {type: 4, index: 93};// RNM(OWS) + this.rules[62].opcodes[7] = {type: 7, string: [125]};// TLS + + /* expandProperty */ + this.rules[63].opcodes = []; + this.rules[63].opcodes[0] = {type: 1, children: [1,2]};// ALT + this.rules[63].opcodes[1] = {type: 4, index: 81};// RNM(star) + this.rules[63].opcodes[2] = {type: 2, children: [3,7,8]};// CAT + this.rules[63].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[63].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[63].opcodes[5] = {type: 4, index: 42};// RNM(castSegment) + this.rules[63].opcodes[6] = {type: 7, string: [47]};// TLS + this.rules[63].opcodes[7] = {type: 4, index: 64};// RNM(navigationProperty) + this.rules[63].opcodes[8] = {type: 1, children: [9,13]};// ALT + this.rules[63].opcodes[9] = {type: 3, min: 0, max: 1};// REP + this.rules[63].opcodes[10] = {type: 2, children: [11,12]};// CAT + this.rules[63].opcodes[11] = {type: 4, index: 93};// RNM(OWS) + this.rules[63].opcodes[12] = {type: 4, index: 60};// RNM(collectionNavCapabilities) + this.rules[63].opcodes[13] = {type: 3, min: 0, max: 1};// REP + this.rules[63].opcodes[14] = {type: 2, children: [15,16]};// CAT + this.rules[63].opcodes[15] = {type: 4, index: 93};// RNM(OWS) + this.rules[63].opcodes[16] = {type: 4, index: 62};// RNM(navCapabilities) + + /* navigationProperty */ + this.rules[64].opcodes = []; + this.rules[64].opcodes[0] = {type: 4, index: 77};// RNM(identifier) + + /* filterCapability */ + this.rules[65].opcodes = []; + this.rules[65].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[65].opcodes[1] = {type: 7, string: [102,105,108,116,101,114]};// TLS + this.rules[65].opcodes[2] = {type: 3, min: 0, max: 1};// REP + this.rules[65].opcodes[3] = {type: 2, children: [4,5,15]};// CAT + this.rules[65].opcodes[4] = {type: 7, string: [123]};// TLS + this.rules[65].opcodes[5] = {type: 3, min: 0, max: 1};// REP + this.rules[65].opcodes[6] = {type: 2, children: [7,8,9]};// CAT + this.rules[65].opcodes[7] = {type: 4, index: 93};// RNM(OWS) + this.rules[65].opcodes[8] = {type: 4, index: 66};// RNM(filterProperty) + this.rules[65].opcodes[9] = {type: 3, min: 0, max: Infinity};// REP + this.rules[65].opcodes[10] = {type: 2, children: [11,12,13,14]};// CAT + this.rules[65].opcodes[11] = {type: 7, string: [44]};// TLS + this.rules[65].opcodes[12] = {type: 4, index: 93};// RNM(OWS) + this.rules[65].opcodes[13] = {type: 4, index: 66};// RNM(filterProperty) + this.rules[65].opcodes[14] = {type: 4, index: 93};// RNM(OWS) + this.rules[65].opcodes[15] = {type: 7, string: [125]};// TLS + + /* filterProperty */ + this.rules[66].opcodes = []; + this.rules[66].opcodes[0] = {type: 2, children: [1,9]};// CAT + this.rules[66].opcodes[1] = {type: 1, children: [2,8]};// ALT + this.rules[66].opcodes[2] = {type: 2, children: [3,7]};// CAT + this.rules[66].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[66].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[66].opcodes[5] = {type: 4, index: 13};// RNM(typeName) + this.rules[66].opcodes[6] = {type: 7, string: [47]};// TLS + this.rules[66].opcodes[7] = {type: 4, index: 31};// RNM(propertyName) + this.rules[66].opcodes[8] = {type: 4, index: 67};// RNM(allProperties) + this.rules[66].opcodes[9] = {type: 3, min: 0, max: 1};// REP + this.rules[66].opcodes[10] = {type: 2, children: [11,12]};// CAT + this.rules[66].opcodes[11] = {type: 4, index: 93};// RNM(OWS) + this.rules[66].opcodes[12] = {type: 4, index: 68};// RNM(filterOptions) + + /* allProperties */ + this.rules[67].opcodes = []; + this.rules[67].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[67].opcodes[1] = {type: 4, index: 81};// RNM(star) + this.rules[67].opcodes[2] = {type: 3, min: 0, max: 1};// REP + this.rules[67].opcodes[3] = {type: 2, children: [4,5]};// CAT + this.rules[67].opcodes[4] = {type: 7, string: [47]};// TLS + this.rules[67].opcodes[5] = {type: 4, index: 13};// RNM(typeName) + + /* filterOptions */ + this.rules[68].opcodes = []; + this.rules[68].opcodes[0] = {type: 2, children: [1,2,3,7]};// CAT + this.rules[68].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[68].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[68].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[68].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[68].opcodes[5] = {type: 4, index: 69};// RNM(filterOperations) + this.rules[68].opcodes[6] = {type: 4, index: 93};// RNM(OWS) + this.rules[68].opcodes[7] = {type: 7, string: [125]};// TLS + + /* filterOperations */ + this.rules[69].opcodes = []; + this.rules[69].opcodes[0] = {type: 1, children: [1,2,3,4,5]};// ALT + this.rules[69].opcodes[1] = {type: 7, string: [110,111,110,101]};// TLS + this.rules[69].opcodes[2] = {type: 7, string: [101,113]};// TLS + this.rules[69].opcodes[3] = {type: 7, string: [99,111,109,112]};// TLS + this.rules[69].opcodes[4] = {type: 7, string: [115,116,114,105,110,103,99,111,109,112]};// TLS + this.rules[69].opcodes[5] = {type: 7, string: [115,116,114,105,110,103]};// TLS + + /* orderByCapability */ + this.rules[70].opcodes = []; + this.rules[70].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[70].opcodes[1] = {type: 7, string: [111,114,100,101,114,98,121]};// TLS + this.rules[70].opcodes[2] = {type: 3, min: 0, max: 1};// REP + this.rules[70].opcodes[3] = {type: 2, children: [4,5]};// CAT + this.rules[70].opcodes[4] = {type: 4, index: 93};// RNM(OWS) + this.rules[70].opcodes[5] = {type: 4, index: 71};// RNM(orderByProperties) + + /* orderByProperties */ + this.rules[71].opcodes = []; + this.rules[71].opcodes[0] = {type: 2, children: [1,2,3,12]};// CAT + this.rules[71].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[71].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[71].opcodes[3] = {type: 3, min: 0, max: 1};// REP + this.rules[71].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[71].opcodes[5] = {type: 4, index: 72};// RNM(orderByProperty) + this.rules[71].opcodes[6] = {type: 3, min: 0, max: Infinity};// REP + this.rules[71].opcodes[7] = {type: 2, children: [8,9,10,11]};// CAT + this.rules[71].opcodes[8] = {type: 7, string: [44]};// TLS + this.rules[71].opcodes[9] = {type: 4, index: 93};// RNM(OWS) + this.rules[71].opcodes[10] = {type: 4, index: 72};// RNM(orderByProperty) + this.rules[71].opcodes[11] = {type: 4, index: 93};// RNM(OWS) + this.rules[71].opcodes[12] = {type: 7, string: [125]};// TLS + + /* orderByProperty */ + this.rules[72].opcodes = []; + this.rules[72].opcodes[0] = {type: 1, children: [1,2]};// ALT + this.rules[72].opcodes[1] = {type: 4, index: 67};// RNM(allProperties) + this.rules[72].opcodes[2] = {type: 2, children: [3,4]};// CAT + this.rules[72].opcodes[3] = {type: 4, index: 31};// RNM(propertyName) + this.rules[72].opcodes[4] = {type: 3, min: 0, max: 1};// REP + this.rules[72].opcodes[5] = {type: 2, children: [6,7]};// CAT + this.rules[72].opcodes[6] = {type: 4, index: 93};// RNM(OWS) + this.rules[72].opcodes[7] = {type: 4, index: 73};// RNM(orderByDirection) + + /* orderByDirection */ + this.rules[73].opcodes = []; + this.rules[73].opcodes[0] = {type: 2, children: [1,2,12]};// CAT + this.rules[73].opcodes[1] = {type: 7, string: [123]};// TLS + this.rules[73].opcodes[2] = {type: 3, min: 0, max: 1};// REP + this.rules[73].opcodes[3] = {type: 2, children: [4,5,6]};// CAT + this.rules[73].opcodes[4] = {type: 4, index: 93};// RNM(OWS) + this.rules[73].opcodes[5] = {type: 4, index: 74};// RNM(ascOrDesc) + this.rules[73].opcodes[6] = {type: 3, min: 0, max: 1};// REP + this.rules[73].opcodes[7] = {type: 2, children: [8,9,10,11]};// CAT + this.rules[73].opcodes[8] = {type: 7, string: [44]};// TLS + this.rules[73].opcodes[9] = {type: 4, index: 93};// RNM(OWS) + this.rules[73].opcodes[10] = {type: 4, index: 74};// RNM(ascOrDesc) + this.rules[73].opcodes[11] = {type: 4, index: 93};// RNM(OWS) + this.rules[73].opcodes[12] = {type: 7, string: [125]};// TLS + + /* ascOrDesc */ + this.rules[74].opcodes = []; + this.rules[74].opcodes[0] = {type: 1, children: [1,2]};// ALT + this.rules[74].opcodes[1] = {type: 7, string: [97,115,99]};// TLS + this.rules[74].opcodes[2] = {type: 7, string: [100,101,115,99]};// TLS + + /* noOptions */ + this.rules[75].opcodes = []; + this.rules[75].opcodes[0] = {type: 2, children: [1,2,3,4]};// CAT + this.rules[75].opcodes[1] = {type: 4, index: 93};// RNM(OWS) + this.rules[75].opcodes[2] = {type: 7, string: [123]};// TLS + this.rules[75].opcodes[3] = {type: 4, index: 93};// RNM(OWS) + this.rules[75].opcodes[4] = {type: 7, string: [125]};// TLS + + /* qualifiedName */ + this.rules[76].opcodes = []; + this.rules[76].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[76].opcodes[1] = {type: 4, index: 77};// RNM(identifier) + this.rules[76].opcodes[2] = {type: 3, min: 0, max: Infinity};// REP + this.rules[76].opcodes[3] = {type: 2, children: [4,5]};// CAT + this.rules[76].opcodes[4] = {type: 7, string: [46]};// TLS + this.rules[76].opcodes[5] = {type: 4, index: 77};// RNM(identifier) + + /* identifier */ + this.rules[77].opcodes = []; + this.rules[77].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[77].opcodes[1] = {type: 4, index: 78};// RNM(identInitial) + this.rules[77].opcodes[2] = {type: 3, min: 0, max: Infinity};// REP + this.rules[77].opcodes[3] = {type: 4, index: 79};// RNM(identSubsequent) + + /* identInitial */ + this.rules[78].opcodes = []; + this.rules[78].opcodes[0] = {type: 1, children: [1,2]};// ALT + this.rules[78].opcodes[1] = {type: 4, index: 88};// RNM(ALPHA) + this.rules[78].opcodes[2] = {type: 7, string: [95]};// TLS + + /* identSubsequent */ + this.rules[79].opcodes = []; + this.rules[79].opcodes[0] = {type: 1, children: [1,2]};// ALT + this.rules[79].opcodes[1] = {type: 4, index: 78};// RNM(identInitial) + this.rules[79].opcodes[2] = {type: 4, index: 89};// RNM(DIGIT) + + /* separator */ + this.rules[80].opcodes = []; + this.rules[80].opcodes[0] = {type: 1, children: [1,5]};// ALT + this.rules[80].opcodes[1] = {type: 2, children: [2,3,4]};// CAT + this.rules[80].opcodes[2] = {type: 4, index: 93};// RNM(OWS) + this.rules[80].opcodes[3] = {type: 7, string: [44]};// TLS + this.rules[80].opcodes[4] = {type: 4, index: 93};// RNM(OWS) + this.rules[80].opcodes[5] = {type: 4, index: 94};// RNM(RWS) + + /* star */ + this.rules[81].opcodes = []; + this.rules[81].opcodes[0] = {type: 7, string: [42]};// TLS + + /* number */ + this.rules[82].opcodes = []; + this.rules[82].opcodes[0] = {type: 2, children: [1,2,7]};// CAT + this.rules[82].opcodes[1] = {type: 4, index: 83};// RNM(integer) + this.rules[82].opcodes[2] = {type: 3, min: 0, max: 1};// REP + this.rules[82].opcodes[3] = {type: 2, children: [4,5]};// CAT + this.rules[82].opcodes[4] = {type: 7, string: [46]};// TLS + this.rules[82].opcodes[5] = {type: 3, min: 1, max: Infinity};// REP + this.rules[82].opcodes[6] = {type: 4, index: 89};// RNM(DIGIT) + this.rules[82].opcodes[7] = {type: 3, min: 0, max: 1};// REP + this.rules[82].opcodes[8] = {type: 2, children: [9,10]};// CAT + this.rules[82].opcodes[9] = {type: 7, string: [101]};// TLS + this.rules[82].opcodes[10] = {type: 4, index: 83};// RNM(integer) + + /* integer */ + this.rules[83].opcodes = []; + this.rules[83].opcodes[0] = {type: 2, children: [1,5]};// CAT + this.rules[83].opcodes[1] = {type: 3, min: 0, max: 1};// REP + this.rules[83].opcodes[2] = {type: 1, children: [3,4]};// ALT + this.rules[83].opcodes[3] = {type: 7, string: [43]};// TLS + this.rules[83].opcodes[4] = {type: 7, string: [45]};// TLS + this.rules[83].opcodes[5] = {type: 1, children: [6,7]};// ALT + this.rules[83].opcodes[6] = {type: 6, string: [48]};// TBS + this.rules[83].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[83].opcodes[8] = {type: 5, min: 49, max: 57};// TRG + this.rules[83].opcodes[9] = {type: 3, min: 0, max: Infinity};// REP + this.rules[83].opcodes[10] = {type: 4, index: 89};// RNM(DIGIT) + + /* precision */ + this.rules[84].opcodes = []; + this.rules[84].opcodes[0] = {type: 4, index: 83};// RNM(integer) + + /* scale */ + this.rules[85].opcodes = []; + this.rules[85].opcodes[0] = {type: 4, index: 83};// RNM(integer) + + /* maxLength */ + this.rules[86].opcodes = []; + this.rules[86].opcodes[0] = {type: 4, index: 83};// RNM(integer) + + /* DOC-COMMENT */ + this.rules[87].opcodes = []; + this.rules[87].opcodes[0] = {type: 2, children: [1,2]};// CAT + this.rules[87].opcodes[1] = {type: 7, string: [35,35]};// TLS + this.rules[87].opcodes[2] = {type: 3, min: 0, max: Infinity};// REP + this.rules[87].opcodes[3] = {type: 1, children: [4,5,6]};// ALT + this.rules[87].opcodes[4] = {type: 5, min: 0, max: 9};// TRG + this.rules[87].opcodes[5] = {type: 5, min: 11, max: 12};// TRG + this.rules[87].opcodes[6] = {type: 5, min: 14, max: 1114111};// TRG + + /* ALPHA */ + this.rules[88].opcodes = []; + this.rules[88].opcodes[0] = {type: 1, children: [1,2]};// ALT + this.rules[88].opcodes[1] = {type: 5, min: 65, max: 90};// TRG + this.rules[88].opcodes[2] = {type: 5, min: 97, max: 122};// TRG + + /* DIGIT */ + this.rules[89].opcodes = []; + this.rules[89].opcodes[0] = {type: 5, min: 48, max: 57};// TRG + + /* CHAR */ + this.rules[90].opcodes = []; + this.rules[90].opcodes[0] = {type: 1, children: [1,2,3,4,7]};// ALT + this.rules[90].opcodes[1] = {type: 5, min: 32, max: 33};// TRG + this.rules[90].opcodes[2] = {type: 5, min: 35, max: 91};// TRG + this.rules[90].opcodes[3] = {type: 5, min: 93, max: 1114111};// TRG + this.rules[90].opcodes[4] = {type: 2, children: [5,6]};// CAT + this.rules[90].opcodes[5] = {type: 4, index: 92};// RNM(ESCAPE) + this.rules[90].opcodes[6] = {type: 4, index: 92};// RNM(ESCAPE) + this.rules[90].opcodes[7] = {type: 2, children: [8,9]};// CAT + this.rules[90].opcodes[8] = {type: 4, index: 92};// RNM(ESCAPE) + this.rules[90].opcodes[9] = {type: 4, index: 91};// RNM(DQUOTE) + + /* DQUOTE */ + this.rules[91].opcodes = []; + this.rules[91].opcodes[0] = {type: 6, string: [34]};// TBS + + /* ESCAPE */ + this.rules[92].opcodes = []; + this.rules[92].opcodes[0] = {type: 6, string: [92]};// TBS + + /* OWS */ + this.rules[93].opcodes = []; + this.rules[93].opcodes[0] = {type: 3, min: 0, max: Infinity};// REP + this.rules[93].opcodes[1] = {type: 4, index: 95};// RNM(WS) + + /* RWS */ + this.rules[94].opcodes = []; + this.rules[94].opcodes[0] = {type: 3, min: 1, max: Infinity};// REP + this.rules[94].opcodes[1] = {type: 4, index: 95};// RNM(WS) + + /* WS */ + this.rules[95].opcodes = []; + this.rules[95].opcodes[0] = {type: 1, children: [1,2,3,4]};// ALT + this.rules[95].opcodes[1] = {type: 6, string: [8]};// TBS + this.rules[95].opcodes[2] = {type: 6, string: [10]};// TBS + this.rules[95].opcodes[3] = {type: 6, string: [13]};// TBS + this.rules[95].opcodes[4] = {type: 6, string: [32]};// TBS // The `toString()` function will display the original grammar file(s) that produced these opcodes. this.toString = function toString(){ @@ -644,13 +1343,13 @@ module.exports = function grammar(){ str += "; Model\r\n"; str += ";----------------------------\r\n"; str += "\r\n"; - str += "model = OWS [ namespace RWS ] *include [ modelElement *( RWS modelElement ) ] OWS\r\n"; + str += "model = OWS [ namespace RWS ] *include [ modelElement *( RWS modelElement ) ] [ OWS service ] [ OWS paths ] OWS\r\n"; str += "\r\n"; str += "namespace = %s\"namespace\" RWS qualifiedName\r\n"; str += "\r\n"; str += "include = %s\"include\" RWS DQUOTE 1*CHAR DQUOTE RWS %s\"as\" RWS identifier RWS\r\n"; str += "\r\n"; - str += "modelElement = ( structuredType / enumType / typeDefinition / service )\r\n"; + str += "modelElement = ( structuredType / enumType / typeDefinition )\r\n"; str += "\r\n"; str += "\r\n"; str += ";----------------------------\r\n"; @@ -661,11 +1360,20 @@ module.exports = function grammar(){ str += "\r\n"; str += "structuredTypeMember = property / operation ; property, action, or function\r\n"; str += "\r\n"; - str += "property = annotations [propertyModifier RWS] identifier OWS \":\" OWS typeReference\r\n"; + str += "property = singlePropertyDefinition [ OWS (primitivePropertyCapabilities / singleNavigationCapabilities) ]\r\n"; + str += " / collectionPropertyDefinition [ OWS ( collectionCapabilities / collectionNavigationCapabilities) ]\r\n"; + str += "\r\n"; + str += "singlePropertyDefinition = annotations [propertyModifier RWS] identifier OWS \":\" OWS singleTypeReference\r\n"; + str += "\r\n"; + str += "collectionPropertyDefinition = annotations identifier OWS \":\" OWS collectionTypeReference\r\n"; str += "\r\n"; str += "propertyModifier = %s\"key\"\r\n"; str += "\r\n"; - str += "typeReference = typeName [ \"?\" ] / \"[\" typeName [ \"?\" ] \"]\"\r\n"; + str += "singleTypeReference = typeName [ \"?\" ]\r\n"; + str += "\r\n"; + str += "collectionTypeReference = \"[\" typeName [ \"?\" ] \"]\"\r\n"; + str += "\r\n"; + str += "typeReference = singleTypeReference / collectionTypeReference\r\n"; str += "\r\n"; str += "typeName = builtInType / edmType / qualifiedName\r\n"; str += "\r\n"; @@ -684,6 +1392,7 @@ module.exports = function grammar(){ str += "operation = annotations operationKind RWS identifier OWS\r\n"; str += " \"(\" OWS [ parameter *( OWS \",\" OWS parameter) OWS ] \")\"\r\n"; str += " [ OWS \":\" OWS annotations typeReference ]\r\n"; + str += " [ separator collectionNavCapabilities ]\r\n"; str += "\r\n"; str += "operationKind = %s\"action\" / %s\"function\"\r\n"; str += "\r\n"; @@ -714,9 +1423,9 @@ module.exports = function grammar(){ str += "\r\n"; str += "serviceMember = annotations ( entitySet / singleton / serviceOperation )\r\n"; str += "\r\n"; - str += "entitySet = identifier OWS \":\" OWS \"[\" qualifiedName \"]\"\r\n"; + str += "entitySet = identifier OWS \":\" OWS \"[\" qualifiedName \"]\" [ OWS collectionNavigationCapabilities ]\r\n"; str += "\r\n"; - str += "singleton = identifier OWS \":\" OWS qualifiedName\r\n"; + str += "singleton = identifier OWS \":\" OWS qualifiedName [ OWS singleNavigationCapabilities ]\r\n"; str += "\r\n"; str += "serviceOperation = operationKind RWS identifier\r\n"; str += " OWS \"(\" OWS [ parameter *(OWS \",\" OWS parameter) OWS ] \")\"\r\n"; @@ -736,8 +1445,8 @@ module.exports = function grammar(){ str += " / %s\"null\"\r\n"; str += " / number\r\n"; str += " / DQUOTE *CHAR DQUOTE\r\n"; - str += " / \"[\" OWS [ annotationValue *( ( OWS \",\" OWS / RWS ) annotationValue ) OWS [ \",\" OWS ] ] \"]\"\r\n"; - str += " / \"{\" OWS [ annotationProperty *( ( OWS \",\" OWS /RWS ) annotationProperty ) OWS [ \",\" OWS ] ] \"}\"\r\n"; + str += " / \"[\" OWS [ annotationValue *( separator annotationValue ) OWS [ \",\" OWS ] ] \"]\"\r\n"; + str += " / \"{\" OWS [ annotationProperty *( separator annotationProperty ) OWS [ \",\" OWS ] ] \"}\"\r\n"; str += " / \".\" *( \"/\" identifier )\r\n"; str += "\r\n"; str += "annotationProperty = propertyName OWS \":\" OWS annotationValue\r\n"; @@ -746,9 +1455,134 @@ module.exports = function grammar(){ str += "\r\n"; str += "\r\n"; str += ";----------------------------\r\n"; + str += "; Model Capabilities\r\n"; + str += ";----------------------------\r\n"; + str += "\r\n"; + str += "primitivePropertyCapability = \"filterable\" [ OWS filterOptions ] / \"orderable\" [ OWS orderByDirection ]\r\n"; + str += "\r\n"; + str += "primitivePropertyCapabilities = \"{\" OWS [ primitivePropertyCapability *( separator primitivePropertyCapability )] OWS \"}\"\r\n"; + str += "\r\n"; + str += "singleNavigationCapability = (\"READ\" / \"UPDATE\" / \"REPLACE\") [ OWS navCapabilities ] / \"DELETE\" noOptions\r\n"; + str += "\r\n"; + str += "singleNavigationCapabilities = \"{\" OWS [ singleNavigationCapability *( separator singleNavigationCapability )] OWS \"}\"\r\n"; + str += "\r\n"; + str += "collectionNavigationCapability = \"DELETE\" OWS noOptions\r\n"; + str += " / \"LIST\" [ OWS collectionNavCapabilities ]\r\n"; + str += " / (\"READ\" / \"CREATE\" / \"REPLACE\" / \"UPDATE\") [ OWS navCapabilities ]\r\n"; + str += "\r\n"; + str += "collectionNavigationCapabilities = \"{\" OWS [ collectionNavigationCapability *( separator collectionNavigationCapability )] OWS \"}\"\r\n"; + str += "\r\n"; + str += "\r\n"; + str += "\r\n"; + str += ";----------------------------\r\n"; + str += "; Paths\r\n"; + str += ";----------------------------\r\n"; + str += "\r\n"; + str += "paths = %s\"paths\" OWS \"{\" *( OWS \"/\" path ) OWS \"}\"\r\n"; + str += "\r\n"; + str += "path = propertySegment \"/\" keySegment [ pathSegment / ( RWS singleNavPathCapabilities ) ]\r\n"; + str += " / serviceOperationSegment \"/\" keySegment [ pathSegment / ( RWS singleNavPathCapabilities ) ]\r\n"; + str += " / serviceOperationSegment [ pathSegment / ( RWS capabilities ) ]\r\n"; + str += " / castSegment [ pathSegment / ( RWS capabilities ) ]\r\n"; + str += " / propertySegment [ pathSegment / ( RWS capabilities ) ]\r\n"; + str += "\r\n"; + str += "propertySegment = identifier; structural or navigation property\r\n"; + str += "\r\n"; + str += "pathSegment = \"/\" path\r\n"; + str += "\r\n"; + str += "castSegment = identifier 1*( \".\" identifier ) ; qualified type name\r\n"; + str += "\r\n"; + str += "keySegment = \"{\" keyProperty \"}\"\r\n"; + str += "\r\n"; + str += "keyProperty = identifier ; name of the key property\r\n"; + str += "\r\n"; + str += "serviceOperationSegment = identifier parameters [ \"/\" castSegment ] [ \"/\" keySegment ]\r\n"; + str += "\r\n"; + str += "parameters = \"(\" OWS [ parameterSpecification *( \",\" OWS parameterSpecification ) OWS ] \")\"\r\n"; + str += "\r\n"; + str += "parameterSpecification = identifier OWS \"=\" OWS \"{\" identifier \"}\"\r\n"; + str += "\r\n"; + str += "capabilities = singlePathCapabilities / collectionPathCapabilities / singleNavPathCapabilities / collectionNavPathCapabilities\r\n"; + str += "\r\n"; + str += "\r\n"; + str += "\r\n"; + str += ";----------------------------\r\n"; + str += "; Path Capabilities\r\n"; + str += ";----------------------------\r\n"; + str += "\r\n"; + str += "\r\n"; + str += "singlePathCapability = (\"GET\" / \"PUT\" / \"PATCH\" / \"DELETE\") [noOptions]\r\n"; + str += "\r\n"; + str += "singlePathCapabilities = \"{\" OWS [singlePathCapability *( separator singlePathCapability) OWS] \"}\"\r\n"; + str += "\r\n"; + str += "collectionPathCapability = \"GET\" [ collectionCapabilities ] / \"POST\" [noOptions]\r\n"; + str += "\r\n"; + str += "collectionPathCapabilities = \"{\" OWS [ collectionPathCapability *( separator collectionPathCapability ) OWS ] \"}\"\r\n"; + str += "\r\n"; + str += "singleNavPathCapability = (\"GET\" / \"PATCH\" / \"PUT\") [ OWS navCapabilities ] / \"DELETE\" noOptions\r\n"; + str += "\r\n"; + str += "singleNavPathCapabilities = \"{\" OWS [singleNavPathCapability *( separator singleNavPathCapability ) OWS ] \"}\"\r\n"; + str += "\r\n"; + str += "collectionNavPathCapability = \"GET\" [ OWS collectionNavCapabilities ] / \"POST\" [ OWS navCapabilities ]\r\n"; + str += "\r\n"; + str += "collectionNavPathCapabilities = \"{\" OWS [ collectionNavPathCapability *( separator collectionNavPathCapability ) OWS ] \"}\"\r\n"; + str += "\r\n"; + str += "\r\n"; + str += "\r\n"; + str += ";----------------------------\r\n"; + str += "; Capability Elements\r\n"; + str += ";----------------------------\r\n"; + str += "\r\n"; + str += "\r\n"; + str += "collectionCapability = filterCapability / orderByCapability / \"top\" / \"skip\" / \"count\"\r\n"; + str += "\r\n"; + str += "collectionCapabilities = \"{\" OWS [ collectionCapability *( separator collectionCapability ) OWS ] \"}\"\r\n"; + str += "\r\n"; + str += "collectionNavCapability = collectionCapability / navCapability\r\n"; + str += "\r\n"; + str += "collectionNavCapabilities = \"{\" OWS [ collectionNavCapability *( separator collectionNavCapability ) OWS ] \"}\"\r\n"; + str += "\r\n"; + str += "navCapability = \"expand\" [ OWS \"{\" OWS [ expandProperty *( OWS \",\" OWS expandProperty OWS ) ] OWS \"}\" ]\r\n"; + str += "\r\n"; + str += "navCapabilities = \"{\" OWS [ navCapability OWS ] \"}\"\r\n"; + str += "\r\n"; + str += "expandProperty = star / [ castSegment \"/\" ] navigationProperty ( [ OWS collectionNavCapabilities ] / [ OWS navCapabilities ] )\r\n"; + str += "\r\n"; + str += "navigationProperty = identifier ; single or collection valued navigation property\r\n"; + str += "\r\n"; + str += "filterCapability = \"filter\" [ \"{\" [ OWS filterProperty *( \",\" OWS filterProperty OWS ) ] \"}\" ]\r\n"; + str += "\r\n"; + str += "filterProperty = ( ( [ typeName \"/\" ] propertyName ) / allProperties) [ OWS filterOptions ]\r\n"; + str += "\r\n"; + str += "allProperties = star [ \"/\" typeName ] ; all properties, optionally of a given type\r\n"; + str += "\r\n"; + str += "filterOptions = \"{\" OWS [ filterOperations OWS ] \"}\"\r\n"; + str += "\r\n"; + str += "filterOperations = \"none\" ; not filterable\r\n"; + str += " / \"eq\" ; eq\r\n"; + str += " / \"comp\" ; eq, gt, ge, lt, le\r\n"; + str += " / \"stringComp\" ; eq, gt, ge, lt, le, startswith, endswith, contains\r\n"; + str += " / \"string\" ; eq, startswith, endswith, contains\r\n"; + str += "\r\n"; + str += "orderByCapability = \"orderby\" [ OWS orderByProperties ]\r\n"; + str += "\r\n"; + str += "orderByProperties = \"{\" OWS [ orderByProperty *( \",\" OWS orderByProperty OWS ) ] \"}\"\r\n"; + str += "\r\n"; + str += "orderByProperty = allProperties / propertyName [ OWS orderByDirection ]\r\n"; + str += "\r\n"; + str += "orderByDirection =\"{\" [ OWS ascOrDesc [ \",\" OWS ascOrDesc OWS ] ] \"}\"\r\n"; + str += "\r\n"; + str += "ascOrDesc = \"asc\" / \"desc\"\r\n"; + str += "\r\n"; + str += "noOptions = OWS \"{\" OWS \"}\"\r\n"; + str += "\r\n"; + str += "\r\n"; + str += "\r\n"; + str += ";----------------------------\r\n"; str += "; Core Syntax Elements\r\n"; str += ";----------------------------\r\n"; str += "\r\n"; + str += "\r\n"; str += "qualifiedName = identifier *( \".\" identifier )\r\n"; str += "\r\n"; str += "identifier = identInitial *identSubsequent\r\n"; @@ -757,6 +1591,10 @@ module.exports = function grammar(){ str += "\r\n"; str += "identSubsequent = identInitial / DIGIT\r\n"; str += "\r\n"; + str += "separator = OWS \",\" OWS / RWS\r\n"; + str += "\r\n"; + str += "star = \"*\"\r\n"; + str += "\r\n"; str += "number = integer [ \".\" 1*DIGIT ] [ \"e\" integer ]\r\n"; str += "\r\n"; str += "integer = [ \"+\" / \"-\" ] ( %x30 / %x31-39 *DIGIT )\r\n"; diff --git a/tools/rsdl/abnf/rsdl-testcases.yaml b/tools/rsdl/abnf/rsdl-testcases.yaml index a8cf8238..29116745 100644 --- a/tools/rsdl/abnf/rsdl-testcases.yaml +++ b/tools/rsdl/abnf/rsdl-testcases.yaml @@ -1,4 +1,33 @@ # test cases for rsdl.abnf +- source: | + namespace Jetsons + include "core" as Core + type Company + { + key stockSymbol: String + } + service { + competitors: [Company] + } + paths { + /competitors/{stockSymbol} + } + tokens: + - namespace + - Jetsons + - include + - Core + - structuredType + - Company + - key + - stockSymbol + - String + - service + - entitySet + - competitors + - Company + - competitors + - stockSymbol - source: "namespace foo\n" # whitespace required after namespace identifier tokens: [namespace, foo] @@ -46,14 +75,14 @@ tokens: [service, x, singleton, foo, bar] - source: | - service { + service { foo: bar baz: [qux] } tokens: [service, singleton, foo, bar, entitySet, baz, qux] - source: | - service { + service { function f():Boolean action a() action b(c:Date):[String?] @@ -62,7 +91,7 @@ [service, function, f, Boolean, action, a, action, b, c, Date, "[String?]"] - source: | - service { + service { function f(g: DateTime): Decimal? action a( b :Decimal(5,2), d : Double ) : [Duration] } @@ -107,7 +136,7 @@ - source: | @aa.bb.cc:42 - service { + service { @a.b:"" foo: bar @a.b:" " @@ -199,3 +228,197 @@ - entitySet - employees - Employee + +- source: | + service { + company: Company { READ { expand { jetsons.company/employees } } } + } + tokens: + - service + - singleton + - company + - Company + - jetsons + - company + - employees + +- source: | + service { + competitors: [Company] { + LIST { top, skip, count, filter, orderby, expand { employees { expand {*}, top, skip, count, filter}} } + CREATE { expand{ employees { top, skip, count, filter, orderby, expand{ * } }, orders } } + READ { expand{ } } + UPDATE { expand } + DELETE {} + } + } + tokens: + - service + - entitySet + - competitors + - Company + - employees + - employees + - orders + +- source: | + type Company + { + key stockSymbol: String { filterable { eq }, orderable } + name: String { filterable { stringComp }, orderable {} } + incorporated: Date { filterable, orderable { asc, desc } } + employees: [Employee] { LIST { filter{name {stringComp}}, orderby{name{asc,desc}} }, READ } + } + tokens: + - structuredType + - Company + - key + - stockSymbol + - String + - name + - String + - incorporated + - Date + - employees + - Employee + - name + - name + +- source: | + service {competitors: [Company] { DELETE } } + failAt: 41 # braces required after DELETE + +- source: | + paths { + /competitors + /competitors/{stockSymbol} + /competitors/{stockSymbol}/employees + /competitors/{stockSymbol}/employees/{id} + } + +- source: | + paths { + /company + /company/employees + /company/employees/{id} + /company/youreFired + /company/youreFired/{id} + } + +- source: | + paths { + /company + /company/employees + /company/employees/{id} + /competitors + /competitors/{stockSymbol} + /competitors/{stockSymbol}/employees + /competitors/{stockSymbol}/employees/{id} + /company/topEmployees(num={num}) + /company/topEmployees(num={num})/{id} + /company/youreFired + } + +- source: | + paths + { + /company/topEmployees(num={num}) + /company/topEmployees(num={num},num2={num2}) + /company/topEmployees(num={num})/{id} + /company/topEmployees(num={num},num2={num2})/{id} + } + +- source: | + paths + { + /topEmployees(num={num}) + /topEmployees(num={num},num2={num2}) + /topEmployees(num={num})/{id} + /topEmployees(num={num},num2={num2})/{id} + } + +- source: | + paths { + /company/employees { GET } + } + +- source: | + paths { + /company/employees { GET {} } + } + +- source: | + paths { + /company/employees { GET { orderby{name {asc, desc}} } } + } + +- source: | + paths { + /company/employees { GET { top skip count } } + } + +- source: | + paths { + /company/employees { GET { filter{name {stringComp}} } } + } + +- source: | + paths { + /company/employees { GET { expand{ employees { top, skip, count, filter, orderby } } } } + } + +- source: | + paths { + /company/employees { GET { orderby top skip count filter expand } } + } + +- source: | + paths { + /company/employees { GET { orderby{name} filter{name} expand{ employees } } } + } + +- source: | + paths { + /company/employees { GET { orderby{name {asc, desc}} top skip count filter{name {stringComp}} expand{ employees { top, skip, count, filter, orderby } } } } + } + +- source: | + paths { + /company/employees { GET { orderby{*} filter{*} } } + } + +- source: | + paths { + /company/employees { POST } + } + +- source: | + paths { + /company/employees { GET } + } + +- source: | + paths { + /company/employees { PATCH } + } + +- source: | + paths { + /company/employees { PUT } + } + +- source: | + paths { + /company/employees { DELETE } + } + +- source: | + paths { + /company/employees/{id} { GET { expand{ employees { top, skip, count, filter, orderby } } } } + } + +- source: | + paths { + /company/employees/{id} { GET { orderby{name {asc, desc}} top skip count filter{name {stringComp}} expand{ employees { top, skip, count, filter, orderby } } } } + } + failAt: 42 # collection valued capabilities not supported for a single valued collection diff --git a/tools/rsdl/abnf/rsdl.abnf b/tools/rsdl/abnf/rsdl.abnf index bd6da110..ab25d415 100644 --- a/tools/rsdl/abnf/rsdl.abnf +++ b/tools/rsdl/abnf/rsdl.abnf @@ -7,13 +7,13 @@ ; Model ;---------------------------- -model = OWS [ namespace RWS ] *include [ modelElement *( RWS modelElement ) ] OWS +model = OWS [ namespace RWS ] *include [ modelElement *( RWS modelElement ) ] [ OWS service ] [ OWS paths ] OWS namespace = %s"namespace" RWS qualifiedName include = %s"include" RWS DQUOTE 1*CHAR DQUOTE RWS %s"as" RWS identifier RWS -modelElement = ( structuredType / enumType / typeDefinition / service ) +modelElement = ( structuredType / enumType / typeDefinition ) ;---------------------------- @@ -24,11 +24,20 @@ structuredType = annotations [ %s"abstract" RWS ] %s"type" RWS identifier structuredTypeMember = property / operation ; property, action, or function -property = annotations [propertyModifier RWS] identifier OWS ":" OWS typeReference +property = singlePropertyDefinition [ OWS (primitivePropertyCapabilities / singleNavigationCapabilities) ] + / collectionPropertyDefinition [ OWS ( collectionCapabilities / collectionNavigationCapabilities) ] + +singlePropertyDefinition = annotations [propertyModifier RWS] identifier OWS ":" OWS singleTypeReference + +collectionPropertyDefinition = annotations identifier OWS ":" OWS collectionTypeReference propertyModifier = %s"key" -typeReference = typeName [ "?" ] / "[" typeName [ "?" ] "]" +singleTypeReference = typeName [ "?" ] + +collectionTypeReference = "[" typeName [ "?" ] "]" + +typeReference = singleTypeReference / collectionTypeReference typeName = builtInType / edmType / qualifiedName @@ -47,6 +56,7 @@ edmType = %s"Edm" "." identifier operation = annotations operationKind RWS identifier OWS "(" OWS [ parameter *( OWS "," OWS parameter) OWS ] ")" [ OWS ":" OWS annotations typeReference ] + [ separator collectionNavCapabilities ] operationKind = %s"action" / %s"function" @@ -77,9 +87,9 @@ service = annotations %s"service" [ RWS identifier ] OWS "{" OWS se serviceMember = annotations ( entitySet / singleton / serviceOperation ) -entitySet = identifier OWS ":" OWS "[" qualifiedName "]" +entitySet = identifier OWS ":" OWS "[" qualifiedName "]" [ OWS collectionNavigationCapabilities ] -singleton = identifier OWS ":" OWS qualifiedName +singleton = identifier OWS ":" OWS qualifiedName [ OWS singleNavigationCapabilities ] serviceOperation = operationKind RWS identifier OWS "(" OWS [ parameter *(OWS "," OWS parameter) OWS ] ")" @@ -99,8 +109,8 @@ annotationValue = %s"true" / %s"null" / number / DQUOTE *CHAR DQUOTE - / "[" OWS [ annotationValue *( ( OWS "," OWS / RWS ) annotationValue ) OWS [ "," OWS ] ] "]" - / "{" OWS [ annotationProperty *( ( OWS "," OWS /RWS ) annotationProperty ) OWS [ "," OWS ] ] "}" + / "[" OWS [ annotationValue *( separator annotationValue ) OWS [ "," OWS ] ] "]" + / "{" OWS [ annotationProperty *( separator annotationProperty ) OWS [ "," OWS ] ] "}" / "." *( "/" identifier ) annotationProperty = propertyName OWS ":" OWS annotationValue @@ -108,10 +118,135 @@ annotationProperty = propertyName OWS ":" OWS annotationValue propertyName = identifier / DQUOTE 1*CHAR DQUOTE / "@" qualifiedName [ "#" identifier ] +;---------------------------- +; Model Capabilities +;---------------------------- + +primitivePropertyCapability = "filterable" [ OWS filterOptions ] / "orderable" [ OWS orderByDirection ] + +primitivePropertyCapabilities = "{" OWS [ primitivePropertyCapability *( separator primitivePropertyCapability )] OWS "}" + +singleNavigationCapability = ("READ" / "UPDATE" / "REPLACE") [ OWS navCapabilities ] / "DELETE" noOptions + +singleNavigationCapabilities = "{" OWS [ singleNavigationCapability *( separator singleNavigationCapability )] OWS "}" + +collectionNavigationCapability = "DELETE" OWS noOptions + / "LIST" [ OWS collectionNavCapabilities ] + / ("READ" / "CREATE" / "REPLACE" / "UPDATE") [ OWS navCapabilities ] + +collectionNavigationCapabilities = "{" OWS [ collectionNavigationCapability *( separator collectionNavigationCapability )] OWS "}" + + + +;---------------------------- +; Paths +;---------------------------- + +paths = %s"paths" OWS "{" *( OWS "/" path ) OWS "}" + +path = propertySegment "/" keySegment [ pathSegment / ( RWS singleNavPathCapabilities ) ] + / serviceOperationSegment "/" keySegment [ pathSegment / ( RWS singleNavPathCapabilities ) ] + / serviceOperationSegment [ pathSegment / ( RWS capabilities ) ] + / castSegment [ pathSegment / ( RWS capabilities ) ] + / propertySegment [ pathSegment / ( RWS capabilities ) ] + +propertySegment = identifier; structural or navigation property + +pathSegment = "/" path + +castSegment = identifier 1*( "." identifier ) ; qualified type name + +keySegment = "{" keyProperty "}" + +keyProperty = identifier ; name of the key property + +serviceOperationSegment = identifier parameters [ "/" castSegment ] [ "/" keySegment ] + +parameters = "(" OWS [ parameterSpecification *( "," OWS parameterSpecification ) OWS ] ")" + +parameterSpecification = identifier OWS "=" OWS "{" identifier "}" + +capabilities = singlePathCapabilities / collectionPathCapabilities / singleNavPathCapabilities / collectionNavPathCapabilities + + + +;---------------------------- +; Path Capabilities +;---------------------------- + + +singlePathCapability = ("GET" / "PUT" / "PATCH" / "DELETE") [noOptions] + +singlePathCapabilities = "{" OWS [singlePathCapability *( separator singlePathCapability) OWS] "}" + +collectionPathCapability = "GET" [ collectionCapabilities ] / "POST" [noOptions] + +collectionPathCapabilities = "{" OWS [ collectionPathCapability *( separator collectionPathCapability ) OWS ] "}" + +singleNavPathCapability = ("GET" / "PATCH" / "PUT") [ OWS navCapabilities ] / "DELETE" noOptions + +singleNavPathCapabilities = "{" OWS [singleNavPathCapability *( separator singleNavPathCapability ) OWS ] "}" + +collectionNavPathCapability = "GET" [ OWS collectionNavCapabilities ] / "POST" [ OWS navCapabilities ] + +collectionNavPathCapabilities = "{" OWS [ collectionNavPathCapability *( separator collectionNavPathCapability ) OWS ] "}" + + + +;---------------------------- +; Capability Elements +;---------------------------- + + +collectionCapability = filterCapability / orderByCapability / "top" / "skip" / "count" + +collectionCapabilities = "{" OWS [ collectionCapability *( separator collectionCapability ) OWS ] "}" + +collectionNavCapability = collectionCapability / navCapability + +collectionNavCapabilities = "{" OWS [ collectionNavCapability *( separator collectionNavCapability ) OWS ] "}" + +navCapability = "expand" [ OWS "{" OWS [ expandProperty *( OWS "," OWS expandProperty OWS ) ] OWS "}" ] + +navCapabilities = "{" OWS [ navCapability OWS ] "}" + +expandProperty = star / [ castSegment "/" ] navigationProperty ( [ OWS collectionNavCapabilities ] / [ OWS navCapabilities ] ) + +navigationProperty = identifier ; single or collection valued navigation property + +filterCapability = "filter" [ "{" [ OWS filterProperty *( "," OWS filterProperty OWS ) ] "}" ] + +filterProperty = ( ( [ typeName "/" ] propertyName ) / allProperties) [ OWS filterOptions ] + +allProperties = star [ "/" typeName ] ; all properties, optionally of a given type + +filterOptions = "{" OWS [ filterOperations OWS ] "}" + +filterOperations = "none" ; not filterable + / "eq" ; eq + / "comp" ; eq, gt, ge, lt, le + / "stringComp" ; eq, gt, ge, lt, le, startswith, endswith, contains + / "string" ; eq, startswith, endswith, contains + +orderByCapability = "orderby" [ OWS orderByProperties ] + +orderByProperties = "{" OWS [ orderByProperty *( "," OWS orderByProperty OWS ) ] "}" + +orderByProperty = allProperties / propertyName [ OWS orderByDirection ] + +orderByDirection ="{" [ OWS ascOrDesc [ "," OWS ascOrDesc OWS ] ] "}" + +ascOrDesc = "asc" / "desc" + +noOptions = OWS "{" OWS "}" + + + ;---------------------------- ; Core Syntax Elements ;---------------------------- + qualifiedName = identifier *( "." identifier ) identifier = identInitial *identSubsequent @@ -120,6 +255,10 @@ identInitial = ALPHA / "_" ; Note: actually all Unicode letters identSubsequent = identInitial / DIGIT +separator = OWS "," OWS / RWS + +star = "*" + number = integer [ "." 1*DIGIT ] [ "e" integer ] integer = [ "+" / "-" ] ( %x30 / %x31-39 *DIGIT ) diff --git a/website/sidebars.js b/website/sidebars.js index 4ee9b05b..8bf8d379 100644 --- a/website/sidebars.js +++ b/website/sidebars.js @@ -38,7 +38,7 @@ const sidebars = { { type: "category", label: "RAPID Schema Definition Language (RSDL)", - items: ["rsdl/rsdl-intro", "rsdl/rsdl-semantics", "rsdl/rsdl-abnf"], + items: ["rsdl/rsdl-intro", "rsdl/rsdl-paths", "rsdl/rsdl-semantics", "rsdl/rsdl-capabilities", "rsdl/rsdl-abnf"], }, { type: "category",