001/******************************************************************************* 002 * Copyright (c) 2018 Red Hat Inc 003 * All rights reserved. This program and the accompanying materials 004 * are made available under the terms of the Eclipse Public License v1.0 005 * which accompanies this distribution, and is available at 006 * http://www.eclipse.org/legal/epl-v10.html 007 * 008 * Contributors: 009 * Jens Reimann - initial API and implementation 010 *******************************************************************************/ 011package de.dentrassi.varlink.idl.services; 012 013import com.google.inject.Inject; 014import com.google.inject.Singleton; 015import java.util.List; 016import org.eclipse.xtext.Action; 017import org.eclipse.xtext.Alternatives; 018import org.eclipse.xtext.Assignment; 019import org.eclipse.xtext.CrossReference; 020import org.eclipse.xtext.Grammar; 021import org.eclipse.xtext.GrammarUtil; 022import org.eclipse.xtext.Group; 023import org.eclipse.xtext.Keyword; 024import org.eclipse.xtext.ParserRule; 025import org.eclipse.xtext.RuleCall; 026import org.eclipse.xtext.TerminalRule; 027import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder; 028import org.eclipse.xtext.service.GrammarProvider; 029 030@Singleton 031public class VarlinkIdlGrammarAccess extends AbstractGrammarElementFinder { 032 033 public class InterfaceElements extends AbstractParserRuleElementFinder { 034 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Interface"); 035 private final Group cGroup = (Group)rule.eContents().get(1); 036 private final Keyword cInterfaceKeyword_0 = (Keyword)cGroup.eContents().get(0); 037 private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); 038 private final RuleCall cNameInterfaceNameParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); 039 private final Assignment cMembersAssignment_2 = (Assignment)cGroup.eContents().get(2); 040 private final RuleCall cMembersMemberParserRuleCall_2_0 = (RuleCall)cMembersAssignment_2.eContents().get(0); 041 042 //Interface: 043 // 'interface' name=InterfaceName 044 // members+=Member*; 045 @Override public ParserRule getRule() { return rule; } 046 047 //'interface' name=InterfaceName members+=Member* 048 public Group getGroup() { return cGroup; } 049 050 //'interface' 051 public Keyword getInterfaceKeyword_0() { return cInterfaceKeyword_0; } 052 053 //name=InterfaceName 054 public Assignment getNameAssignment_1() { return cNameAssignment_1; } 055 056 //InterfaceName 057 public RuleCall getNameInterfaceNameParserRuleCall_1_0() { return cNameInterfaceNameParserRuleCall_1_0; } 058 059 //members+=Member* 060 public Assignment getMembersAssignment_2() { return cMembersAssignment_2; } 061 062 //Member 063 public RuleCall getMembersMemberParserRuleCall_2_0() { return cMembersMemberParserRuleCall_2_0; } 064 } 065 public class MemberElements extends AbstractParserRuleElementFinder { 066 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Member"); 067 private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); 068 private final RuleCall cTypeAliasParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); 069 private final RuleCall cMethodParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); 070 private final RuleCall cErrorParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); 071 072 //Member: 073 // TypeAlias | Method | Error; 074 @Override public ParserRule getRule() { return rule; } 075 076 //TypeAlias | Method | Error 077 public Alternatives getAlternatives() { return cAlternatives; } 078 079 //TypeAlias 080 public RuleCall getTypeAliasParserRuleCall_0() { return cTypeAliasParserRuleCall_0; } 081 082 //Method 083 public RuleCall getMethodParserRuleCall_1() { return cMethodParserRuleCall_1; } 084 085 //Error 086 public RuleCall getErrorParserRuleCall_2() { return cErrorParserRuleCall_2; } 087 } 088 public class TypeAliasElements extends AbstractParserRuleElementFinder { 089 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.TypeAlias"); 090 private final Group cGroup = (Group)rule.eContents().get(1); 091 private final Keyword cTypeKeyword_0 = (Keyword)cGroup.eContents().get(0); 092 private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); 093 private final RuleCall cNameValidIDParserRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); 094 private final Assignment cDefinitionAssignment_2 = (Assignment)cGroup.eContents().get(2); 095 private final RuleCall cDefinitionTypeAliasDefinitionParserRuleCall_2_0 = (RuleCall)cDefinitionAssignment_2.eContents().get(0); 096 097 //TypeAlias: 098 // 'type' name=ValidID definition=TypeAliasDefinition; 099 @Override public ParserRule getRule() { return rule; } 100 101 //'type' name=ValidID definition=TypeAliasDefinition 102 public Group getGroup() { return cGroup; } 103 104 //'type' 105 public Keyword getTypeKeyword_0() { return cTypeKeyword_0; } 106 107 //name=ValidID 108 public Assignment getNameAssignment_1() { return cNameAssignment_1; } 109 110 //ValidID 111 public RuleCall getNameValidIDParserRuleCall_1_0() { return cNameValidIDParserRuleCall_1_0; } 112 113 //definition=TypeAliasDefinition 114 public Assignment getDefinitionAssignment_2() { return cDefinitionAssignment_2; } 115 116 //TypeAliasDefinition 117 public RuleCall getDefinitionTypeAliasDefinitionParserRuleCall_2_0() { return cDefinitionTypeAliasDefinitionParserRuleCall_2_0; } 118 } 119 public class TypeAliasDefinitionElements extends AbstractParserRuleElementFinder { 120 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.TypeAliasDefinition"); 121 private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); 122 private final RuleCall cEnumParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); 123 private final RuleCall cObjectParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); 124 125 //TypeAliasDefinition: 126 // Enum | Object; 127 @Override public ParserRule getRule() { return rule; } 128 129 //Enum | Object 130 public Alternatives getAlternatives() { return cAlternatives; } 131 132 //Enum 133 public RuleCall getEnumParserRuleCall_0() { return cEnumParserRuleCall_0; } 134 135 //Object 136 public RuleCall getObjectParserRuleCall_1() { return cObjectParserRuleCall_1; } 137 } 138 public class EnumElements extends AbstractParserRuleElementFinder { 139 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Enum"); 140 private final Group cGroup = (Group)rule.eContents().get(1); 141 private final Keyword cLeftParenthesisKeyword_0 = (Keyword)cGroup.eContents().get(0); 142 private final Assignment cFieldsAssignment_1 = (Assignment)cGroup.eContents().get(1); 143 private final RuleCall cFieldsValidIDParserRuleCall_1_0 = (RuleCall)cFieldsAssignment_1.eContents().get(0); 144 private final Group cGroup_2 = (Group)cGroup.eContents().get(2); 145 private final Keyword cCommaKeyword_2_0 = (Keyword)cGroup_2.eContents().get(0); 146 private final Assignment cFieldsAssignment_2_1 = (Assignment)cGroup_2.eContents().get(1); 147 private final RuleCall cFieldsValidIDParserRuleCall_2_1_0 = (RuleCall)cFieldsAssignment_2_1.eContents().get(0); 148 private final Keyword cRightParenthesisKeyword_3 = (Keyword)cGroup.eContents().get(3); 149 150 //Enum: 151 // "(" 152 // fields+=ValidID ("," fields+=ValidID)* 153 // ")"; 154 @Override public ParserRule getRule() { return rule; } 155 156 //"(" fields+=ValidID ("," fields+=ValidID)* ")" 157 public Group getGroup() { return cGroup; } 158 159 //"(" 160 public Keyword getLeftParenthesisKeyword_0() { return cLeftParenthesisKeyword_0; } 161 162 //fields+=ValidID 163 public Assignment getFieldsAssignment_1() { return cFieldsAssignment_1; } 164 165 //ValidID 166 public RuleCall getFieldsValidIDParserRuleCall_1_0() { return cFieldsValidIDParserRuleCall_1_0; } 167 168 //("," fields+=ValidID)* 169 public Group getGroup_2() { return cGroup_2; } 170 171 //"," 172 public Keyword getCommaKeyword_2_0() { return cCommaKeyword_2_0; } 173 174 //fields+=ValidID 175 public Assignment getFieldsAssignment_2_1() { return cFieldsAssignment_2_1; } 176 177 //ValidID 178 public RuleCall getFieldsValidIDParserRuleCall_2_1_0() { return cFieldsValidIDParserRuleCall_2_1_0; } 179 180 //")" 181 public Keyword getRightParenthesisKeyword_3() { return cRightParenthesisKeyword_3; } 182 } 183 public class ObjectElements extends AbstractParserRuleElementFinder { 184 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Object"); 185 private final Group cGroup = (Group)rule.eContents().get(1); 186 private final Action cObjectAction_0 = (Action)cGroup.eContents().get(0); 187 private final Keyword cLeftParenthesisKeyword_1 = (Keyword)cGroup.eContents().get(1); 188 private final Assignment cFieldsAssignment_2 = (Assignment)cGroup.eContents().get(2); 189 private final RuleCall cFieldsFieldParserRuleCall_2_0 = (RuleCall)cFieldsAssignment_2.eContents().get(0); 190 private final Group cGroup_3 = (Group)cGroup.eContents().get(3); 191 private final Keyword cCommaKeyword_3_0 = (Keyword)cGroup_3.eContents().get(0); 192 private final Assignment cFieldsAssignment_3_1 = (Assignment)cGroup_3.eContents().get(1); 193 private final RuleCall cFieldsFieldParserRuleCall_3_1_0 = (RuleCall)cFieldsAssignment_3_1.eContents().get(0); 194 private final Keyword cRightParenthesisKeyword_4 = (Keyword)cGroup.eContents().get(4); 195 196 //Object: 197 // {Object} 198 // "(" 199 // fields+=Field? ("," fields+=Field)* 200 // ")"; 201 @Override public ParserRule getRule() { return rule; } 202 203 //{Object} "(" fields+=Field? ("," fields+=Field)* ")" 204 public Group getGroup() { return cGroup; } 205 206 //{Object} 207 public Action getObjectAction_0() { return cObjectAction_0; } 208 209 //"(" 210 public Keyword getLeftParenthesisKeyword_1() { return cLeftParenthesisKeyword_1; } 211 212 //fields+=Field? 213 public Assignment getFieldsAssignment_2() { return cFieldsAssignment_2; } 214 215 //Field 216 public RuleCall getFieldsFieldParserRuleCall_2_0() { return cFieldsFieldParserRuleCall_2_0; } 217 218 //("," fields+=Field)* 219 public Group getGroup_3() { return cGroup_3; } 220 221 //"," 222 public Keyword getCommaKeyword_3_0() { return cCommaKeyword_3_0; } 223 224 //fields+=Field 225 public Assignment getFieldsAssignment_3_1() { return cFieldsAssignment_3_1; } 226 227 //Field 228 public RuleCall getFieldsFieldParserRuleCall_3_1_0() { return cFieldsFieldParserRuleCall_3_1_0; } 229 230 //")" 231 public Keyword getRightParenthesisKeyword_4() { return cRightParenthesisKeyword_4; } 232 } 233 public class FieldElements extends AbstractParserRuleElementFinder { 234 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Field"); 235 private final Group cGroup = (Group)rule.eContents().get(1); 236 private final Assignment cNameAssignment_0 = (Assignment)cGroup.eContents().get(0); 237 private final RuleCall cNameValidIDParserRuleCall_0_0 = (RuleCall)cNameAssignment_0.eContents().get(0); 238 private final Keyword cColonKeyword_1 = (Keyword)cGroup.eContents().get(1); 239 private final Assignment cTypeAssignment_2 = (Assignment)cGroup.eContents().get(2); 240 private final RuleCall cTypeElementTypeParserRuleCall_2_0 = (RuleCall)cTypeAssignment_2.eContents().get(0); 241 242 //Field: 243 // name=ValidID ":" type=ElementType; 244 @Override public ParserRule getRule() { return rule; } 245 246 //name=ValidID ":" type=ElementType 247 public Group getGroup() { return cGroup; } 248 249 //name=ValidID 250 public Assignment getNameAssignment_0() { return cNameAssignment_0; } 251 252 //ValidID 253 public RuleCall getNameValidIDParserRuleCall_0_0() { return cNameValidIDParserRuleCall_0_0; } 254 255 //":" 256 public Keyword getColonKeyword_1() { return cColonKeyword_1; } 257 258 //type=ElementType 259 public Assignment getTypeAssignment_2() { return cTypeAssignment_2; } 260 261 //ElementType 262 public RuleCall getTypeElementTypeParserRuleCall_2_0() { return cTypeElementTypeParserRuleCall_2_0; } 263 } 264 public class ElementTypeElements extends AbstractParserRuleElementFinder { 265 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.ElementType"); 266 private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); 267 private final RuleCall cBasicTypeParserRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); 268 private final RuleCall cTypeReferenceParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); 269 private final RuleCall cEnumParserRuleCall_2 = (RuleCall)cAlternatives.eContents().get(2); 270 private final RuleCall cObjectParserRuleCall_3 = (RuleCall)cAlternatives.eContents().get(3); 271 private final RuleCall cArrayParserRuleCall_4 = (RuleCall)cAlternatives.eContents().get(4); 272 private final RuleCall cDictionaryParserRuleCall_5 = (RuleCall)cAlternatives.eContents().get(5); 273 private final RuleCall cOptionalParserRuleCall_6 = (RuleCall)cAlternatives.eContents().get(6); 274 275 //ElementType: 276 // BasicType | TypeReference | Enum | Object | Array | Dictionary | Optional; 277 @Override public ParserRule getRule() { return rule; } 278 279 //BasicType | TypeReference | Enum | Object | Array | Dictionary | Optional 280 public Alternatives getAlternatives() { return cAlternatives; } 281 282 //BasicType 283 public RuleCall getBasicTypeParserRuleCall_0() { return cBasicTypeParserRuleCall_0; } 284 285 //TypeReference 286 public RuleCall getTypeReferenceParserRuleCall_1() { return cTypeReferenceParserRuleCall_1; } 287 288 //Enum 289 public RuleCall getEnumParserRuleCall_2() { return cEnumParserRuleCall_2; } 290 291 //Object 292 public RuleCall getObjectParserRuleCall_3() { return cObjectParserRuleCall_3; } 293 294 //Array 295 public RuleCall getArrayParserRuleCall_4() { return cArrayParserRuleCall_4; } 296 297 //Dictionary 298 public RuleCall getDictionaryParserRuleCall_5() { return cDictionaryParserRuleCall_5; } 299 300 //Optional 301 public RuleCall getOptionalParserRuleCall_6() { return cOptionalParserRuleCall_6; } 302 } 303 public class ArrayElements extends AbstractParserRuleElementFinder { 304 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Array"); 305 private final Group cGroup = (Group)rule.eContents().get(1); 306 private final Keyword cLeftSquareBracketRightSquareBracketKeyword_0 = (Keyword)cGroup.eContents().get(0); 307 private final Assignment cTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); 308 private final RuleCall cTypeElementTypeParserRuleCall_1_0 = (RuleCall)cTypeAssignment_1.eContents().get(0); 309 310 //Array: 311 // "[]" type=ElementType; 312 @Override public ParserRule getRule() { return rule; } 313 314 //"[]" type=ElementType 315 public Group getGroup() { return cGroup; } 316 317 //"[]" 318 public Keyword getLeftSquareBracketRightSquareBracketKeyword_0() { return cLeftSquareBracketRightSquareBracketKeyword_0; } 319 320 //type=ElementType 321 public Assignment getTypeAssignment_1() { return cTypeAssignment_1; } 322 323 //ElementType 324 public RuleCall getTypeElementTypeParserRuleCall_1_0() { return cTypeElementTypeParserRuleCall_1_0; } 325 } 326 public class DictionaryElements extends AbstractParserRuleElementFinder { 327 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Dictionary"); 328 private final Group cGroup = (Group)rule.eContents().get(1); 329 private final Keyword cStringKeyword_0 = (Keyword)cGroup.eContents().get(0); 330 private final Assignment cTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); 331 private final RuleCall cTypeElementTypeParserRuleCall_1_0 = (RuleCall)cTypeAssignment_1.eContents().get(0); 332 333 //Dictionary: 334 // "[string]" type=ElementType; 335 @Override public ParserRule getRule() { return rule; } 336 337 //"[string]" type=ElementType 338 public Group getGroup() { return cGroup; } 339 340 //"[string]" 341 public Keyword getStringKeyword_0() { return cStringKeyword_0; } 342 343 //type=ElementType 344 public Assignment getTypeAssignment_1() { return cTypeAssignment_1; } 345 346 //ElementType 347 public RuleCall getTypeElementTypeParserRuleCall_1_0() { return cTypeElementTypeParserRuleCall_1_0; } 348 } 349 public class OptionalElements extends AbstractParserRuleElementFinder { 350 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Optional"); 351 private final Group cGroup = (Group)rule.eContents().get(1); 352 private final Keyword cQuestionMarkKeyword_0 = (Keyword)cGroup.eContents().get(0); 353 private final Assignment cTypeAssignment_1 = (Assignment)cGroup.eContents().get(1); 354 private final RuleCall cTypeElementTypeParserRuleCall_1_0 = (RuleCall)cTypeAssignment_1.eContents().get(0); 355 356 //Optional: 357 // "?" type=ElementType; 358 @Override public ParserRule getRule() { return rule; } 359 360 //"?" type=ElementType 361 public Group getGroup() { return cGroup; } 362 363 //"?" 364 public Keyword getQuestionMarkKeyword_0() { return cQuestionMarkKeyword_0; } 365 366 //type=ElementType 367 public Assignment getTypeAssignment_1() { return cTypeAssignment_1; } 368 369 //ElementType 370 public RuleCall getTypeElementTypeParserRuleCall_1_0() { return cTypeElementTypeParserRuleCall_1_0; } 371 } 372 public class TypeReferenceElements extends AbstractParserRuleElementFinder { 373 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.TypeReference"); 374 private final Assignment cNameAssignment = (Assignment)rule.eContents().get(1); 375 private final CrossReference cNameTypeAliasCrossReference_0 = (CrossReference)cNameAssignment.eContents().get(0); 376 private final RuleCall cNameTypeAliasIDTerminalRuleCall_0_1 = (RuleCall)cNameTypeAliasCrossReference_0.eContents().get(1); 377 378 //TypeReference: 379 // name=[TypeAlias]; 380 @Override public ParserRule getRule() { return rule; } 381 382 //name=[TypeAlias] 383 public Assignment getNameAssignment() { return cNameAssignment; } 384 385 //[TypeAlias] 386 public CrossReference getNameTypeAliasCrossReference_0() { return cNameTypeAliasCrossReference_0; } 387 388 //ID 389 public RuleCall getNameTypeAliasIDTerminalRuleCall_0_1() { return cNameTypeAliasIDTerminalRuleCall_0_1; } 390 } 391 public class BasicTypeElements extends AbstractParserRuleElementFinder { 392 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.BasicType"); 393 private final Assignment cTypeAssignment = (Assignment)rule.eContents().get(1); 394 private final Alternatives cTypeAlternatives_0 = (Alternatives)cTypeAssignment.eContents().get(0); 395 private final Keyword cTypeBoolKeyword_0_0 = (Keyword)cTypeAlternatives_0.eContents().get(0); 396 private final Keyword cTypeIntKeyword_0_1 = (Keyword)cTypeAlternatives_0.eContents().get(1); 397 private final Keyword cTypeFloatKeyword_0_2 = (Keyword)cTypeAlternatives_0.eContents().get(2); 398 private final Keyword cTypeStringKeyword_0_3 = (Keyword)cTypeAlternatives_0.eContents().get(3); 399 400 //BasicType: 401 // type=("bool" | "int" | "float" | "string"); 402 @Override public ParserRule getRule() { return rule; } 403 404 //type=("bool" | "int" | "float" | "string") 405 public Assignment getTypeAssignment() { return cTypeAssignment; } 406 407 //("bool" | "int" | "float" | "string") 408 public Alternatives getTypeAlternatives_0() { return cTypeAlternatives_0; } 409 410 //"bool" 411 public Keyword getTypeBoolKeyword_0_0() { return cTypeBoolKeyword_0_0; } 412 413 //"int" 414 public Keyword getTypeIntKeyword_0_1() { return cTypeIntKeyword_0_1; } 415 416 //"float" 417 public Keyword getTypeFloatKeyword_0_2() { return cTypeFloatKeyword_0_2; } 418 419 //"string" 420 public Keyword getTypeStringKeyword_0_3() { return cTypeStringKeyword_0_3; } 421 } 422 public class MethodElements extends AbstractParserRuleElementFinder { 423 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Method"); 424 private final Group cGroup = (Group)rule.eContents().get(1); 425 private final Keyword cMethodKeyword_0 = (Keyword)cGroup.eContents().get(0); 426 private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); 427 private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); 428 private final Assignment cArgumentsAssignment_2 = (Assignment)cGroup.eContents().get(2); 429 private final RuleCall cArgumentsArgumentsParserRuleCall_2_0 = (RuleCall)cArgumentsAssignment_2.eContents().get(0); 430 private final Keyword cHyphenMinusGreaterThanSignKeyword_3 = (Keyword)cGroup.eContents().get(3); 431 private final Assignment cResultAssignment_4 = (Assignment)cGroup.eContents().get(4); 432 private final RuleCall cResultResultParserRuleCall_4_0 = (RuleCall)cResultAssignment_4.eContents().get(0); 433 434 //Method: 435 // 'method' name=ID arguments=Arguments "->" result=Result; 436 @Override public ParserRule getRule() { return rule; } 437 438 //'method' name=ID arguments=Arguments "->" result=Result 439 public Group getGroup() { return cGroup; } 440 441 //'method' 442 public Keyword getMethodKeyword_0() { return cMethodKeyword_0; } 443 444 //name=ID 445 public Assignment getNameAssignment_1() { return cNameAssignment_1; } 446 447 //ID 448 public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; } 449 450 //arguments=Arguments 451 public Assignment getArgumentsAssignment_2() { return cArgumentsAssignment_2; } 452 453 //Arguments 454 public RuleCall getArgumentsArgumentsParserRuleCall_2_0() { return cArgumentsArgumentsParserRuleCall_2_0; } 455 456 //"->" 457 public Keyword getHyphenMinusGreaterThanSignKeyword_3() { return cHyphenMinusGreaterThanSignKeyword_3; } 458 459 //result=Result 460 public Assignment getResultAssignment_4() { return cResultAssignment_4; } 461 462 //Result 463 public RuleCall getResultResultParserRuleCall_4_0() { return cResultResultParserRuleCall_4_0; } 464 } 465 public class ArgumentsElements extends AbstractParserRuleElementFinder { 466 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Arguments"); 467 private final Assignment cArgumentsAssignment = (Assignment)rule.eContents().get(1); 468 private final RuleCall cArgumentsObjectParserRuleCall_0 = (RuleCall)cArgumentsAssignment.eContents().get(0); 469 470 //Arguments: 471 // arguments=Object; 472 @Override public ParserRule getRule() { return rule; } 473 474 //arguments=Object 475 public Assignment getArgumentsAssignment() { return cArgumentsAssignment; } 476 477 //Object 478 public RuleCall getArgumentsObjectParserRuleCall_0() { return cArgumentsObjectParserRuleCall_0; } 479 } 480 public class ResultElements extends AbstractParserRuleElementFinder { 481 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Result"); 482 private final Assignment cResultAssignment = (Assignment)rule.eContents().get(1); 483 private final RuleCall cResultObjectParserRuleCall_0 = (RuleCall)cResultAssignment.eContents().get(0); 484 485 //Result: 486 // result=Object; 487 @Override public ParserRule getRule() { return rule; } 488 489 //result=Object 490 public Assignment getResultAssignment() { return cResultAssignment; } 491 492 //Object 493 public RuleCall getResultObjectParserRuleCall_0() { return cResultObjectParserRuleCall_0; } 494 } 495 public class ErrorElements extends AbstractParserRuleElementFinder { 496 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.Error"); 497 private final Group cGroup = (Group)rule.eContents().get(1); 498 private final Keyword cErrorKeyword_0 = (Keyword)cGroup.eContents().get(0); 499 private final Assignment cNameAssignment_1 = (Assignment)cGroup.eContents().get(1); 500 private final RuleCall cNameIDTerminalRuleCall_1_0 = (RuleCall)cNameAssignment_1.eContents().get(0); 501 private final Assignment cPropertiesAssignment_2 = (Assignment)cGroup.eContents().get(2); 502 private final RuleCall cPropertiesObjectParserRuleCall_2_0 = (RuleCall)cPropertiesAssignment_2.eContents().get(0); 503 504 //Error: 505 // 'error' name=ID properties=Object; 506 @Override public ParserRule getRule() { return rule; } 507 508 //'error' name=ID properties=Object 509 public Group getGroup() { return cGroup; } 510 511 //'error' 512 public Keyword getErrorKeyword_0() { return cErrorKeyword_0; } 513 514 //name=ID 515 public Assignment getNameAssignment_1() { return cNameAssignment_1; } 516 517 //ID 518 public RuleCall getNameIDTerminalRuleCall_1_0() { return cNameIDTerminalRuleCall_1_0; } 519 520 //properties=Object 521 public Assignment getPropertiesAssignment_2() { return cPropertiesAssignment_2; } 522 523 //Object 524 public RuleCall getPropertiesObjectParserRuleCall_2_0() { return cPropertiesObjectParserRuleCall_2_0; } 525 } 526 public class InterfaceNameElements extends AbstractParserRuleElementFinder { 527 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.InterfaceName"); 528 private final Group cGroup = (Group)rule.eContents().get(1); 529 private final RuleCall cIDTerminalRuleCall_0 = (RuleCall)cGroup.eContents().get(0); 530 private final Group cGroup_1 = (Group)cGroup.eContents().get(1); 531 private final Keyword cFullStopKeyword_1_0 = (Keyword)cGroup_1.eContents().get(0); 532 private final RuleCall cIDTerminalRuleCall_1_1 = (RuleCall)cGroup_1.eContents().get(1); 533 534 //InterfaceName: 535 // ID (=> "." ID)*; 536 @Override public ParserRule getRule() { return rule; } 537 538 //ID (=> "." ID)* 539 public Group getGroup() { return cGroup; } 540 541 //ID 542 public RuleCall getIDTerminalRuleCall_0() { return cIDTerminalRuleCall_0; } 543 544 //(=> "." ID)* 545 public Group getGroup_1() { return cGroup_1; } 546 547 //=> "." 548 public Keyword getFullStopKeyword_1_0() { return cFullStopKeyword_1_0; } 549 550 //ID 551 public RuleCall getIDTerminalRuleCall_1_1() { return cIDTerminalRuleCall_1_1; } 552 } 553 public class ValidIDElements extends AbstractParserRuleElementFinder { 554 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.ValidID"); 555 private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); 556 private final RuleCall cIDTerminalRuleCall_0 = (RuleCall)cAlternatives.eContents().get(0); 557 private final RuleCall cKEYWORDParserRuleCall_1 = (RuleCall)cAlternatives.eContents().get(1); 558 559 //// terminals 560 //ValidID: 561 // ID | KEYWORD; 562 @Override public ParserRule getRule() { return rule; } 563 564 //ID | KEYWORD 565 public Alternatives getAlternatives() { return cAlternatives; } 566 567 //ID 568 public RuleCall getIDTerminalRuleCall_0() { return cIDTerminalRuleCall_0; } 569 570 //KEYWORD 571 public RuleCall getKEYWORDParserRuleCall_1() { return cKEYWORDParserRuleCall_1; } 572 } 573 public class KEYWORDElements extends AbstractParserRuleElementFinder { 574 private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.KEYWORD"); 575 private final Alternatives cAlternatives = (Alternatives)rule.eContents().get(1); 576 private final Keyword cTypeKeyword_0 = (Keyword)cAlternatives.eContents().get(0); 577 private final Keyword cEnumKeyword_1 = (Keyword)cAlternatives.eContents().get(1); 578 private final Keyword cInterfaceKeyword_2 = (Keyword)cAlternatives.eContents().get(2); 579 private final Keyword cMethodKeyword_3 = (Keyword)cAlternatives.eContents().get(3); 580 private final Keyword cErrorKeyword_4 = (Keyword)cAlternatives.eContents().get(4); 581 private final Keyword cBoolKeyword_5 = (Keyword)cAlternatives.eContents().get(5); 582 private final Keyword cIntKeyword_6 = (Keyword)cAlternatives.eContents().get(6); 583 private final Keyword cFloatKeyword_7 = (Keyword)cAlternatives.eContents().get(7); 584 private final Keyword cStringKeyword_8 = (Keyword)cAlternatives.eContents().get(8); 585 586 //KEYWORD: 587 // 'type' | 'enum' | 'interface' | 'method' | 'error' | 'bool' | 'int' | 'float' | 'string'; 588 @Override public ParserRule getRule() { return rule; } 589 590 //'type' | 'enum' | 'interface' | 'method' | 'error' | 'bool' | 'int' | 'float' | 'string' 591 public Alternatives getAlternatives() { return cAlternatives; } 592 593 //'type' 594 public Keyword getTypeKeyword_0() { return cTypeKeyword_0; } 595 596 //'enum' 597 public Keyword getEnumKeyword_1() { return cEnumKeyword_1; } 598 599 //'interface' 600 public Keyword getInterfaceKeyword_2() { return cInterfaceKeyword_2; } 601 602 //'method' 603 public Keyword getMethodKeyword_3() { return cMethodKeyword_3; } 604 605 //'error' 606 public Keyword getErrorKeyword_4() { return cErrorKeyword_4; } 607 608 //'bool' 609 public Keyword getBoolKeyword_5() { return cBoolKeyword_5; } 610 611 //'int' 612 public Keyword getIntKeyword_6() { return cIntKeyword_6; } 613 614 //'float' 615 public Keyword getFloatKeyword_7() { return cFloatKeyword_7; } 616 617 //'string' 618 public Keyword getStringKeyword_8() { return cStringKeyword_8; } 619 } 620 621 622 private final InterfaceElements pInterface; 623 private final MemberElements pMember; 624 private final TypeAliasElements pTypeAlias; 625 private final TypeAliasDefinitionElements pTypeAliasDefinition; 626 private final EnumElements pEnum; 627 private final ObjectElements pObject; 628 private final FieldElements pField; 629 private final ElementTypeElements pElementType; 630 private final ArrayElements pArray; 631 private final DictionaryElements pDictionary; 632 private final OptionalElements pOptional; 633 private final TypeReferenceElements pTypeReference; 634 private final BasicTypeElements pBasicType; 635 private final MethodElements pMethod; 636 private final ArgumentsElements pArguments; 637 private final ResultElements pResult; 638 private final ErrorElements pError; 639 private final InterfaceNameElements pInterfaceName; 640 private final ValidIDElements pValidID; 641 private final KEYWORDElements pKEYWORD; 642 private final TerminalRule tID; 643 private final TerminalRule tSL_COMMENT; 644 private final TerminalRule tWS; 645 private final TerminalRule tANY_OTHER; 646 647 private final Grammar grammar; 648 649 @Inject 650 public VarlinkIdlGrammarAccess(GrammarProvider grammarProvider) { 651 this.grammar = internalFindGrammar(grammarProvider); 652 this.pInterface = new InterfaceElements(); 653 this.pMember = new MemberElements(); 654 this.pTypeAlias = new TypeAliasElements(); 655 this.pTypeAliasDefinition = new TypeAliasDefinitionElements(); 656 this.pEnum = new EnumElements(); 657 this.pObject = new ObjectElements(); 658 this.pField = new FieldElements(); 659 this.pElementType = new ElementTypeElements(); 660 this.pArray = new ArrayElements(); 661 this.pDictionary = new DictionaryElements(); 662 this.pOptional = new OptionalElements(); 663 this.pTypeReference = new TypeReferenceElements(); 664 this.pBasicType = new BasicTypeElements(); 665 this.pMethod = new MethodElements(); 666 this.pArguments = new ArgumentsElements(); 667 this.pResult = new ResultElements(); 668 this.pError = new ErrorElements(); 669 this.pInterfaceName = new InterfaceNameElements(); 670 this.pValidID = new ValidIDElements(); 671 this.pKEYWORD = new KEYWORDElements(); 672 this.tID = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.ID"); 673 this.tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.SL_COMMENT"); 674 this.tWS = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.WS"); 675 this.tANY_OTHER = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "de.dentrassi.varlink.idl.VarlinkIdl.ANY_OTHER"); 676 } 677 678 protected Grammar internalFindGrammar(GrammarProvider grammarProvider) { 679 Grammar grammar = grammarProvider.getGrammar(this); 680 while (grammar != null) { 681 if ("de.dentrassi.varlink.idl.VarlinkIdl".equals(grammar.getName())) { 682 return grammar; 683 } 684 List<Grammar> grammars = grammar.getUsedGrammars(); 685 if (!grammars.isEmpty()) { 686 grammar = grammars.iterator().next(); 687 } else { 688 return null; 689 } 690 } 691 return grammar; 692 } 693 694 @Override 695 public Grammar getGrammar() { 696 return grammar; 697 } 698 699 700 701 //Interface: 702 // 'interface' name=InterfaceName 703 // members+=Member*; 704 public InterfaceElements getInterfaceAccess() { 705 return pInterface; 706 } 707 708 public ParserRule getInterfaceRule() { 709 return getInterfaceAccess().getRule(); 710 } 711 712 //Member: 713 // TypeAlias | Method | Error; 714 public MemberElements getMemberAccess() { 715 return pMember; 716 } 717 718 public ParserRule getMemberRule() { 719 return getMemberAccess().getRule(); 720 } 721 722 //TypeAlias: 723 // 'type' name=ValidID definition=TypeAliasDefinition; 724 public TypeAliasElements getTypeAliasAccess() { 725 return pTypeAlias; 726 } 727 728 public ParserRule getTypeAliasRule() { 729 return getTypeAliasAccess().getRule(); 730 } 731 732 //TypeAliasDefinition: 733 // Enum | Object; 734 public TypeAliasDefinitionElements getTypeAliasDefinitionAccess() { 735 return pTypeAliasDefinition; 736 } 737 738 public ParserRule getTypeAliasDefinitionRule() { 739 return getTypeAliasDefinitionAccess().getRule(); 740 } 741 742 //Enum: 743 // "(" 744 // fields+=ValidID ("," fields+=ValidID)* 745 // ")"; 746 public EnumElements getEnumAccess() { 747 return pEnum; 748 } 749 750 public ParserRule getEnumRule() { 751 return getEnumAccess().getRule(); 752 } 753 754 //Object: 755 // {Object} 756 // "(" 757 // fields+=Field? ("," fields+=Field)* 758 // ")"; 759 public ObjectElements getObjectAccess() { 760 return pObject; 761 } 762 763 public ParserRule getObjectRule() { 764 return getObjectAccess().getRule(); 765 } 766 767 //Field: 768 // name=ValidID ":" type=ElementType; 769 public FieldElements getFieldAccess() { 770 return pField; 771 } 772 773 public ParserRule getFieldRule() { 774 return getFieldAccess().getRule(); 775 } 776 777 //ElementType: 778 // BasicType | TypeReference | Enum | Object | Array | Dictionary | Optional; 779 public ElementTypeElements getElementTypeAccess() { 780 return pElementType; 781 } 782 783 public ParserRule getElementTypeRule() { 784 return getElementTypeAccess().getRule(); 785 } 786 787 //Array: 788 // "[]" type=ElementType; 789 public ArrayElements getArrayAccess() { 790 return pArray; 791 } 792 793 public ParserRule getArrayRule() { 794 return getArrayAccess().getRule(); 795 } 796 797 //Dictionary: 798 // "[string]" type=ElementType; 799 public DictionaryElements getDictionaryAccess() { 800 return pDictionary; 801 } 802 803 public ParserRule getDictionaryRule() { 804 return getDictionaryAccess().getRule(); 805 } 806 807 //Optional: 808 // "?" type=ElementType; 809 public OptionalElements getOptionalAccess() { 810 return pOptional; 811 } 812 813 public ParserRule getOptionalRule() { 814 return getOptionalAccess().getRule(); 815 } 816 817 //TypeReference: 818 // name=[TypeAlias]; 819 public TypeReferenceElements getTypeReferenceAccess() { 820 return pTypeReference; 821 } 822 823 public ParserRule getTypeReferenceRule() { 824 return getTypeReferenceAccess().getRule(); 825 } 826 827 //BasicType: 828 // type=("bool" | "int" | "float" | "string"); 829 public BasicTypeElements getBasicTypeAccess() { 830 return pBasicType; 831 } 832 833 public ParserRule getBasicTypeRule() { 834 return getBasicTypeAccess().getRule(); 835 } 836 837 //Method: 838 // 'method' name=ID arguments=Arguments "->" result=Result; 839 public MethodElements getMethodAccess() { 840 return pMethod; 841 } 842 843 public ParserRule getMethodRule() { 844 return getMethodAccess().getRule(); 845 } 846 847 //Arguments: 848 // arguments=Object; 849 public ArgumentsElements getArgumentsAccess() { 850 return pArguments; 851 } 852 853 public ParserRule getArgumentsRule() { 854 return getArgumentsAccess().getRule(); 855 } 856 857 //Result: 858 // result=Object; 859 public ResultElements getResultAccess() { 860 return pResult; 861 } 862 863 public ParserRule getResultRule() { 864 return getResultAccess().getRule(); 865 } 866 867 //Error: 868 // 'error' name=ID properties=Object; 869 public ErrorElements getErrorAccess() { 870 return pError; 871 } 872 873 public ParserRule getErrorRule() { 874 return getErrorAccess().getRule(); 875 } 876 877 //InterfaceName: 878 // ID (=> "." ID)*; 879 public InterfaceNameElements getInterfaceNameAccess() { 880 return pInterfaceName; 881 } 882 883 public ParserRule getInterfaceNameRule() { 884 return getInterfaceNameAccess().getRule(); 885 } 886 887 //// terminals 888 //ValidID: 889 // ID | KEYWORD; 890 public ValidIDElements getValidIDAccess() { 891 return pValidID; 892 } 893 894 public ParserRule getValidIDRule() { 895 return getValidIDAccess().getRule(); 896 } 897 898 //KEYWORD: 899 // 'type' | 'enum' | 'interface' | 'method' | 'error' | 'bool' | 'int' | 'float' | 'string'; 900 public KEYWORDElements getKEYWORDAccess() { 901 return pKEYWORD; 902 } 903 904 public ParserRule getKEYWORDRule() { 905 return getKEYWORDAccess().getRule(); 906 } 907 908 //terminal ID: 909 // ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*; 910 public TerminalRule getIDRule() { 911 return tID; 912 } 913 914 //terminal SL_COMMENT: 915 // '#' !('\n' | '\r')* ('\r'? '\n')?; 916 public TerminalRule getSL_COMMENTRule() { 917 return tSL_COMMENT; 918 } 919 920 //terminal WS: 921 // ' ' | '\t' | '\r' | '\n'+; 922 public TerminalRule getWSRule() { 923 return tWS; 924 } 925 926 //terminal ANY_OTHER: 927 // .; 928 public TerminalRule getANY_OTHERRule() { 929 return tANY_OTHER; 930 } 931}