/**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link DawnGmfGenmodelPackage#eINSTANCE} when that field
   * is accessed. Clients should not invoke it directly. Instead, they should simply access that
   * field to obtain the package.
   * <!--
   * begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static DawnGmfGenmodelPackage init() {
    if (isInited) {
      return (DawnGmfGenmodelPackage)
          EPackage.Registry.INSTANCE.getEPackage(DawnGmfGenmodelPackage.eNS_URI);
    }

    // Obtain or create and register package
    DawnGmfGenmodelPackageImpl theDawnGmfGenmodelPackage =
        (DawnGmfGenmodelPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof DawnGmfGenmodelPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new DawnGmfGenmodelPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    DawngenmodelPackage.eINSTANCE.eClass();
    GMFGenPackage.eINSTANCE.eClass();

    // Create package meta-data objects
    theDawnGmfGenmodelPackage.createPackageContents();

    // Initialize created meta-data
    theDawnGmfGenmodelPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theDawnGmfGenmodelPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(DawnGmfGenmodelPackage.eNS_URI, theDawnGmfGenmodelPackage);
    return theDawnGmfGenmodelPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link Graphics2dPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static Graphics2dPackage init() {
    if (isInited)
      return (Graphics2dPackage) EPackage.Registry.INSTANCE.getEPackage(Graphics2dPackage.eNS_URI);

    // Obtain or create and register package
    Graphics2dPackageImpl theGraphics2dPackage =
        (Graphics2dPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof Graphics2dPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new Graphics2dPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    WidgetsPackage.eINSTANCE.eClass();
    StylesPackage.eINSTANCE.eClass();
    LayoutsPackage.eINSTANCE.eClass();
    UtilPackage.eINSTANCE.eClass();

    // Create package meta-data objects
    theGraphics2dPackage.createPackageContents();

    // Initialize created meta-data
    theGraphics2dPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theGraphics2dPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(Graphics2dPackage.eNS_URI, theGraphics2dPackage);
    return theGraphics2dPackage;
  }
Exemplo n.º 3
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link MyDslPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static MyDslPackage init() {
    if (isInited)
      return (MyDslPackage) EPackage.Registry.INSTANCE.getEPackage(MyDslPackage.eNS_URI);

    // Obtain or create and register package
    MyDslPackageImpl theMyDslPackage =
        (MyDslPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof MyDslPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new MyDslPackageImpl());

    isInited = true;

    // Create package meta-data objects
    theMyDslPackage.createPackageContents();

    // Initialize created meta-data
    theMyDslPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theMyDslPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(MyDslPackage.eNS_URI, theMyDslPackage);
    return theMyDslPackage;
  }
Exemplo n.º 4
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link RuleEnginePackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static RuleEnginePackage init() {
    if (isInited)
      return (RuleEnginePackage) EPackage.Registry.INSTANCE.getEPackage(RuleEnginePackage.eNS_URI);

    // Obtain or create and register package
    RuleEnginePackageImpl theRuleEnginePackage =
        (RuleEnginePackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof RuleEnginePackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new RuleEnginePackageImpl());

    isInited = true;

    // Initialize simple dependencies
    XbasePackage.eINSTANCE.eClass();

    // Create package meta-data objects
    theRuleEnginePackage.createPackageContents();

    // Initialize created meta-data
    theRuleEnginePackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theRuleEnginePackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(RuleEnginePackage.eNS_URI, theRuleEnginePackage);
    return theRuleEnginePackage;
  }
Exemplo n.º 5
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link LibraryPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static LibraryPackage init() {
    if (isInited)
      return (LibraryPackage) EPackage.Registry.INSTANCE.getEPackage(LibraryPackage.eNS_URI);

    // Obtain or create and register package
    LibraryPackageImpl theLibraryPackage =
        (LibraryPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof LibraryPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new LibraryPackageImpl());

    isInited = true;

    // Create package meta-data objects
    theLibraryPackage.createPackageContents();

    // Initialize created meta-data
    theLibraryPackage.initializePackageContents();

    // Register package validator
    EValidator.Registry.INSTANCE.put(
        theLibraryPackage,
        new EValidator.Descriptor() {
          public EValidator getEValidator() {
            return LibraryValidator.INSTANCE;
          }
        });

    // Mark meta-data to indicate it can't be changed
    theLibraryPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(LibraryPackage.eNS_URI, theLibraryPackage);
    return theLibraryPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link StatesPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static StatesPackage init() {
    if (isInited)
      return (StatesPackage) EPackage.Registry.INSTANCE.getEPackage(StatesPackage.eNS_URI);

    // Obtain or create and register package
    StatesPackageImpl theStatesPackage =
        (StatesPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof StatesPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new StatesPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    ArduinoPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    ArduinoTracePackageImpl theArduinoTracePackage =
        (ArduinoTracePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ArduinoTracePackage.eNS_URI)
                    instanceof ArduinoTracePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ArduinoTracePackage.eNS_URI)
                : ArduinoTracePackage.eINSTANCE);
    StepsPackageImpl theStepsPackage =
        (StepsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(StepsPackage.eNS_URI)
                    instanceof StepsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(StepsPackage.eNS_URI)
                : StepsPackage.eINSTANCE);
    ArduinoPackageImpl theArduinoPackage_1 =
        (ArduinoPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(
                        arduinoTrace.States.arduino.ArduinoPackage.eNS_URI)
                    instanceof ArduinoPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(
                    arduinoTrace.States.arduino.ArduinoPackage.eNS_URI)
                : arduinoTrace.States.arduino.ArduinoPackage.eINSTANCE);

    // Create package meta-data objects
    theStatesPackage.createPackageContents();
    theArduinoTracePackage.createPackageContents();
    theStepsPackage.createPackageContents();
    theArduinoPackage_1.createPackageContents();

    // Initialize created meta-data
    theStatesPackage.initializePackageContents();
    theArduinoTracePackage.initializePackageContents();
    theStepsPackage.initializePackageContents();
    theArduinoPackage_1.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theStatesPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(StatesPackage.eNS_URI, theStatesPackage);
    return theStatesPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link EnactmentPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static EnactmentPackage init() {
    if (isInited)
      return (EnactmentPackage) EPackage.Registry.INSTANCE.getEPackage(EnactmentPackage.eNS_URI);

    // Obtain or create and register package
    EnactmentPackageImpl theEnactmentPackage =
        (EnactmentPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof EnactmentPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new EnactmentPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    TasksPackage.eINSTANCE.eClass();
    NormInstancesPackage.eINSTANCE.eClass();
    ServicePackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    ActionPackageImpl theActionPackage =
        (ActionPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ActionPackage.eNS_URI)
                    instanceof ActionPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ActionPackage.eNS_URI)
                : ActionPackage.eINSTANCE);
    EventPackageImpl theEventPackage =
        (EventPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(EventPackage.eNS_URI)
                    instanceof EventPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(EventPackage.eNS_URI)
                : EventPackage.eINSTANCE);
    FactPackageImpl theFactPackage =
        (FactPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(FactPackage.eNS_URI) instanceof FactPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(FactPackage.eNS_URI)
                : FactPackage.eINSTANCE);

    // Create package meta-data objects
    theEnactmentPackage.createPackageContents();
    theActionPackage.createPackageContents();
    theEventPackage.createPackageContents();
    theFactPackage.createPackageContents();

    // Initialize created meta-data
    theEnactmentPackage.initializePackageContents();
    theActionPackage.initializePackageContents();
    theEventPackage.initializePackageContents();
    theFactPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theEnactmentPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(EnactmentPackage.eNS_URI, theEnactmentPackage);
    return theEnactmentPackage;
  }
Exemplo n.º 8
0
class Libraries extends Plugin {

  public static final String OCL_LIBRARY_PACKAGE =
      EPackage.Registry.INSTANCE.get(EcoreEnvironment.OCL_STANDARD_LIBRARY_NS_URI)
              instanceof EPackage
          ? ((EPackage)
                  EPackage.Registry.INSTANCE.get(EcoreEnvironment.OCL_STANDARD_LIBRARY_NS_URI))
              .getName()
          : "oclstdlib"; //$NON-NLS-1$
}
Exemplo n.º 9
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link EditorPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static EditorPackage init() {
    if (isInited)
      return (EditorPackage) EPackage.Registry.INSTANCE.getEPackage(EditorPackage.eNS_URI);

    // Obtain or create and register package
    EditorPackageImpl theEditorPackage =
        (EditorPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof EditorPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new EditorPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    MAVOPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    MIDPackageImpl theMIDPackage =
        (MIDPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(MIDPackage.eNS_URI) instanceof MIDPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(MIDPackage.eNS_URI)
                : MIDPackage.eINSTANCE);
    RelationshipPackageImpl theRelationshipPackage =
        (RelationshipPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(RelationshipPackage.eNS_URI)
                    instanceof RelationshipPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(RelationshipPackage.eNS_URI)
                : RelationshipPackage.eINSTANCE);
    OperatorPackageImpl theOperatorPackage =
        (OperatorPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(OperatorPackage.eNS_URI)
                    instanceof OperatorPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(OperatorPackage.eNS_URI)
                : OperatorPackage.eINSTANCE);

    // Create package meta-data objects
    theEditorPackage.createPackageContents();
    theMIDPackage.createPackageContents();
    theRelationshipPackage.createPackageContents();
    theOperatorPackage.createPackageContents();

    // Initialize created meta-data
    theEditorPackage.initializePackageContents();
    theMIDPackage.initializePackageContents();
    theRelationshipPackage.initializePackageContents();
    theOperatorPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theEditorPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(EditorPackage.eNS_URI, theEditorPackage);
    return theEditorPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link CinematicPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static CinematicPackage init() {
    if (isInited)
      return (CinematicPackage) EPackage.Registry.INSTANCE.getEPackage(CinematicPackage.eNS_URI);

    // Obtain or create and register package
    CinematicPackageImpl theCinematicPackage =
        (CinematicPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof CinematicPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new CinematicPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    EnvironmentPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    ViewPackageImpl theViewPackage =
        (ViewPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ViewPackage.eNS_URI) instanceof ViewPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ViewPackage.eNS_URI)
                : ViewPackage.eINSTANCE);
    FlowPackageImpl theFlowPackage =
        (FlowPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(FlowPackage.eNS_URI) instanceof FlowPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(FlowPackage.eNS_URI)
                : FlowPackage.eINSTANCE);
    ToolkitsPackageImpl theToolkitsPackage =
        (ToolkitsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ToolkitsPackage.eNS_URI)
                    instanceof ToolkitsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ToolkitsPackage.eNS_URI)
                : ToolkitsPackage.eINSTANCE);

    // Create package meta-data objects
    theCinematicPackage.createPackageContents();
    theViewPackage.createPackageContents();
    theFlowPackage.createPackageContents();
    theToolkitsPackage.createPackageContents();

    // Initialize created meta-data
    theCinematicPackage.initializePackageContents();
    theViewPackage.initializePackageContents();
    theFlowPackage.initializePackageContents();
    theToolkitsPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theCinematicPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(CinematicPackage.eNS_URI, theCinematicPackage);
    return theCinematicPackage;
  }
Exemplo n.º 11
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link MmPackage#eINSTANCE} when that field is accessed.
   * Clients should not invoke it directly. Instead, they should simply access that field to obtain
   * the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static MmPackage init() {
    if (isInited) return (MmPackage) EPackage.Registry.INSTANCE.getEPackage(MmPackage.eNS_URI);

    // Obtain or create and register package
    MmPackageImpl theMmPackage =
        (MmPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof MmPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new MmPackageImpl());

    isInited = true;

    // Obtain or create and register interdependencies
    PictogramsPackageImpl thePictogramsPackage =
        (PictogramsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(PictogramsPackage.eNS_URI)
                    instanceof PictogramsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(PictogramsPackage.eNS_URI)
                : PictogramsPackage.eINSTANCE);
    AlgorithmsPackageImpl theAlgorithmsPackage =
        (AlgorithmsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(AlgorithmsPackage.eNS_URI)
                    instanceof AlgorithmsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(AlgorithmsPackage.eNS_URI)
                : AlgorithmsPackage.eINSTANCE);
    StylesPackageImpl theStylesPackage =
        (StylesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(StylesPackage.eNS_URI)
                    instanceof StylesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(StylesPackage.eNS_URI)
                : StylesPackage.eINSTANCE);

    // Create package meta-data objects
    theMmPackage.createPackageContents();
    thePictogramsPackage.createPackageContents();
    theAlgorithmsPackage.createPackageContents();
    theStylesPackage.createPackageContents();

    // Initialize created meta-data
    theMmPackage.initializePackageContents();
    thePictogramsPackage.initializePackageContents();
    theAlgorithmsPackage.initializePackageContents();
    theStylesPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theMmPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(MmPackage.eNS_URI, theMmPackage);
    return theMmPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link Statechart_1_0Package#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!--
   * begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static Statechart_1_0Package init() {
    if (isInited) {
      return (Statechart_1_0Package)
          EPackage.Registry.INSTANCE.getEPackage(Statechart_1_0Package.eNS_URI);
    }

    // Obtain or create and register package
    Statechart_1_0PackageImpl theStatechart_1_0Package =
        (Statechart_1_0PackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof Statechart_1_0PackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new Statechart_1_0PackageImpl());

    isInited = true;

    // Initialize simple dependencies
    XMLTypePackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    Xadlcore_3_0PackageImpl theXadlcore_3_0Package =
        (Xadlcore_3_0PackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Xadlcore_3_0Package.eNS_URI)
                    instanceof Xadlcore_3_0PackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Xadlcore_3_0Package.eNS_URI)
                : Xadlcore_3_0Package.eINSTANCE);
    XlinkPackageImpl theXlinkPackage =
        (XlinkPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(XlinkPackage.eNS_URI)
                    instanceof XlinkPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(XlinkPackage.eNS_URI)
                : XlinkPackage.eINSTANCE);

    // Create package meta-data objects
    theStatechart_1_0Package.createPackageContents();
    theXadlcore_3_0Package.createPackageContents();
    theXlinkPackage.createPackageContents();

    // Initialize created meta-data
    theStatechart_1_0Package.initializePackageContents();
    theXadlcore_3_0Package.initializePackageContents();
    theXlinkPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theStatechart_1_0Package.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(Statechart_1_0Package.eNS_URI, theStatechart_1_0Package);
    return theStatechart_1_0Package;
  }
Exemplo n.º 13
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link EnvironmentPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static EnvironmentPackage init() {
    if (isInited)
      return (EnvironmentPackage)
          EPackage.Registry.INSTANCE.getEPackage(EnvironmentPackage.eNS_URI);

    // Obtain or create and register package
    EnvironmentPackageImpl theEnvironmentPackage =
        (EnvironmentPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof EnvironmentPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new EnvironmentPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    ConstraintsPackage.eINSTANCE.eClass();
    EcorePackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    ContextsPackageImpl theContextsPackage =
        (ContextsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ContextsPackage.eNS_URI)
                    instanceof ContextsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ContextsPackage.eNS_URI)
                : ContextsPackage.eINSTANCE);
    UiPackageImpl theUiPackage =
        (UiPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(UiPackage.eNS_URI) instanceof UiPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(UiPackage.eNS_URI)
                : UiPackage.eINSTANCE);

    // Create package meta-data objects
    theEnvironmentPackage.createPackageContents();
    theContextsPackage.createPackageContents();
    theUiPackage.createPackageContents();

    // Initialize created meta-data
    theEnvironmentPackage.initializePackageContents();
    theContextsPackage.initializePackageContents();
    theUiPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theEnvironmentPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(EnvironmentPackage.eNS_URI, theEnvironmentPackage);
    return theEnvironmentPackage;
  }
Exemplo n.º 14
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link XtypePackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static XtypePackage init() {
    if (isInited)
      return (XtypePackage) EPackage.Registry.INSTANCE.getEPackage(XtypePackage.eNS_URI);

    // Obtain or create and register package
    XtypePackageImpl theXtypePackage =
        (XtypePackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof XtypePackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new XtypePackageImpl());

    isInited = true;

    // Initialize simple dependencies
    TypesPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    XAnnotationsPackageImpl theXAnnotationsPackage =
        (XAnnotationsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(XAnnotationsPackage.eNS_URI)
                    instanceof XAnnotationsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(XAnnotationsPackage.eNS_URI)
                : XAnnotationsPackage.eINSTANCE);
    XbasePackageImpl theXbasePackage =
        (XbasePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(XbasePackage.eNS_URI)
                    instanceof XbasePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(XbasePackage.eNS_URI)
                : XbasePackage.eINSTANCE);

    // Create package meta-data objects
    theXtypePackage.createPackageContents();
    theXAnnotationsPackage.createPackageContents();
    theXbasePackage.createPackageContents();

    // Initialize created meta-data
    theXtypePackage.initializePackageContents();
    theXAnnotationsPackage.initializePackageContents();
    theXbasePackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theXtypePackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(XtypePackage.eNS_URI, theXtypePackage);
    return theXtypePackage;
  }
Exemplo n.º 15
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link ArgumentationPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static ArgumentationPackage init() {
    if (isInited)
      return (ArgumentationPackage)
          EPackage.Registry.INSTANCE.getEPackage(ArgumentationPackage.eNS_URI);

    // Obtain or create and register package
    ArgumentationPackageImpl theArgumentationPackage =
        (ArgumentationPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ArgumentationPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new ArgumentationPackageImpl());

    isInited = true;

    // Obtain or create and register interdependencies
    SACMPackageImpl theSACMPackage =
        (SACMPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(SACMPackage.eNS_URI) instanceof SACMPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(SACMPackage.eNS_URI)
                : SACMPackage.eINSTANCE);
    EvidencePackageImpl theEvidencePackage =
        (EvidencePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(EvidencePackage.eNS_URI)
                    instanceof EvidencePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(EvidencePackage.eNS_URI)
                : EvidencePackage.eINSTANCE);

    // Create package meta-data objects
    theArgumentationPackage.createPackageContents();
    theSACMPackage.createPackageContents();
    theEvidencePackage.createPackageContents();

    // Initialize created meta-data
    theArgumentationPackage.initializePackageContents();
    theSACMPackage.initializePackageContents();
    theEvidencePackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theArgumentationPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(ArgumentationPackage.eNS_URI, theArgumentationPackage);
    return theArgumentationPackage;
  }
Exemplo n.º 16
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link ModelPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static ModelPackage init() {
    if (isInited) {
      return (ModelPackage) EPackage.Registry.INSTANCE.getEPackage(ModelPackage.eNS_URI);
    }

    // Obtain or create and register package
    final ModelPackageImpl theModelPackage =
        (ModelPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ModelPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new ModelPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    VCategorizationPackage.eINSTANCE.eClass();

    // Create package meta-data objects
    theModelPackage.createPackageContents();

    // Initialize created meta-data
    theModelPackage.initializePackageContents();

    // Register package validator
    EValidator.Registry.INSTANCE.put(
        theModelPackage,
        new EValidator.Descriptor() {
          @Override
          public EValidator getEValidator() {
            return ModelValidator.INSTANCE;
          }
        });

    // Mark meta-data to indicate it can't be changed
    theModelPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(ModelPackage.eNS_URI, theModelPackage);
    return theModelPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link XMLNamespacePackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static XMLNamespacePackage init() {
    if (isInited)
      return (XMLNamespacePackage)
          EPackage.Registry.INSTANCE.getEPackage(XMLNamespacePackage.eNS_URI);

    // Obtain or create and register package
    XMLNamespacePackageImpl theXMLNamespacePackage =
        (XMLNamespacePackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof XMLNamespacePackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new XMLNamespacePackageImpl());

    isInited = true;

    // Initialize simple dependencies
    XMLTypePackage.eINSTANCE.eClass();

    // Create package meta-data objects
    theXMLNamespacePackage.createPackageContents();

    // Initialize created meta-data
    theXMLNamespacePackage.initializePackageContents();

    // Register package validator
    EValidator.Registry.INSTANCE.put(
        theXMLNamespacePackage,
        new EValidator.Descriptor() {
          public EValidator getEValidator() {
            return XMLNamespaceValidator.INSTANCE;
          }
        });

    // Mark meta-data to indicate it can't be changed
    theXMLNamespacePackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(XMLNamespacePackage.eNS_URI, theXMLNamespacePackage);
    return theXMLNamespacePackage;
  }
Exemplo n.º 18
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link SGraphPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @generated
   */
  public static SGraphPackage init() {
    if (isInited)
      return (SGraphPackage) EPackage.Registry.INSTANCE.getEPackage(SGraphPackage.eNS_URI);

    // Obtain or create and register package
    SGraphPackageImpl theSGraphPackage =
        (SGraphPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof SGraphPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new SGraphPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    BasePackage.eINSTANCE.eClass();

    // Load packages
    theSGraphPackage.loadPackage();

    // Fix loaded packages
    theSGraphPackage.fixPackageContents();

    // Register package validator
    EValidator.Registry.INSTANCE.put(
        theSGraphPackage,
        new EValidator.Descriptor() {
          public EValidator getEValidator() {
            return SGraphValidator.INSTANCE;
          }
        });

    // Mark meta-data to indicate it can't be changed
    theSGraphPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(SGraphPackage.eNS_URI, theSGraphPackage);
    return theSGraphPackage;
  }
Exemplo n.º 19
0
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link AutomaticexperimentPackage#eINSTANCE} when that
   * field is accessed. Clients should not invoke it directly. Instead, they should simply access
   * that field to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static AutomaticexperimentPackage init() {
    if (isInited)
      return (AutomaticexperimentPackage)
          EPackage.Registry.INSTANCE.getEPackage(AutomaticexperimentPackage.eNS_URI);

    // Obtain or create and register package
    AutomaticexperimentPackageImpl theAutomaticexperimentPackage =
        (AutomaticexperimentPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof AutomaticexperimentPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new AutomaticexperimentPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    CommonPackage.eINSTANCE.eClass();
    GraphPackage.eINSTANCE.eClass();
    ModelPackage.eINSTANCE.eClass();
    ModifierPackage.eINSTANCE.eClass();
    ScenarioPackage.eINSTANCE.eClass();
    SequencerPackage.eINSTANCE.eClass();
    SolverPackage.eINSTANCE.eClass();

    // Create package meta-data objects
    theAutomaticexperimentPackage.createPackageContents();

    // Initialize created meta-data
    theAutomaticexperimentPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theAutomaticexperimentPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(
        AutomaticexperimentPackage.eNS_URI, theAutomaticexperimentPackage);
    return theAutomaticexperimentPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link InstructionsetPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static InstructionsetPackage init() {
    if (isInited)
      return (InstructionsetPackage)
          EPackage.Registry.INSTANCE.getEPackage(InstructionsetPackage.eNS_URI);

    // Obtain or create and register package
    InstructionsetPackageImpl theInstructionsetPackage =
        (InstructionsetPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof InstructionsetPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new InstructionsetPackageImpl());

    isInited = true;

    // Obtain or create and register interdependencies
    CodePackageImpl theCodePackage =
        (CodePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(CodePackage.eNS_URI) instanceof CodePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(CodePackage.eNS_URI)
                : CodePackage.eINSTANCE);

    // Create package meta-data objects
    theInstructionsetPackage.createPackageContents();
    theCodePackage.createPackageContents();

    // Initialize created meta-data
    theInstructionsetPackage.initializePackageContents();
    theCodePackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theInstructionsetPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(InstructionsetPackage.eNS_URI, theInstructionsetPackage);
    return theInstructionsetPackage;
  }
 private void setElementCombos(int index) {
   if (index == -1) {
     comboInput.removeAll();
     comboOutput.removeAll();
     comboInput.setEnabled(false);
     comboOutput.setEnabled(false);
   } else {
     String mm = comboMM.getItem(index);
     // new
     Object value = EPackage.Registry.INSTANCE.get(mm);
     System.out.println(value);
     metaModel = (EPackage) value;
     setModelElementNames();
     comboInput.setItems(modelElementNames);
     comboInput.setEnabled(true);
     comboOutput.setItems(modelElementNames);
     comboOutput.add("String");
     comboOutput.setEnabled(!isFilter);
   }
 }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link PropertiesPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc
   * -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static PropertiesPackage init() {
    if (isInited)
      return (PropertiesPackage) EPackage.Registry.INSTANCE.getEPackage(PropertiesPackage.eNS_URI);

    // Obtain or create and register package
    PropertiesPackageImpl thePropertiesPackage =
        (PropertiesPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof PropertiesPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new PropertiesPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    org.talend.core.model.properties.PropertiesPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    AnalysisPackageImpl theAnalysisPackage =
        (AnalysisPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(AnalysisPackage.eNS_URI)
                    instanceof AnalysisPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(AnalysisPackage.eNS_URI)
                : AnalysisPackage.eINSTANCE);
    CategoryPackageImpl theCategoryPackage =
        (CategoryPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(CategoryPackage.eNS_URI)
                    instanceof CategoryPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(CategoryPackage.eNS_URI)
                : CategoryPackage.eINSTANCE);
    ReportsPackageImpl theReportsPackage =
        (ReportsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ReportsPackage.eNS_URI)
                    instanceof ReportsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ReportsPackage.eNS_URI)
                : ReportsPackage.eINSTANCE);
    IndicatorsPackageImpl theIndicatorsPackage =
        (IndicatorsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(IndicatorsPackage.eNS_URI)
                    instanceof IndicatorsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(IndicatorsPackage.eNS_URI)
                : IndicatorsPackage.eINSTANCE);
    SchemaPackageImpl theSchemaPackage =
        (SchemaPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(SchemaPackage.eNS_URI)
                    instanceof SchemaPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(SchemaPackage.eNS_URI)
                : SchemaPackage.eINSTANCE);
    DefinitionPackageImpl theDefinitionPackage =
        (DefinitionPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(DefinitionPackage.eNS_URI)
                    instanceof DefinitionPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(DefinitionPackage.eNS_URI)
                : DefinitionPackage.eINSTANCE);
    UserdefinePackageImpl theUserdefinePackage =
        (UserdefinePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(UserdefinePackage.eNS_URI)
                    instanceof UserdefinePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(UserdefinePackage.eNS_URI)
                : UserdefinePackage.eINSTANCE);
    IndicatorSqlPackageImpl theIndicatorSqlPackage =
        (IndicatorSqlPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(IndicatorSqlPackage.eNS_URI)
                    instanceof IndicatorSqlPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(IndicatorSqlPackage.eNS_URI)
                : IndicatorSqlPackage.eINSTANCE);
    ColumnsetPackageImpl theColumnsetPackage =
        (ColumnsetPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ColumnsetPackage.eNS_URI)
                    instanceof ColumnsetPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ColumnsetPackage.eNS_URI)
                : ColumnsetPackage.eINSTANCE);
    ExpressionsPackageImpl theExpressionsPackage =
        (ExpressionsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ExpressionsPackage.eNS_URI)
                    instanceof ExpressionsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ExpressionsPackage.eNS_URI)
                : ExpressionsPackage.eINSTANCE);
    DomainPackageImpl theDomainPackage =
        (DomainPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(DomainPackage.eNS_URI)
                    instanceof DomainPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(DomainPackage.eNS_URI)
                : DomainPackage.eINSTANCE);
    PatternPackageImpl thePatternPackage =
        (PatternPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(PatternPackage.eNS_URI)
                    instanceof PatternPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(PatternPackage.eNS_URI)
                : PatternPackage.eINSTANCE);
    SQLPackageImpl theSQLPackage =
        (SQLPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(SQLPackage.eNS_URI) instanceof SQLPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(SQLPackage.eNS_URI)
                : SQLPackage.eINSTANCE);
    RulesPackageImpl theRulesPackage =
        (RulesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(RulesPackage.eNS_URI)
                    instanceof RulesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(RulesPackage.eNS_URI)
                : RulesPackage.eINSTANCE);

    // Create package meta-data objects
    thePropertiesPackage.createPackageContents();
    theAnalysisPackage.createPackageContents();
    theCategoryPackage.createPackageContents();
    theReportsPackage.createPackageContents();
    theIndicatorsPackage.createPackageContents();
    theSchemaPackage.createPackageContents();
    theDefinitionPackage.createPackageContents();
    theUserdefinePackage.createPackageContents();
    theIndicatorSqlPackage.createPackageContents();
    theColumnsetPackage.createPackageContents();
    theExpressionsPackage.createPackageContents();
    theDomainPackage.createPackageContents();
    thePatternPackage.createPackageContents();
    theSQLPackage.createPackageContents();
    theRulesPackage.createPackageContents();

    // Initialize created meta-data
    thePropertiesPackage.initializePackageContents();
    theAnalysisPackage.initializePackageContents();
    theCategoryPackage.initializePackageContents();
    theReportsPackage.initializePackageContents();
    theIndicatorsPackage.initializePackageContents();
    theSchemaPackage.initializePackageContents();
    theDefinitionPackage.initializePackageContents();
    theUserdefinePackage.initializePackageContents();
    theIndicatorSqlPackage.initializePackageContents();
    theColumnsetPackage.initializePackageContents();
    theExpressionsPackage.initializePackageContents();
    theDomainPackage.initializePackageContents();
    thePatternPackage.initializePackageContents();
    theSQLPackage.initializePackageContents();
    theRulesPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    thePropertiesPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(PropertiesPackage.eNS_URI, thePropertiesPackage);
    return thePropertiesPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link PortandflowsPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static PortandflowsPackage init() {
    if (isInited)
      return (PortandflowsPackage)
          EPackage.Registry.INSTANCE.getEPackage(PortandflowsPackage.eNS_URI);

    // Obtain or create and register package
    PortandflowsPackageImpl thePortandflowsPackage =
        (PortandflowsPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof PortandflowsPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new PortandflowsPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    StandardPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    SysmlPackageImpl theSysmlPackage =
        (SysmlPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(SysmlPackage.eNS_URI)
                    instanceof SysmlPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(SysmlPackage.eNS_URI)
                : SysmlPackage.eINSTANCE);
    ModelelementsPackageImpl theModelelementsPackage =
        (ModelelementsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ModelelementsPackage.eNS_URI)
                    instanceof ModelelementsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ModelelementsPackage.eNS_URI)
                : ModelelementsPackage.eINSTANCE);
    BlocksPackageImpl theBlocksPackage =
        (BlocksPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(BlocksPackage.eNS_URI)
                    instanceof BlocksPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(BlocksPackage.eNS_URI)
                : BlocksPackage.eINSTANCE);
    ConstraintsPackageImpl theConstraintsPackage =
        (ConstraintsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ConstraintsPackage.eNS_URI)
                    instanceof ConstraintsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ConstraintsPackage.eNS_URI)
                : ConstraintsPackage.eINSTANCE);
    ActivitiesPackageImpl theActivitiesPackage =
        (ActivitiesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ActivitiesPackage.eNS_URI)
                    instanceof ActivitiesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ActivitiesPackage.eNS_URI)
                : ActivitiesPackage.eINSTANCE);
    AllocationsPackageImpl theAllocationsPackage =
        (AllocationsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(AllocationsPackage.eNS_URI)
                    instanceof AllocationsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(AllocationsPackage.eNS_URI)
                : AllocationsPackage.eINSTANCE);
    RequirementsPackageImpl theRequirementsPackage =
        (RequirementsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(RequirementsPackage.eNS_URI)
                    instanceof RequirementsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(RequirementsPackage.eNS_URI)
                : RequirementsPackage.eINSTANCE);
    InteractionsPackageImpl theInteractionsPackage =
        (InteractionsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(InteractionsPackage.eNS_URI)
                    instanceof InteractionsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(InteractionsPackage.eNS_URI)
                : InteractionsPackage.eINSTANCE);
    StatemachinesPackageImpl theStatemachinesPackage =
        (StatemachinesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(StatemachinesPackage.eNS_URI)
                    instanceof StatemachinesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(StatemachinesPackage.eNS_URI)
                : StatemachinesPackage.eINSTANCE);
    UsecasesPackageImpl theUsecasesPackage =
        (UsecasesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(UsecasesPackage.eNS_URI)
                    instanceof UsecasesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(UsecasesPackage.eNS_URI)
                : UsecasesPackage.eINSTANCE);

    // Create package meta-data objects
    thePortandflowsPackage.createPackageContents();
    theSysmlPackage.createPackageContents();
    theModelelementsPackage.createPackageContents();
    theBlocksPackage.createPackageContents();
    theConstraintsPackage.createPackageContents();
    theActivitiesPackage.createPackageContents();
    theAllocationsPackage.createPackageContents();
    theRequirementsPackage.createPackageContents();
    theInteractionsPackage.createPackageContents();
    theStatemachinesPackage.createPackageContents();
    theUsecasesPackage.createPackageContents();

    // Initialize created meta-data
    thePortandflowsPackage.initializePackageContents();
    theSysmlPackage.initializePackageContents();
    theModelelementsPackage.initializePackageContents();
    theBlocksPackage.initializePackageContents();
    theConstraintsPackage.initializePackageContents();
    theActivitiesPackage.initializePackageContents();
    theAllocationsPackage.initializePackageContents();
    theRequirementsPackage.initializePackageContents();
    theInteractionsPackage.initializePackageContents();
    theStatemachinesPackage.initializePackageContents();
    theUsecasesPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    thePortandflowsPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(PortandflowsPackage.eNS_URI, thePortandflowsPackage);
    return thePortandflowsPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link ClassPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static ClassPackage init() {
    if (isInited)
      return (ClassPackage) EPackage.Registry.INSTANCE.getEPackage(ClassPackage.eNS_URI);

    // Obtain or create and register package
    ClassPackageImpl theClassPackage =
        (ClassPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ClassPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new ClassPackageImpl());

    isInited = true;

    // Obtain or create and register interdependencies
    PackagePackageImpl thePackagePackage =
        (PackagePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(PackagePackage.eNS_URI)
                    instanceof PackagePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(PackagePackage.eNS_URI)
                : PackagePackage.eINSTANCE);
    BehaviorsPackageImpl theBehaviorsPackage =
        (BehaviorsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(BehaviorsPackage.eNS_URI)
                    instanceof BehaviorsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(BehaviorsPackage.eNS_URI)
                : BehaviorsPackage.eINSTANCE);
    ColumnsPackageImpl theColumnsPackage =
        (ColumnsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ColumnsPackage.eNS_URI)
                    instanceof ColumnsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ColumnsPackage.eNS_URI)
                : ColumnsPackage.eINSTANCE);
    RelationsPackageImpl theRelationsPackage =
        (RelationsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(RelationsPackage.eNS_URI)
                    instanceof RelationsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(RelationsPackage.eNS_URI)
                : RelationsPackage.eINSTANCE);
    OptionsPackageImpl theOptionsPackage =
        (OptionsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(OptionsPackage.eNS_URI)
                    instanceof OptionsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(OptionsPackage.eNS_URI)
                : OptionsPackage.eINSTANCE);
    ListenersPackageImpl theListenersPackage =
        (ListenersPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ListenersPackage.eNS_URI)
                    instanceof ListenersPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ListenersPackage.eNS_URI)
                : ListenersPackage.eINSTANCE);
    IndexesPackageImpl theIndexesPackage =
        (IndexesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(IndexesPackage.eNS_URI)
                    instanceof IndexesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(IndexesPackage.eNS_URI)
                : IndexesPackage.eINSTANCE);
    InheritancePackageImpl theInheritancePackage =
        (InheritancePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(InheritancePackage.eNS_URI)
                    instanceof InheritancePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(InheritancePackage.eNS_URI)
                : InheritancePackage.eINSTANCE);
    ChecksPackageImpl theChecksPackage =
        (ChecksPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ChecksPackage.eNS_URI)
                    instanceof ChecksPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ChecksPackage.eNS_URI)
                : ChecksPackage.eINSTANCE);
    ConnectionPackageImpl theConnectionPackage =
        (ConnectionPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ConnectionPackage.eNS_URI)
                    instanceof ConnectionPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ConnectionPackage.eNS_URI)
                : ConnectionPackage.eINSTANCE);
    CommonPackageImpl theCommonPackage =
        (CommonPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(CommonPackage.eNS_URI)
                    instanceof CommonPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(CommonPackage.eNS_URI)
                : CommonPackage.eINSTANCE);
    SchemePackageImpl theSchemePackage =
        (SchemePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(SchemePackage.eNS_URI)
                    instanceof SchemePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(SchemePackage.eNS_URI)
                : SchemePackage.eINSTANCE);

    // Create package meta-data objects
    theClassPackage.createPackageContents();
    thePackagePackage.createPackageContents();
    theBehaviorsPackage.createPackageContents();
    theColumnsPackage.createPackageContents();
    theRelationsPackage.createPackageContents();
    theOptionsPackage.createPackageContents();
    theListenersPackage.createPackageContents();
    theIndexesPackage.createPackageContents();
    theInheritancePackage.createPackageContents();
    theChecksPackage.createPackageContents();
    theConnectionPackage.createPackageContents();
    theCommonPackage.createPackageContents();
    theSchemePackage.createPackageContents();

    // Initialize created meta-data
    theClassPackage.initializePackageContents();
    thePackagePackage.initializePackageContents();
    theBehaviorsPackage.initializePackageContents();
    theColumnsPackage.initializePackageContents();
    theRelationsPackage.initializePackageContents();
    theOptionsPackage.initializePackageContents();
    theListenersPackage.initializePackageContents();
    theIndexesPackage.initializePackageContents();
    theInheritancePackage.initializePackageContents();
    theChecksPackage.initializePackageContents();
    theConnectionPackage.initializePackageContents();
    theCommonPackage.initializePackageContents();
    theSchemePackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theClassPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(ClassPackage.eNS_URI, theClassPackage);
    return theClassPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link TimingconstraintsPackage#eINSTANCE} when that field
   * is accessed. Clients should not invoke it directly. Instead, they should simply access that
   * field to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static TimingconstraintsPackage init() {
    if (isInited)
      return (TimingconstraintsPackage)
          EPackage.Registry.INSTANCE.getEPackage(TimingconstraintsPackage.eNS_URI);

    // Obtain or create and register package
    TimingconstraintsPackageImpl theTimingconstraintsPackage =
        (TimingconstraintsPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof TimingconstraintsPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new TimingconstraintsPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    SysmlPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    EastadlPackageImpl theEastadlPackage =
        (EastadlPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(EastadlPackage.eNS_URI)
                    instanceof EastadlPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(EastadlPackage.eNS_URI)
                : EastadlPackage.eINSTANCE);
    VariabilityPackageImpl theVariabilityPackage =
        (VariabilityPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(VariabilityPackage.eNS_URI)
                    instanceof VariabilityPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(VariabilityPackage.eNS_URI)
                : VariabilityPackage.eINSTANCE);
    InfrastructurePackageImpl theInfrastructurePackage =
        (InfrastructurePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(InfrastructurePackage.eNS_URI)
                    instanceof InfrastructurePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(InfrastructurePackage.eNS_URI)
                : InfrastructurePackage.eINSTANCE);
    DatatypesPackageImpl theDatatypesPackage =
        (DatatypesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(DatatypesPackage.eNS_URI)
                    instanceof DatatypesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(DatatypesPackage.eNS_URI)
                : DatatypesPackage.eINSTANCE);
    UserattributesPackageImpl theUserattributesPackage =
        (UserattributesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(UserattributesPackage.eNS_URI)
                    instanceof UserattributesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(UserattributesPackage.eNS_URI)
                : UserattributesPackage.eINSTANCE);
    ElementsPackageImpl theElementsPackage =
        (ElementsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ElementsPackage.eNS_URI)
                    instanceof ElementsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ElementsPackage.eNS_URI)
                : ElementsPackage.eINSTANCE);
    StructurePackageImpl theStructurePackage =
        (StructurePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(StructurePackage.eNS_URI)
                    instanceof StructurePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(StructurePackage.eNS_URI)
                : StructurePackage.eINSTANCE);
    FunctionmodelingPackageImpl theFunctionmodelingPackage =
        (FunctionmodelingPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(FunctionmodelingPackage.eNS_URI)
                    instanceof FunctionmodelingPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(FunctionmodelingPackage.eNS_URI)
                : FunctionmodelingPackage.eINSTANCE);
    HardwaremodelingPackageImpl theHardwaremodelingPackage =
        (HardwaremodelingPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(HardwaremodelingPackage.eNS_URI)
                    instanceof HardwaremodelingPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(HardwaremodelingPackage.eNS_URI)
                : HardwaremodelingPackage.eINSTANCE);
    SystemmodelingPackageImpl theSystemmodelingPackage =
        (SystemmodelingPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(SystemmodelingPackage.eNS_URI)
                    instanceof SystemmodelingPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(SystemmodelingPackage.eNS_URI)
                : SystemmodelingPackage.eINSTANCE);
    VehiclefeaturemodelingPackageImpl theVehiclefeaturemodelingPackage =
        (VehiclefeaturemodelingPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(VehiclefeaturemodelingPackage.eNS_URI)
                    instanceof VehiclefeaturemodelingPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(VehiclefeaturemodelingPackage.eNS_URI)
                : VehiclefeaturemodelingPackage.eINSTANCE);
    FeaturemodelingPackageImpl theFeaturemodelingPackage =
        (FeaturemodelingPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(FeaturemodelingPackage.eNS_URI)
                    instanceof FeaturemodelingPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(FeaturemodelingPackage.eNS_URI)
                : FeaturemodelingPackage.eINSTANCE);
    BehaviorPackageImpl theBehaviorPackage =
        (BehaviorPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(BehaviorPackage.eNS_URI)
                    instanceof BehaviorPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(BehaviorPackage.eNS_URI)
                : BehaviorPackage.eINSTANCE);
    RequirementsPackageImpl theRequirementsPackage =
        (RequirementsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(RequirementsPackage.eNS_URI)
                    instanceof RequirementsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(RequirementsPackage.eNS_URI)
                : RequirementsPackage.eINSTANCE);
    VerificationvalidationPackageImpl theVerificationvalidationPackage =
        (VerificationvalidationPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(VerificationvalidationPackage.eNS_URI)
                    instanceof VerificationvalidationPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(VerificationvalidationPackage.eNS_URI)
                : VerificationvalidationPackage.eINSTANCE);
    TimingPackageImpl theTimingPackage =
        (TimingPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(TimingPackage.eNS_URI)
                    instanceof TimingPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(TimingPackage.eNS_URI)
                : TimingPackage.eINSTANCE);
    EventsPackageImpl theEventsPackage =
        (EventsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(EventsPackage.eNS_URI)
                    instanceof EventsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(EventsPackage.eNS_URI)
                : EventsPackage.eINSTANCE);
    InterchangePackageImpl theInterchangePackage =
        (InterchangePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(InterchangePackage.eNS_URI)
                    instanceof InterchangePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(InterchangePackage.eNS_URI)
                : InterchangePackage.eINSTANCE);
    EnvironmentPackageImpl theEnvironmentPackage =
        (EnvironmentPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(EnvironmentPackage.eNS_URI)
                    instanceof EnvironmentPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(EnvironmentPackage.eNS_URI)
                : EnvironmentPackage.eINSTANCE);
    DependabilityPackageImpl theDependabilityPackage =
        (DependabilityPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(DependabilityPackage.eNS_URI)
                    instanceof DependabilityPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(DependabilityPackage.eNS_URI)
                : DependabilityPackage.eINSTANCE);
    ErrormodelPackageImpl theErrormodelPackage =
        (ErrormodelPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ErrormodelPackage.eNS_URI)
                    instanceof ErrormodelPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ErrormodelPackage.eNS_URI)
                : ErrormodelPackage.eINSTANCE);
    SafetyrequirementPackageImpl theSafetyrequirementPackage =
        (SafetyrequirementPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(SafetyrequirementPackage.eNS_URI)
                    instanceof SafetyrequirementPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(SafetyrequirementPackage.eNS_URI)
                : SafetyrequirementPackage.eINSTANCE);
    SafetyconstraintsPackageImpl theSafetyconstraintsPackage =
        (SafetyconstraintsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(SafetyconstraintsPackage.eNS_URI)
                    instanceof SafetyconstraintsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(SafetyconstraintsPackage.eNS_URI)
                : SafetyconstraintsPackage.eINSTANCE);
    SafetycasePackageImpl theSafetycasePackage =
        (SafetycasePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(SafetycasePackage.eNS_URI)
                    instanceof SafetycasePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(SafetycasePackage.eNS_URI)
                : SafetycasePackage.eINSTANCE);
    AnnexPackageImpl theAnnexPackage =
        (AnnexPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(AnnexPackage.eNS_URI)
                    instanceof AnnexPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(AnnexPackage.eNS_URI)
                : AnnexPackage.eINSTANCE);
    NeedsPackageImpl theNeedsPackage =
        (NeedsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(NeedsPackage.eNS_URI)
                    instanceof NeedsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(NeedsPackage.eNS_URI)
                : NeedsPackage.eINSTANCE);
    GenericconstraintsPackageImpl theGenericconstraintsPackage =
        (GenericconstraintsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(GenericconstraintsPackage.eNS_URI)
                    instanceof GenericconstraintsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(GenericconstraintsPackage.eNS_URI)
                : GenericconstraintsPackage.eINSTANCE);

    // Create package meta-data objects
    theTimingconstraintsPackage.createPackageContents();
    theEastadlPackage.createPackageContents();
    theVariabilityPackage.createPackageContents();
    theInfrastructurePackage.createPackageContents();
    theDatatypesPackage.createPackageContents();
    theUserattributesPackage.createPackageContents();
    theElementsPackage.createPackageContents();
    theStructurePackage.createPackageContents();
    theFunctionmodelingPackage.createPackageContents();
    theHardwaremodelingPackage.createPackageContents();
    theSystemmodelingPackage.createPackageContents();
    theVehiclefeaturemodelingPackage.createPackageContents();
    theFeaturemodelingPackage.createPackageContents();
    theBehaviorPackage.createPackageContents();
    theRequirementsPackage.createPackageContents();
    theVerificationvalidationPackage.createPackageContents();
    theTimingPackage.createPackageContents();
    theEventsPackage.createPackageContents();
    theInterchangePackage.createPackageContents();
    theEnvironmentPackage.createPackageContents();
    theDependabilityPackage.createPackageContents();
    theErrormodelPackage.createPackageContents();
    theSafetyrequirementPackage.createPackageContents();
    theSafetyconstraintsPackage.createPackageContents();
    theSafetycasePackage.createPackageContents();
    theAnnexPackage.createPackageContents();
    theNeedsPackage.createPackageContents();
    theGenericconstraintsPackage.createPackageContents();

    // Initialize created meta-data
    theTimingconstraintsPackage.initializePackageContents();
    theEastadlPackage.initializePackageContents();
    theVariabilityPackage.initializePackageContents();
    theInfrastructurePackage.initializePackageContents();
    theDatatypesPackage.initializePackageContents();
    theUserattributesPackage.initializePackageContents();
    theElementsPackage.initializePackageContents();
    theStructurePackage.initializePackageContents();
    theFunctionmodelingPackage.initializePackageContents();
    theHardwaremodelingPackage.initializePackageContents();
    theSystemmodelingPackage.initializePackageContents();
    theVehiclefeaturemodelingPackage.initializePackageContents();
    theFeaturemodelingPackage.initializePackageContents();
    theBehaviorPackage.initializePackageContents();
    theRequirementsPackage.initializePackageContents();
    theVerificationvalidationPackage.initializePackageContents();
    theTimingPackage.initializePackageContents();
    theEventsPackage.initializePackageContents();
    theInterchangePackage.initializePackageContents();
    theEnvironmentPackage.initializePackageContents();
    theDependabilityPackage.initializePackageContents();
    theErrormodelPackage.initializePackageContents();
    theSafetyrequirementPackage.initializePackageContents();
    theSafetyconstraintsPackage.initializePackageContents();
    theSafetycasePackage.initializePackageContents();
    theAnnexPackage.initializePackageContents();
    theNeedsPackage.initializePackageContents();
    theGenericconstraintsPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theTimingconstraintsPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(TimingconstraintsPackage.eNS_URI, theTimingconstraintsPackage);
    return theTimingconstraintsPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link BasicPackageImpl#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static BasicPackageImpl init() {
    if (isInited)
      return (BasicPackageImpl) EPackage.Registry.INSTANCE.getEPackage(BasicPackageImpl.eNS_URI);

    // Obtain or create and register package
    BasicPackageImpl theBasicPackage =
        (BasicPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof BasicPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new BasicPackageImpl());

    isInited = true;

    // Obtain or create and register interdependencies
    ApplicationPackageImpl theApplicationPackage =
        (ApplicationPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ApplicationPackageImpl.eNS_URI)
                    instanceof ApplicationPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ApplicationPackageImpl.eNS_URI)
                : ApplicationPackageImpl.eINSTANCE);
    CommandsPackageImpl theCommandsPackage =
        (CommandsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(CommandsPackageImpl.eNS_URI)
                    instanceof CommandsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(CommandsPackageImpl.eNS_URI)
                : CommandsPackageImpl.eINSTANCE);
    UiPackageImpl theUiPackage =
        (UiPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(UiPackageImpl.eNS_URI) instanceof UiPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(UiPackageImpl.eNS_URI)
                : UiPackageImpl.eINSTANCE);
    MenuPackageImpl theMenuPackage =
        (MenuPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(MenuPackageImpl.eNS_URI)
                    instanceof MenuPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(MenuPackageImpl.eNS_URI)
                : MenuPackageImpl.eINSTANCE);
    org.eclipse.e4.ui.model.application.ui.basic.impl.BasicPackageImpl theBasicPackage_1 =
        (org.eclipse.e4.ui.model.application.ui.basic.impl.BasicPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(
                        org.eclipse.e4.ui.model.application.ui.basic.impl.BasicPackageImpl.eNS_URI)
                    instanceof org.eclipse.e4.ui.model.application.ui.basic.impl.BasicPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(
                    org.eclipse.e4.ui.model.application.ui.basic.impl.BasicPackageImpl.eNS_URI)
                : org.eclipse.e4.ui.model.application.ui.basic.impl.BasicPackageImpl.eINSTANCE);
    AdvancedPackageImpl theAdvancedPackage =
        (AdvancedPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(AdvancedPackageImpl.eNS_URI)
                    instanceof AdvancedPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(AdvancedPackageImpl.eNS_URI)
                : AdvancedPackageImpl.eINSTANCE);

    // Create package meta-data objects
    theBasicPackage.createPackageContents();
    theApplicationPackage.createPackageContents();
    theCommandsPackage.createPackageContents();
    theUiPackage.createPackageContents();
    theMenuPackage.createPackageContents();
    theBasicPackage_1.createPackageContents();
    theAdvancedPackage.createPackageContents();

    // Initialize created meta-data
    theBasicPackage.initializePackageContents();
    theApplicationPackage.initializePackageContents();
    theCommandsPackage.initializePackageContents();
    theUiPackage.initializePackageContents();
    theMenuPackage.initializePackageContents();
    theBasicPackage_1.initializePackageContents();
    theAdvancedPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theBasicPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(BasicPackageImpl.eNS_URI, theBasicPackage);
    return theBasicPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link Core_avPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static Core_avPackage init() {
    if (isInited)
      return (Core_avPackage) EPackage.Registry.INSTANCE.getEPackage(Core_avPackage.eNS_URI);

    // Obtain or create and register package
    Core_avPackageImpl theCore_avPackage =
        (Core_avPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof Core_avPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new Core_avPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    Identifier_avPackage.eINSTANCE.eClass();
    Stoex_avPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    Pcm_avPackageImpl thePcm_avPackage =
        (Pcm_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Pcm_avPackage.eNS_URI)
                    instanceof Pcm_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Pcm_avPackage.eNS_URI)
                : Pcm_avPackage.eINSTANCE);
    Entity_avPackageImpl theEntity_avPackage =
        (Entity_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Entity_avPackage.eNS_URI)
                    instanceof Entity_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Entity_avPackage.eNS_URI)
                : Entity_avPackage.eINSTANCE);
    Composition_avPackageImpl theComposition_avPackage =
        (Composition_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Composition_avPackage.eNS_URI)
                    instanceof Composition_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Composition_avPackage.eNS_URI)
                : Composition_avPackage.eINSTANCE);
    Usagemodel_avPackageImpl theUsagemodel_avPackage =
        (Usagemodel_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Usagemodel_avPackage.eNS_URI)
                    instanceof Usagemodel_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Usagemodel_avPackage.eNS_URI)
                : Usagemodel_avPackage.eINSTANCE);
    Repository_avPackageImpl theRepository_avPackage =
        (Repository_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Repository_avPackage.eNS_URI)
                    instanceof Repository_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Repository_avPackage.eNS_URI)
                : Repository_avPackage.eINSTANCE);
    Resourcetype_avPackageImpl theResourcetype_avPackage =
        (Resourcetype_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Resourcetype_avPackage.eNS_URI)
                    instanceof Resourcetype_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Resourcetype_avPackage.eNS_URI)
                : Resourcetype_avPackage.eINSTANCE);
    Protocol_avPackageImpl theProtocol_avPackage =
        (Protocol_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Protocol_avPackage.eNS_URI)
                    instanceof Protocol_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Protocol_avPackage.eNS_URI)
                : Protocol_avPackage.eINSTANCE);
    Parameter_avPackageImpl theParameter_avPackage =
        (Parameter_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Parameter_avPackage.eNS_URI)
                    instanceof Parameter_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Parameter_avPackage.eNS_URI)
                : Parameter_avPackage.eINSTANCE);
    Reliability_avPackageImpl theReliability_avPackage =
        (Reliability_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Reliability_avPackage.eNS_URI)
                    instanceof Reliability_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Reliability_avPackage.eNS_URI)
                : Reliability_avPackage.eINSTANCE);
    Seff_avPackageImpl theSeff_avPackage =
        (Seff_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Seff_avPackage.eNS_URI)
                    instanceof Seff_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Seff_avPackage.eNS_URI)
                : Seff_avPackage.eINSTANCE);
    Seff_performance_avPackageImpl theSeff_performance_avPackage =
        (Seff_performance_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Seff_performance_avPackage.eNS_URI)
                    instanceof Seff_performance_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Seff_performance_avPackage.eNS_URI)
                : Seff_performance_avPackage.eINSTANCE);
    Seff_reliability_avPackageImpl theSeff_reliability_avPackage =
        (Seff_reliability_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Seff_reliability_avPackage.eNS_URI)
                    instanceof Seff_reliability_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Seff_reliability_avPackage.eNS_URI)
                : Seff_reliability_avPackage.eINSTANCE);
    Qosannotations_avPackageImpl theQosannotations_avPackage =
        (Qosannotations_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Qosannotations_avPackage.eNS_URI)
                    instanceof Qosannotations_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Qosannotations_avPackage.eNS_URI)
                : Qosannotations_avPackage.eINSTANCE);
    Qos_performance_avPackageImpl theQos_performance_avPackage =
        (Qos_performance_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Qos_performance_avPackage.eNS_URI)
                    instanceof Qos_performance_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Qos_performance_avPackage.eNS_URI)
                : Qos_performance_avPackage.eINSTANCE);
    Qos_reliability_avPackageImpl theQos_reliability_avPackage =
        (Qos_reliability_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Qos_reliability_avPackage.eNS_URI)
                    instanceof Qos_reliability_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Qos_reliability_avPackage.eNS_URI)
                : Qos_reliability_avPackage.eINSTANCE);
    System_avPackageImpl theSystem_avPackage =
        (System_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(System_avPackage.eNS_URI)
                    instanceof System_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(System_avPackage.eNS_URI)
                : System_avPackage.eINSTANCE);
    Resourceenvironment_avPackageImpl theResourceenvironment_avPackage =
        (Resourceenvironment_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Resourceenvironment_avPackage.eNS_URI)
                    instanceof Resourceenvironment_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Resourceenvironment_avPackage.eNS_URI)
                : Resourceenvironment_avPackage.eINSTANCE);
    Allocation_avPackageImpl theAllocation_avPackage =
        (Allocation_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Allocation_avPackage.eNS_URI)
                    instanceof Allocation_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Allocation_avPackage.eNS_URI)
                : Allocation_avPackage.eINSTANCE);
    Subsystem_avPackageImpl theSubsystem_avPackage =
        (Subsystem_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Subsystem_avPackage.eNS_URI)
                    instanceof Subsystem_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Subsystem_avPackage.eNS_URI)
                : Subsystem_avPackage.eINSTANCE);
    Completions_avPackageImpl theCompletions_avPackage =
        (Completions_avPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Completions_avPackage.eNS_URI)
                    instanceof Completions_avPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Completions_avPackage.eNS_URI)
                : Completions_avPackage.eINSTANCE);

    // Create package meta-data objects
    theCore_avPackage.createPackageContents();
    thePcm_avPackage.createPackageContents();
    theEntity_avPackage.createPackageContents();
    theComposition_avPackage.createPackageContents();
    theUsagemodel_avPackage.createPackageContents();
    theRepository_avPackage.createPackageContents();
    theResourcetype_avPackage.createPackageContents();
    theProtocol_avPackage.createPackageContents();
    theParameter_avPackage.createPackageContents();
    theReliability_avPackage.createPackageContents();
    theSeff_avPackage.createPackageContents();
    theSeff_performance_avPackage.createPackageContents();
    theSeff_reliability_avPackage.createPackageContents();
    theQosannotations_avPackage.createPackageContents();
    theQos_performance_avPackage.createPackageContents();
    theQos_reliability_avPackage.createPackageContents();
    theSystem_avPackage.createPackageContents();
    theResourceenvironment_avPackage.createPackageContents();
    theAllocation_avPackage.createPackageContents();
    theSubsystem_avPackage.createPackageContents();
    theCompletions_avPackage.createPackageContents();

    // Initialize created meta-data
    theCore_avPackage.initializePackageContents();
    thePcm_avPackage.initializePackageContents();
    theEntity_avPackage.initializePackageContents();
    theComposition_avPackage.initializePackageContents();
    theUsagemodel_avPackage.initializePackageContents();
    theRepository_avPackage.initializePackageContents();
    theResourcetype_avPackage.initializePackageContents();
    theProtocol_avPackage.initializePackageContents();
    theParameter_avPackage.initializePackageContents();
    theReliability_avPackage.initializePackageContents();
    theSeff_avPackage.initializePackageContents();
    theSeff_performance_avPackage.initializePackageContents();
    theSeff_reliability_avPackage.initializePackageContents();
    theQosannotations_avPackage.initializePackageContents();
    theQos_performance_avPackage.initializePackageContents();
    theQos_reliability_avPackage.initializePackageContents();
    theSystem_avPackage.initializePackageContents();
    theResourceenvironment_avPackage.initializePackageContents();
    theAllocation_avPackage.initializePackageContents();
    theSubsystem_avPackage.initializePackageContents();
    theCompletions_avPackage.initializePackageContents();

    // Register package validator
    EValidator.Registry.INSTANCE.put(
        theCore_avPackage,
        new EValidator.Descriptor() {
          public EValidator getEValidator() {
            return Core_avValidator.INSTANCE;
          }
        });

    // Mark meta-data to indicate it can't be changed
    theCore_avPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(Core_avPackage.eNS_URI, theCore_avPackage);
    return theCore_avPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link ComponentsPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static ComponentsPackage init() {
    if (isInited)
      return (ComponentsPackage) EPackage.Registry.INSTANCE.getEPackage(ComponentsPackage.eNS_URI);

    // Obtain or create and register package
    ComponentsPackageImpl theComponentsPackage =
        (ComponentsPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ComponentsPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new ComponentsPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    SysmlPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    Sysml4modelicaPackageImpl theSysml4modelicaPackage =
        (Sysml4modelicaPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Sysml4modelicaPackage.eNS_URI)
                    instanceof Sysml4modelicaPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Sysml4modelicaPackage.eNS_URI)
                : Sysml4modelicaPackage.eINSTANCE);
    ClassesPackageImpl theClassesPackage =
        (ClassesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ClassesPackage.eNS_URI)
                    instanceof ClassesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ClassesPackage.eNS_URI)
                : ClassesPackage.eINSTANCE);
    TypesPackageImpl theTypesPackage =
        (TypesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(TypesPackage.eNS_URI)
                    instanceof TypesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(TypesPackage.eNS_URI)
                : TypesPackage.eINSTANCE);
    EquationsandalgorithmsPackageImpl theEquationsandalgorithmsPackage =
        (EquationsandalgorithmsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(EquationsandalgorithmsPackage.eNS_URI)
                    instanceof EquationsandalgorithmsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(EquationsandalgorithmsPackage.eNS_URI)
                : EquationsandalgorithmsPackage.eINSTANCE);
    OtherPackageImpl theOtherPackage =
        (OtherPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(OtherPackage.eNS_URI)
                    instanceof OtherPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(OtherPackage.eNS_URI)
                : OtherPackage.eINSTANCE);

    // Create package meta-data objects
    theComponentsPackage.createPackageContents();
    theSysml4modelicaPackage.createPackageContents();
    theClassesPackage.createPackageContents();
    theTypesPackage.createPackageContents();
    theEquationsandalgorithmsPackage.createPackageContents();
    theOtherPackage.createPackageContents();

    // Initialize created meta-data
    theComponentsPackage.initializePackageContents();
    theSysml4modelicaPackage.initializePackageContents();
    theClassesPackage.initializePackageContents();
    theTypesPackage.initializePackageContents();
    theEquationsandalgorithmsPackage.initializePackageContents();
    theOtherPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theComponentsPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(ComponentsPackage.eNS_URI, theComponentsPackage);
    return theComponentsPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link ModelingUnitPackage#eINSTANCE} when that field is
   * accessed. Clients should not invoke it directly. Instead, they should simply access that field
   * to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static ModelingUnitPackage init() {
    if (isInited)
      return (ModelingUnitPackage)
          EPackage.Registry.INSTANCE.getEPackage(ModelingUnitPackage.eNS_URI);

    // Obtain or create and register package
    ModelingUnitPackageImpl theModelingUnitPackage =
        (ModelingUnitPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof ModelingUnitPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new ModelingUnitPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    MarkupPackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    GenericUnitPackageImpl theGenericUnitPackage =
        (GenericUnitPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(GenericUnitPackage.eNS_URI)
                    instanceof GenericUnitPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(GenericUnitPackage.eNS_URI)
                : GenericUnitPackage.eINSTANCE);
    IntentDocumentPackageImpl theIntentDocumentPackage =
        (IntentDocumentPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(IntentDocumentPackage.eNS_URI)
                    instanceof IntentDocumentPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(IntentDocumentPackage.eNS_URI)
                : IntentDocumentPackage.eINSTANCE);
    CompilerPackageImpl theCompilerPackage =
        (CompilerPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(CompilerPackage.eNS_URI)
                    instanceof CompilerPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(CompilerPackage.eNS_URI)
                : CompilerPackage.eINSTANCE);
    DescriptionUnitPackageImpl theDescriptionUnitPackage =
        (DescriptionUnitPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(DescriptionUnitPackage.eNS_URI)
                    instanceof DescriptionUnitPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(DescriptionUnitPackage.eNS_URI)
                : DescriptionUnitPackage.eINSTANCE);

    // Create package meta-data objects
    theModelingUnitPackage.createPackageContents();
    theGenericUnitPackage.createPackageContents();
    theIntentDocumentPackage.createPackageContents();
    theCompilerPackage.createPackageContents();
    theDescriptionUnitPackage.createPackageContents();

    // Initialize created meta-data
    theModelingUnitPackage.initializePackageContents();
    theGenericUnitPackage.initializePackageContents();
    theIntentDocumentPackage.initializePackageContents();
    theCompilerPackage.initializePackageContents();
    theDescriptionUnitPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theModelingUnitPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(ModelingUnitPackage.eNS_URI, theModelingUnitPackage);
    return theModelingUnitPackage;
  }
  /**
   * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon
   * which it depends.
   *
   * <p>This method is used to initialize {@link Ap_runtime_constraintsPackage#eINSTANCE} when that
   * field is accessed. Clients should not invoke it directly. Instead, they should simply access
   * that field to obtain the package.
   * <!-- begin-user-doc -->
   * <!-- end-user-doc -->
   *
   * @see #eNS_URI
   * @see #createPackageContents()
   * @see #initializePackageContents()
   * @generated
   */
  public static Ap_runtime_constraintsPackage init() {
    if (isInited)
      return (Ap_runtime_constraintsPackage)
          EPackage.Registry.INSTANCE.getEPackage(Ap_runtime_constraintsPackage.eNS_URI);

    // Obtain or create and register package
    Ap_runtime_constraintsPackageImpl theAp_runtime_constraintsPackage =
        (Ap_runtime_constraintsPackageImpl)
            (EPackage.Registry.INSTANCE.get(eNS_URI) instanceof Ap_runtime_constraintsPackageImpl
                ? EPackage.Registry.INSTANCE.get(eNS_URI)
                : new Ap_runtime_constraintsPackageImpl());

    isInited = true;

    // Initialize simple dependencies
    EcorePackage.eINSTANCE.eClass();

    // Obtain or create and register interdependencies
    AbapmappingPackageImpl theAbapmappingPackage =
        (AbapmappingPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(AbapmappingPackage.eNS_URI)
                    instanceof AbapmappingPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(AbapmappingPackage.eNS_URI)
                : AbapmappingPackage.eINSTANCE);
    AbapdictionaryPackageImpl theAbapdictionaryPackage =
        (AbapdictionaryPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(AbapdictionaryPackage.eNS_URI)
                    instanceof AbapdictionaryPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(AbapdictionaryPackage.eNS_URI)
                : AbapdictionaryPackage.eINSTANCE);
    BpdmPackageImpl theBpdmPackage =
        (BpdmPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(BpdmPackage.eNS_URI) instanceof BpdmPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(BpdmPackage.eNS_URI)
                : BpdmPackage.eINSTANCE);
    BusinesstasksPackageImpl theBusinesstasksPackage =
        (BusinesstasksPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(BusinesstasksPackage.eNS_URI)
                    instanceof BusinesstasksPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(BusinesstasksPackage.eNS_URI)
                : BusinesstasksPackage.eINSTANCE);
    ActionsPackageImpl theActionsPackage =
        (ActionsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ActionsPackage.eNS_URI)
                    instanceof ActionsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ActionsPackage.eNS_URI)
                : ActionsPackage.eINSTANCE);
    RulesPackageImpl theRulesPackage =
        (RulesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(RulesPackage.eNS_URI)
                    instanceof RulesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(RulesPackage.eNS_URI)
                : RulesPackage.eINSTANCE);
    EventsPackageImpl theEventsPackage =
        (EventsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(EventsPackage.eNS_URI)
                    instanceof EventsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(EventsPackage.eNS_URI)
                : EventsPackage.eINSTANCE);
    TransactionsPackageImpl theTransactionsPackage =
        (TransactionsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(TransactionsPackage.eNS_URI)
                    instanceof TransactionsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(TransactionsPackage.eNS_URI)
                : TransactionsPackage.eINSTANCE);
    Status_and_action_oldPackageImpl theStatus_and_action_oldPackage =
        (Status_and_action_oldPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Status_and_action_oldPackage.eNS_URI)
                    instanceof Status_and_action_oldPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Status_and_action_oldPackage.eNS_URI)
                : Status_and_action_oldPackage.eINSTANCE);
    DesignPackageImpl theDesignPackage =
        (DesignPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(DesignPackage.eNS_URI)
                    instanceof DesignPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(DesignPackage.eNS_URI)
                : DesignPackage.eINSTANCE);
    AssemblyPackageImpl theAssemblyPackage =
        (AssemblyPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(AssemblyPackage.eNS_URI)
                    instanceof AssemblyPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(AssemblyPackage.eNS_URI)
                : AssemblyPackage.eINSTANCE);
    BusinessconfigurationPackageImpl theBusinessconfigurationPackage =
        (BusinessconfigurationPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(BusinessconfigurationPackage.eNS_URI)
                    instanceof BusinessconfigurationPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(BusinessconfigurationPackage.eNS_URI)
                : BusinessconfigurationPackage.eINSTANCE);
    ExperimentalPackageImpl theExperimentalPackage =
        (ExperimentalPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ExperimentalPackage.eNS_URI)
                    instanceof ExperimentalPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ExperimentalPackage.eNS_URI)
                : ExperimentalPackage.eINSTANCE);
    Context_driversPackageImpl theContext_driversPackage =
        (Context_driversPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Context_driversPackage.eNS_URI)
                    instanceof Context_driversPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Context_driversPackage.eNS_URI)
                : Context_driversPackage.eINSTANCE);
    ClassesPackageImpl theClassesPackage =
        (ClassesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ClassesPackage.eNS_URI)
                    instanceof ClassesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ClassesPackage.eNS_URI)
                : ClassesPackage.eINSTANCE);
    ConstraintsPackageImpl theConstraintsPackage =
        (ConstraintsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ConstraintsPackage.eNS_URI)
                    instanceof ConstraintsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ConstraintsPackage.eNS_URI)
                : ConstraintsPackage.eINSTANCE);
    QuantitystructurePackageImpl theQuantitystructurePackage =
        (QuantitystructurePackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(QuantitystructurePackage.eNS_URI)
                    instanceof QuantitystructurePackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(QuantitystructurePackage.eNS_URI)
                : QuantitystructurePackage.eINSTANCE);
    TimedependencyPackageImpl theTimedependencyPackage =
        (TimedependencyPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(TimedependencyPackage.eNS_URI)
                    instanceof TimedependencyPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(TimedependencyPackage.eNS_URI)
                : TimedependencyPackage.eINSTANCE);
    DocumentsPackageImpl theDocumentsPackage =
        (DocumentsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(DocumentsPackage.eNS_URI)
                    instanceof DocumentsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(DocumentsPackage.eNS_URI)
                : DocumentsPackage.eINSTANCE);
    GenericsPackageImpl theGenericsPackage =
        (GenericsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(GenericsPackage.eNS_URI)
                    instanceof GenericsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(GenericsPackage.eNS_URI)
                : GenericsPackage.eINSTANCE);
    TuplesPackageImpl theTuplesPackage =
        (TuplesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(TuplesPackage.eNS_URI)
                    instanceof TuplesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(TuplesPackage.eNS_URI)
                : TuplesPackage.eINSTANCE);
    ExpressionsPackageImpl theExpressionsPackage =
        (ExpressionsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ExpressionsPackage.eNS_URI)
                    instanceof ExpressionsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ExpressionsPackage.eNS_URI)
                : ExpressionsPackage.eINSTANCE);
    LiteralsPackageImpl theLiteralsPackage =
        (LiteralsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(LiteralsPackage.eNS_URI)
                    instanceof LiteralsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(LiteralsPackage.eNS_URI)
                : LiteralsPackage.eINSTANCE);
    CollectionexpressionsPackageImpl theCollectionexpressionsPackage =
        (CollectionexpressionsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(CollectionexpressionsPackage.eNS_URI)
                    instanceof CollectionexpressionsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(CollectionexpressionsPackage.eNS_URI)
                : CollectionexpressionsPackage.eINSTANCE);
    FpPackageImpl theFpPackage =
        (FpPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(FpPackage.eNS_URI) instanceof FpPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(FpPackage.eNS_URI)
                : FpPackage.eINSTANCE);
    QueryPackageImpl theQueryPackage =
        (QueryPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(QueryPackage.eNS_URI)
                    instanceof QueryPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(QueryPackage.eNS_URI)
                : QueryPackage.eINSTANCE);
    AnalyticsPackageImpl theAnalyticsPackage =
        (AnalyticsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(AnalyticsPackage.eNS_URI)
                    instanceof AnalyticsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(AnalyticsPackage.eNS_URI)
                : AnalyticsPackage.eINSTANCE);
    ProcessintegrationPackageImpl theProcessintegrationPackage =
        (ProcessintegrationPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ProcessintegrationPackage.eNS_URI)
                    instanceof ProcessintegrationPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ProcessintegrationPackage.eNS_URI)
                : ProcessintegrationPackage.eINSTANCE);
    XsdPackageImpl theXsdPackage =
        (XsdPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(XsdPackage.eNS_URI) instanceof XsdPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(XsdPackage.eNS_URI)
                : XsdPackage.eINSTANCE);
    BindingPackageImpl theBindingPackage =
        (BindingPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(BindingPackage.eNS_URI)
                    instanceof BindingPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(BindingPackage.eNS_URI)
                : BindingPackage.eINSTANCE);
    LocalizationPackageImpl theLocalizationPackage =
        (LocalizationPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(LocalizationPackage.eNS_URI)
                    instanceof LocalizationPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(LocalizationPackage.eNS_URI)
                : LocalizationPackage.eINSTANCE);
    ModelmanagementPackageImpl theModelmanagementPackage =
        (ModelmanagementPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ModelmanagementPackage.eNS_URI)
                    instanceof ModelmanagementPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ModelmanagementPackage.eNS_URI)
                : ModelmanagementPackage.eINSTANCE);
    ProcesscomponentsPackageImpl theProcesscomponentsPackage =
        (ProcesscomponentsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(ProcesscomponentsPackage.eNS_URI)
                    instanceof ProcesscomponentsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(ProcesscomponentsPackage.eNS_URI)
                : ProcesscomponentsPackage.eINSTANCE);
    DeploymentunitsPackageImpl theDeploymentunitsPackage =
        (DeploymentunitsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(DeploymentunitsPackage.eNS_URI)
                    instanceof DeploymentunitsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(DeploymentunitsPackage.eNS_URI)
                : DeploymentunitsPackage.eINSTANCE);
    persistence.actions.impl.ActionsPackageImpl theActionsPackage_1 =
        (persistence.actions.impl.ActionsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(persistence.actions.ActionsPackage.eNS_URI)
                    instanceof persistence.actions.impl.ActionsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(persistence.actions.ActionsPackage.eNS_URI)
                : persistence.actions.ActionsPackage.eINSTANCE);
    persistence.expressions.impl.ExpressionsPackageImpl theExpressionsPackage_1 =
        (persistence.expressions.impl.ExpressionsPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(
                        persistence.expressions.ExpressionsPackage.eNS_URI)
                    instanceof persistence.expressions.impl.ExpressionsPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(
                    persistence.expressions.ExpressionsPackage.eNS_URI)
                : persistence.expressions.ExpressionsPackage.eINSTANCE);
    Data_bindingPackageImpl theData_bindingPackage =
        (Data_bindingPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(Data_bindingPackage.eNS_URI)
                    instanceof Data_bindingPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(Data_bindingPackage.eNS_URI)
                : Data_bindingPackage.eINSTANCE);
    TemplatesPackageImpl theTemplatesPackage =
        (TemplatesPackageImpl)
            (EPackage.Registry.INSTANCE.getEPackage(TemplatesPackage.eNS_URI)
                    instanceof TemplatesPackageImpl
                ? EPackage.Registry.INSTANCE.getEPackage(TemplatesPackage.eNS_URI)
                : TemplatesPackage.eINSTANCE);

    // Create package meta-data objects
    theAp_runtime_constraintsPackage.createPackageContents();
    theAbapmappingPackage.createPackageContents();
    theAbapdictionaryPackage.createPackageContents();
    theBpdmPackage.createPackageContents();
    theBusinesstasksPackage.createPackageContents();
    theActionsPackage.createPackageContents();
    theRulesPackage.createPackageContents();
    theEventsPackage.createPackageContents();
    theTransactionsPackage.createPackageContents();
    theStatus_and_action_oldPackage.createPackageContents();
    theDesignPackage.createPackageContents();
    theAssemblyPackage.createPackageContents();
    theBusinessconfigurationPackage.createPackageContents();
    theExperimentalPackage.createPackageContents();
    theContext_driversPackage.createPackageContents();
    theClassesPackage.createPackageContents();
    theConstraintsPackage.createPackageContents();
    theQuantitystructurePackage.createPackageContents();
    theTimedependencyPackage.createPackageContents();
    theDocumentsPackage.createPackageContents();
    theGenericsPackage.createPackageContents();
    theTuplesPackage.createPackageContents();
    theExpressionsPackage.createPackageContents();
    theLiteralsPackage.createPackageContents();
    theCollectionexpressionsPackage.createPackageContents();
    theFpPackage.createPackageContents();
    theQueryPackage.createPackageContents();
    theAnalyticsPackage.createPackageContents();
    theProcessintegrationPackage.createPackageContents();
    theXsdPackage.createPackageContents();
    theBindingPackage.createPackageContents();
    theLocalizationPackage.createPackageContents();
    theModelmanagementPackage.createPackageContents();
    theProcesscomponentsPackage.createPackageContents();
    theDeploymentunitsPackage.createPackageContents();
    theActionsPackage_1.createPackageContents();
    theExpressionsPackage_1.createPackageContents();
    theData_bindingPackage.createPackageContents();
    theTemplatesPackage.createPackageContents();

    // Initialize created meta-data
    theAp_runtime_constraintsPackage.initializePackageContents();
    theAbapmappingPackage.initializePackageContents();
    theAbapdictionaryPackage.initializePackageContents();
    theBpdmPackage.initializePackageContents();
    theBusinesstasksPackage.initializePackageContents();
    theActionsPackage.initializePackageContents();
    theRulesPackage.initializePackageContents();
    theEventsPackage.initializePackageContents();
    theTransactionsPackage.initializePackageContents();
    theStatus_and_action_oldPackage.initializePackageContents();
    theDesignPackage.initializePackageContents();
    theAssemblyPackage.initializePackageContents();
    theBusinessconfigurationPackage.initializePackageContents();
    theExperimentalPackage.initializePackageContents();
    theContext_driversPackage.initializePackageContents();
    theClassesPackage.initializePackageContents();
    theConstraintsPackage.initializePackageContents();
    theQuantitystructurePackage.initializePackageContents();
    theTimedependencyPackage.initializePackageContents();
    theDocumentsPackage.initializePackageContents();
    theGenericsPackage.initializePackageContents();
    theTuplesPackage.initializePackageContents();
    theExpressionsPackage.initializePackageContents();
    theLiteralsPackage.initializePackageContents();
    theCollectionexpressionsPackage.initializePackageContents();
    theFpPackage.initializePackageContents();
    theQueryPackage.initializePackageContents();
    theAnalyticsPackage.initializePackageContents();
    theProcessintegrationPackage.initializePackageContents();
    theXsdPackage.initializePackageContents();
    theBindingPackage.initializePackageContents();
    theLocalizationPackage.initializePackageContents();
    theModelmanagementPackage.initializePackageContents();
    theProcesscomponentsPackage.initializePackageContents();
    theDeploymentunitsPackage.initializePackageContents();
    theActionsPackage_1.initializePackageContents();
    theExpressionsPackage_1.initializePackageContents();
    theData_bindingPackage.initializePackageContents();
    theTemplatesPackage.initializePackageContents();

    // Mark meta-data to indicate it can't be changed
    theAp_runtime_constraintsPackage.freeze();

    // Update the registry and return the package
    EPackage.Registry.INSTANCE.put(
        Ap_runtime_constraintsPackage.eNS_URI, theAp_runtime_constraintsPackage);
    return theAp_runtime_constraintsPackage;
  }