public static ExpectedExceptionFactoryImpl init() {
    if (isInited)
      return (ExpectedExceptionFactoryImpl)
          FactoryBase.getStaticFactory(ExpectedExceptionFactoryImpl.NAMESPACE_URI);
    ExpectedExceptionFactoryImpl theExpectedExceptionFactoryImpl =
        new ExpectedExceptionFactoryImpl();
    isInited = true;

    // Initialize dependencies
    SDOUtil.registerStaticTypes(SDOFactory.class);
    SDOUtil.registerStaticTypes(ModelFactory.class);
    SDOUtil.registerStaticTypes(InternalFactory.class);

    // Create package meta-data objects
    theExpectedExceptionFactoryImpl.createMetaData();

    // Initialize created meta-data
    theExpectedExceptionFactoryImpl.initializeMetaData();

    // Mark meta-data to indicate it can't be changed
    // theExpectedExceptionFactoryImpl.freeze(); //FB do we need to freeze / should we freeze ????

    return theExpectedExceptionFactoryImpl;
  }
  protected void createXSDMetaData(ModelFactoryImpl theModelPackageImpl) {
    super.initXSD();

    Property property = null;

    property =
        createGlobalProperty(
            "expectedExceptionsElem",
            this.getExpectedExceptionType(),
            new String[] {
              "kind", "element",
              "name", "expectedExceptionsElem",
              "namespace", "##targetNamespace"
            });

    property =
        createGlobalProperty(
            "sequencedReadOnlyElem",
            this.getSequenceReadOnlyType(),
            new String[] {
              "kind", "element",
              "name", "sequencedReadOnlyElem",
              "namespace", "##targetNamespace"
            });

    addXSDMapping(
        expectedExceptionTypeType,
        new String[] {
          "name", "ExpectedExceptionType",
          "kind", "elementOnly"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_STRING_VAL),
        new String[] {
          "kind", "element",
          "name", "stringVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_BOOLEAN_VAL),
        new String[] {
          "kind", "element",
          "name", "booleanVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_BYTE_VAL),
        new String[] {
          "kind", "element",
          "name", "byteVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_DECIMAL_VAL),
        new String[] {
          "kind", "element",
          "name", "decimalVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_INT_VAL),
        new String[] {
          "kind", "element",
          "name", "intVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_FLOAT_VAL),
        new String[] {
          "kind", "element",
          "name", "floatVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_DOUBLE_VAL),
        new String[] {
          "kind", "element",
          "name", "doubleVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_DATE_VAL),
        new String[] {
          "kind", "element",
          "name", "dateVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_SHORT_VAL),
        new String[] {
          "kind", "element",
          "name", "shortVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_LONG_VAL),
        new String[] {
          "kind", "element",
          "name", "longVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_LIST_VAL),
        new String[] {
          "kind", "element",
          "name", "listVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_BYTES_VAL),
        new String[] {
          "kind", "element",
          "name", "bytesVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_INTEGER_VAL),
        new String[] {
          "kind", "element",
          "name", "integerVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_CHAR_VAL),
        new String[] {
          "kind", "element",
          "name", "charVal"
        });

    addXSDMapping(
        getProperty(expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_READ_ONLY_VAL),
        new String[] {
          "kind", "element",
          "name", "readOnlyVal"
        });

    addXSDMapping(
        getProperty(
            expectedExceptionTypeType, ExpectedExceptionTypeImpl.INTERNAL_READ_ONLY_LIST_VAL),
        new String[] {
          "kind", "element",
          "name", "readOnlyListVal"
        });

    addXSDMapping(
        sequenceReadOnlyTypeType,
        new String[] {
          "name", "SequenceReadOnlyType",
          "kind", "mixed"
        });

    addXSDMapping(
        getProperty(sequenceReadOnlyTypeType, SequenceReadOnlyTypeImpl.INTERNAL_MIXED),
        new String[] {
          "kind", "elementWildcard",
          "name", ":mixed"
        });

    addXSDMapping(
        getProperty(sequenceReadOnlyTypeType, SequenceReadOnlyTypeImpl.INTERNAL_READ_ONLY_VAL),
        new String[] {
          "kind", "element",
          "name", "readOnlyVal"
        });

    addXSDMapping(
        getProperty(sequenceReadOnlyTypeType, SequenceReadOnlyTypeImpl.INTERNAL_READ_ONLY_LIST_VAL),
        new String[] {
          "kind", "element",
          "name", "readOnlyListVal"
        });

    addXSDMapping(
        getProperty(sequenceReadOnlyTypeType, SequenceReadOnlyTypeImpl.INTERNAL_UNIQUE_NAME),
        new String[] {
          "kind", "element",
          "name", "uniqueName"
        });

    addXSDMapping(
        char_Type,
        new String[] {
          "name", "char",
          "baseType", "commonj.sdo#String",
          "length", "1"
        });
  }
  public void initializeMetaData() {
    if (isInitialized) return;
    isInitialized = true;

    // Obtain other dependent packages
    ModelFactoryImpl theModelPackageImpl =
        (ModelFactoryImpl) FactoryBase.getStaticFactory(ModelFactoryImpl.NAMESPACE_URI);
    Property property = null;

    // Add supertypes to types

    // Initialize types and properties
    initializeType(
        expectedExceptionTypeType, ExpectedExceptionType.class, "ExpectedExceptionType", false);
    property = getLocalProperty(expectedExceptionTypeType, 0);
    initializeProperty(
        property,
        theModelPackageImpl.getString(),
        "stringVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 1);
    initializeProperty(
        property,
        theModelPackageImpl.getBoolean(),
        "booleanVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 2);
    initializeProperty(
        property,
        theModelPackageImpl.getByte(),
        "byteVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 3);
    initializeProperty(
        property,
        theModelPackageImpl.getDecimal(),
        "decimalVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 4);
    initializeProperty(
        property,
        theModelPackageImpl.getInt(),
        "intVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 5);
    initializeProperty(
        property,
        theModelPackageImpl.getFloat(),
        "floatVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 6);
    initializeProperty(
        property,
        theModelPackageImpl.getDouble(),
        "doubleVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 7);
    initializeProperty(
        property,
        theModelPackageImpl.getDateTime(),
        "dateVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 8);
    initializeProperty(
        property,
        theModelPackageImpl.getShort(),
        "shortVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 9);
    initializeProperty(
        property,
        theModelPackageImpl.getLong(),
        "longVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 10);
    initializeProperty(
        property,
        theModelPackageImpl.getString(),
        "listVal",
        null,
        0,
        -1,
        ExpectedExceptionType.class,
        false,
        false,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 11);
    initializeProperty(
        property,
        theModelPackageImpl.getBytes(),
        "bytesVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 12);
    initializeProperty(
        property,
        theModelPackageImpl.getInteger(),
        "integerVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 13);
    initializeProperty(
        property,
        this.getchar(),
        "charVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        false,
        true,
        false);

    property = getLocalProperty(expectedExceptionTypeType, 14);
    initializeProperty(
        property,
        theModelPackageImpl.getString(),
        "readOnlyVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        true,
        true,
        false);
    setInstanceProperty(property, "commonj.sdo/xml", "readOnly", "true");

    property = getLocalProperty(expectedExceptionTypeType, 15);
    initializeProperty(
        property,
        theModelPackageImpl.getString(),
        "readOnlyListVal",
        null,
        1,
        1,
        ExpectedExceptionType.class,
        true,
        true,
        false);
    setInstanceProperty(property, "commonj.sdo/xml", "readOnly", "true");

    initializeType(
        sequenceReadOnlyTypeType, SequenceReadOnlyType.class, "SequenceReadOnlyType", false);
    property = getLocalProperty(sequenceReadOnlyTypeType, 0);
    initializeProperty(
        property,
        getSequence(),
        "mixed",
        null,
        0,
        -1,
        SequenceReadOnlyType.class,
        false,
        false,
        false);

    property = getLocalProperty(sequenceReadOnlyTypeType, 1);
    initializeProperty(
        property,
        theModelPackageImpl.getString(),
        "readOnlyVal",
        null,
        1,
        1,
        SequenceReadOnlyType.class,
        true,
        true,
        true);
    setInstanceProperty(property, "commonj.sdo/xml", "readOnly", "true");

    property = getLocalProperty(sequenceReadOnlyTypeType, 2);
    initializeProperty(
        property,
        theModelPackageImpl.getString(),
        "readOnlyListVal",
        null,
        1,
        1,
        SequenceReadOnlyType.class,
        true,
        true,
        true);
    setInstanceProperty(property, "commonj.sdo/xml", "readOnly", "true");

    property = getLocalProperty(sequenceReadOnlyTypeType, 3);
    initializeProperty(
        property,
        theModelPackageImpl.getString(),
        "uniqueName",
        null,
        1,
        1,
        SequenceReadOnlyType.class,
        false,
        true,
        true);

    // Initialize data types
    initializeType(char_Type, String.class, "char", true, false);

    createXSDMetaData(theModelPackageImpl);
  }