/**
 * A document containing one Attribute(@http://core.cobielite.cobie.erdc.org) element.
 *
 * <p>This is a complex type.
 */
public class AttributeDocumentImpl extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl
    implements org.erdc.cobie.cobielite.core.AttributeDocument {
  private static final long serialVersionUID = 1L;

  public AttributeDocumentImpl(org.apache.xmlbeans.SchemaType sType) {
    super(sType);
  }

  private static final javax.xml.namespace.QName ATTRIBUTE$0 =
      new javax.xml.namespace.QName("http://core.cobielite.cobie.erdc.org", "Attribute");
  private static final org.apache.xmlbeans.QNameSet ATTRIBUTE$1 =
      org.apache.xmlbeans.QNameSet.forArray(
          new javax.xml.namespace.QName[] {
            new javax.xml.namespace.QName("http://core.cobielite.cobie.erdc.org", "Attribute"),
            new javax.xml.namespace.QName("http://attribute.cobielite.cobie.erdc.org", "Attribute"),
          });

  /** Gets the "Attribute" element */
  public org.erdc.cobie.cobielite.core.AttributeType getAttribute() {
    synchronized (monitor()) {
      check_orphaned();
      org.erdc.cobie.cobielite.core.AttributeType target = null;
      target =
          (org.erdc.cobie.cobielite.core.AttributeType)
              get_store().find_element_user(ATTRIBUTE$1, 0);
      if (target == null) {
        return null;
      }
      return target;
    }
  }

  /** Sets the "Attribute" element */
  public void setAttribute(org.erdc.cobie.cobielite.core.AttributeType attribute) {
    synchronized (monitor()) {
      check_orphaned();
      org.erdc.cobie.cobielite.core.AttributeType target = null;
      target =
          (org.erdc.cobie.cobielite.core.AttributeType)
              get_store().find_element_user(ATTRIBUTE$1, 0);
      if (target == null) {
        target =
            (org.erdc.cobie.cobielite.core.AttributeType) get_store().add_element_user(ATTRIBUTE$0);
      }
      target.set(attribute);
    }
  }

  /** Appends and returns a new empty "Attribute" element */
  public org.erdc.cobie.cobielite.core.AttributeType addNewAttribute() {
    synchronized (monitor()) {
      check_orphaned();
      org.erdc.cobie.cobielite.core.AttributeType target = null;
      target =
          (org.erdc.cobie.cobielite.core.AttributeType) get_store().add_element_user(ATTRIBUTE$0);
      return target;
    }
  }
}
/**
 * A document containing one DataItemStatusAbstract(@ulex:message:structure:1.0) element.
 *
 * <p>This is a complex type.
 */
public class DataItemStatusAbstractDocumentImpl
    extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl
    implements _0._1.structure.message.DataItemStatusAbstractDocument {

  public DataItemStatusAbstractDocumentImpl(org.apache.xmlbeans.SchemaType sType) {
    super(sType);
  }

  private static final javax.xml.namespace.QName DATAITEMSTATUSABSTRACT$0 =
      new javax.xml.namespace.QName("ulex:message:structure:1.0", "DataItemStatusAbstract");
  private static final org.apache.xmlbeans.QNameSet DATAITEMSTATUSABSTRACT$1 =
      org.apache.xmlbeans.QNameSet.forArray(
          new javax.xml.namespace.QName[] {
            new javax.xml.namespace.QName("http://ucore.gov/ucore/2.0", "DataItemStatus"),
            new javax.xml.namespace.QName("ulex:message:structure:1.0", "DataItemStatusAbstract"),
          });

  /** Gets the "DataItemStatusAbstract" element */
  public org.apache.xmlbeans.XmlObject getDataItemStatusAbstract() {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().find_element_user(DATAITEMSTATUSABSTRACT$1, 0);
      if (target == null) {
        return null;
      }
      return target;
    }
  }

  /** Sets the "DataItemStatusAbstract" element */
  public void setDataItemStatusAbstract(org.apache.xmlbeans.XmlObject dataItemStatusAbstract) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().find_element_user(DATAITEMSTATUSABSTRACT$1, 0);
      if (target == null) {
        target =
            (org.apache.xmlbeans.XmlObject) get_store().add_element_user(DATAITEMSTATUSABSTRACT$0);
      }
      target.set(dataItemStatusAbstract);
    }
  }

  /** Appends and returns a new empty "DataItemStatusAbstract" element */
  public org.apache.xmlbeans.XmlObject addNewDataItemStatusAbstract() {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject) get_store().add_element_user(DATAITEMSTATUSABSTRACT$0);
      return target;
    }
  }
}
/**
 * A document containing one
 * single-best-record(@http://configuration.openempi.openhie.org/mpiconfig) element.
 *
 * <p>This is a complex type.
 */
public class SingleBestRecordDocumentImpl
    extends org.apache.xmlbeans.impl.values.XmlComplexContentImpl
    implements org.openhie.openempi.configuration.xml.SingleBestRecordDocument {
  private static final long serialVersionUID = 1L;

  public SingleBestRecordDocumentImpl(org.apache.xmlbeans.SchemaType sType) {
    super(sType);
  }

  private static final javax.xml.namespace.QName SINGLEBESTRECORD$0 =
      new javax.xml.namespace.QName(
          "http://configuration.openempi.openhie.org/mpiconfig", "single-best-record");
  private static final org.apache.xmlbeans.QNameSet SINGLEBESTRECORD$1 =
      org.apache.xmlbeans.QNameSet.forArray(
          new javax.xml.namespace.QName[] {
            new javax.xml.namespace.QName(
                "http://configuration.openempi.openhie.org/mpiconfig", "single-best-record"),
            new javax.xml.namespace.QName(
                "http://configuration.openempi.openhie.org/single-best-record",
                "single-best-record"),
          });

  /** Gets the "single-best-record" element */
  public org.openhie.openempi.configuration.xml.SingleBestRecordType getSingleBestRecord() {
    synchronized (monitor()) {
      check_orphaned();
      org.openhie.openempi.configuration.xml.SingleBestRecordType target = null;
      target =
          (org.openhie.openempi.configuration.xml.SingleBestRecordType)
              get_store().find_element_user(SINGLEBESTRECORD$1, 0);
      if (target == null) {
        return null;
      }
      return target;
    }
  }

  /** Sets the "single-best-record" element */
  public void setSingleBestRecord(
      org.openhie.openempi.configuration.xml.SingleBestRecordType singleBestRecord) {
    synchronized (monitor()) {
      check_orphaned();
      org.openhie.openempi.configuration.xml.SingleBestRecordType target = null;
      target =
          (org.openhie.openempi.configuration.xml.SingleBestRecordType)
              get_store().find_element_user(SINGLEBESTRECORD$1, 0);
      if (target == null) {
        target =
            (org.openhie.openempi.configuration.xml.SingleBestRecordType)
                get_store().add_element_user(SINGLEBESTRECORD$0);
      }
      target.set(singleBestRecord);
    }
  }

  /** Appends and returns a new empty "single-best-record" element */
  public org.openhie.openempi.configuration.xml.SingleBestRecordType addNewSingleBestRecord() {
    synchronized (monitor()) {
      check_orphaned();
      org.openhie.openempi.configuration.xml.SingleBestRecordType target = null;
      target =
          (org.openhie.openempi.configuration.xml.SingleBestRecordType)
              get_store().add_element_user(SINGLEBESTRECORD$0);
      return target;
    }
  }
}
Esempio n. 4
0
  private String parseAnyScalarTypes(XmlObject anyScalarType) {
    if (anyScalarType == null) return null;

    /*
     * select children that are of AnyScalar group
     */
    String sweNS = "http://www.opengis.net/swe/1.0.1";
    QName[] qnArray =
        new QName[] {
          new QName(sweNS, "Count"),
          new QName(sweNS, "Quantity"),
          new QName(sweNS, "Time"),
          new QName(sweNS, "Boolean"),
          new QName(sweNS, "Category"),
          new QName(sweNS, "Text")
        };

    QNameSet qns = QNameSet.forArray(qnArray);
    qnArray = null;
    XmlObject[] anyScalars = anyScalarType.selectChildren(qns);

    /*
     * if found any, parse the results
     */
    if (anyScalars.length == 1) {
      String resultString = null;

      XmlObject as = anyScalars[0];

      UomPropertyType uom = null;
      double doubleValue = Double.NaN;
      String stringValue = null;

      /*
       * AnyNumerical
       */
      if (as instanceof Count) {
        Count count = (Count) as;

        if (count.isSetValue()) {
          doubleValue = Double.parseDouble("" + count.getValue());
        }
      } else if (as instanceof Quantity) {
        Quantity quant = (Quantity) as;

        if (quant.isSetUom()) {
          uom = quant.getUom();
        }

        if (quant.isSetValue()) {
          doubleValue = quant.getValue();
        }
      } else if (as instanceof Time) {
        // TODO parse
        throw new RuntimeException("time parsing not yet implemented in LiteralExpression.java");
      }

      /*
       * Other AnyScalars
       */
      else if (as instanceof net.opengis.swe.x101.BooleanDocument.Boolean) {
        net.opengis.swe.x101.BooleanDocument.Boolean bool =
            (net.opengis.swe.x101.BooleanDocument.Boolean) as;

        if (bool.isSetValue()) {
          stringValue = "" + bool.getValue();
        }
      } else if (as instanceof Category) {
        Category cat = (Category) as;

        if (cat.isSetValue()) {
          stringValue = cat.getValue();
        }
      } else if (as instanceof Text) {
        Text text = (Text) as;

        if (text.isSetValue()) {
          stringValue = text.getValue();
        }
      }

      // convert if a uom was found
      if (uom != null && doubleValue != Double.NaN) {
        try {
          // convert to SI units
          doubleValue = UOMTools.convertToBaseUnit(doubleValue, uom.getCode());

          if (UCUMTools.isCompatible(uom.getCode(), "s")) {
            // XXX This affects also Parsers -> VERY DIRTY as it is NOT transparent.
            // time values shall be represented as milliseconds -> mult by 1000
            doubleValue *= 1000;
          }
        } catch (Exception t) {
          logger.warn(
              "Could not convert uom '"
                  + uom.xmlText(new XmlOptions().setSaveOuter())
                  + "' to base unit, reason: "
                  + t.getMessage());
          if (t instanceof RuntimeException) throw (RuntimeException) t;
          throw new RuntimeException(t);
        }
      }

      if (stringValue != null) {
        resultString = "\"" + stringValue + "\"";
      } else {
        resultString = "" + doubleValue;
      }

      return resultString;
    }
    // else
    return null;
  }
Esempio n. 5
0
/**
 * A document containing one AbstractGML(@http://www.opengis.net/gml/3.2) element.
 *
 * <p>This is a complex type.
 */
public class AbstractGMLDocumentImpl
    extends net.opengis.www.gml._3_2.impl.AbstractObjectDocumentImpl
    implements net.opengis.www.gml._3_2.AbstractGMLDocument {

  public AbstractGMLDocumentImpl(org.apache.xmlbeans.SchemaType sType) {
    super(sType);
  }

  private static final javax.xml.namespace.QName ABSTRACTGML$0 =
      new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "AbstractGML");
  private static final org.apache.xmlbeans.QNameSet ABSTRACTGML$1 =
      org.apache.xmlbeans.QNameSet.forArray(
          new javax.xml.namespace.QName[] {
            new javax.xml.namespace.QName(
                "http://www.opengis.net/gml/3.2", "AbstractGeometricPrimitive"),
            new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "LineString"),
            new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "AbstractSurface"),
            new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "AbstractCurve"),
            new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "Point"),
            new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "AbstractGML"),
            new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "Polygon"),
            new javax.xml.namespace.QName("http://www.opengis.net/gml/3.2", "AbstractGeometry"),
          });

  /** Gets the "AbstractGML" element */
  public net.opengis.www.gml._3_2.AbstractGMLType getAbstractGML() {
    synchronized (monitor()) {
      check_orphaned();
      net.opengis.www.gml._3_2.AbstractGMLType target = null;
      target =
          (net.opengis.www.gml._3_2.AbstractGMLType)
              get_store().find_element_user(ABSTRACTGML$1, 0);
      if (target == null) {
        return null;
      }
      return target;
    }
  }

  /** Sets the "AbstractGML" element */
  public void setAbstractGML(net.opengis.www.gml._3_2.AbstractGMLType abstractGML) {
    synchronized (monitor()) {
      check_orphaned();
      net.opengis.www.gml._3_2.AbstractGMLType target = null;
      target =
          (net.opengis.www.gml._3_2.AbstractGMLType)
              get_store().find_element_user(ABSTRACTGML$1, 0);
      if (target == null) {
        target =
            (net.opengis.www.gml._3_2.AbstractGMLType) get_store().add_element_user(ABSTRACTGML$0);
      }
      target.set(abstractGML);
    }
  }

  /** Appends and returns a new empty "AbstractGML" element */
  public net.opengis.www.gml._3_2.AbstractGMLType addNewAbstractGML() {
    synchronized (monitor()) {
      check_orphaned();
      net.opengis.www.gml._3_2.AbstractGMLType target = null;
      target =
          (net.opengis.www.gml._3_2.AbstractGMLType) get_store().add_element_user(ABSTRACTGML$0);
      return target;
    }
  }
}
Esempio n. 6
0
/**
 * An XML IdentificationType(@http://niem.gov/niem/niem-core/2.0).
 *
 * <p>This is a complex type.
 */
public class IdentificationTypeImpl extends gov.niem.niem.structures._2_0.impl.ComplexObjectTypeImpl
    implements gov.niem.niem.niem_core._2_0.IdentificationType {

  public IdentificationTypeImpl(org.apache.xmlbeans.SchemaType sType) {
    super(sType);
  }

  private static final javax.xml.namespace.QName IDENTIFICATIONID$0 =
      new javax.xml.namespace.QName("http://niem.gov/niem/niem-core/2.0", "IdentificationID");
  private static final javax.xml.namespace.QName IDENTIFICATIONCATEGORY$2 =
      new javax.xml.namespace.QName("http://niem.gov/niem/niem-core/2.0", "IdentificationCategory");
  private static final org.apache.xmlbeans.QNameSet IDENTIFICATIONCATEGORY$3 =
      org.apache.xmlbeans.QNameSet.forArray(
          new javax.xml.namespace.QName[] {
            new javax.xml.namespace.QName(
                "http://niem.gov/niem/niem-core/2.0", "IdentificationCategoryText"),
            new javax.xml.namespace.QName(
                "http://niem.gov/niem/niem-core/2.0", "IdentificationCategory"),
          });
  private static final javax.xml.namespace.QName IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4 =
      new javax.xml.namespace.QName(
          "http://niem.gov/niem/niem-core/2.0", "IdentificationCategoryDescriptionText");
  private static final javax.xml.namespace.QName IDENTIFICATIONEFFECTIVEDATE$6 =
      new javax.xml.namespace.QName(
          "http://niem.gov/niem/niem-core/2.0", "IdentificationEffectiveDate");
  private static final javax.xml.namespace.QName IDENTIFICATIONEXPIRATIONDATE$8 =
      new javax.xml.namespace.QName(
          "http://niem.gov/niem/niem-core/2.0", "IdentificationExpirationDate");
  private static final javax.xml.namespace.QName IDENTIFICATIONJURISDICTION$10 =
      new javax.xml.namespace.QName(
          "http://niem.gov/niem/niem-core/2.0", "IdentificationJurisdiction");
  private static final org.apache.xmlbeans.QNameSet IDENTIFICATIONJURISDICTION$11 =
      org.apache.xmlbeans.QNameSet.forArray(
          new javax.xml.namespace.QName[] {
            new javax.xml.namespace.QName(
                "http://niem.gov/niem/niem-core/2.0", "IdentificationJurisdictionText"),
            new javax.xml.namespace.QName(
                "http://niem.gov/niem/niem-core/2.0", "IdentificationJurisdiction"),
          });

  /** Gets array of all "IdentificationID" elements */
  public gov.niem.niem.proxy.xsd._2_0.String[] getIdentificationIDArray() {
    synchronized (monitor()) {
      check_orphaned();
      java.util.List targetList = new java.util.ArrayList();
      get_store().find_all_element_users(IDENTIFICATIONID$0, targetList);
      gov.niem.niem.proxy.xsd._2_0.String[] result =
          new gov.niem.niem.proxy.xsd._2_0.String[targetList.size()];
      targetList.toArray(result);
      return result;
    }
  }

  /** Gets ith "IdentificationID" element */
  public gov.niem.niem.proxy.xsd._2_0.String getIdentificationIDArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.proxy.xsd._2_0.String target = null;
      target =
          (gov.niem.niem.proxy.xsd._2_0.String)
              get_store().find_element_user(IDENTIFICATIONID$0, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target;
    }
  }

  /** Tests for nil ith "IdentificationID" element */
  public boolean isNilIdentificationIDArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.proxy.xsd._2_0.String target = null;
      target =
          (gov.niem.niem.proxy.xsd._2_0.String)
              get_store().find_element_user(IDENTIFICATIONID$0, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target.isNil();
    }
  }

  /** Returns number of "IdentificationID" element */
  public int sizeOfIdentificationIDArray() {
    synchronized (monitor()) {
      check_orphaned();
      return get_store().count_elements(IDENTIFICATIONID$0);
    }
  }

  /** Sets array of all "IdentificationID" element */
  public void setIdentificationIDArray(
      gov.niem.niem.proxy.xsd._2_0.String[] identificationIDArray) {
    synchronized (monitor()) {
      check_orphaned();
      arraySetterHelper(identificationIDArray, IDENTIFICATIONID$0);
    }
  }

  /** Sets ith "IdentificationID" element */
  public void setIdentificationIDArray(
      int i, gov.niem.niem.proxy.xsd._2_0.String identificationID) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.proxy.xsd._2_0.String target = null;
      target =
          (gov.niem.niem.proxy.xsd._2_0.String)
              get_store().find_element_user(IDENTIFICATIONID$0, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.set(identificationID);
    }
  }

  /** Nils the ith "IdentificationID" element */
  public void setNilIdentificationIDArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.proxy.xsd._2_0.String target = null;
      target =
          (gov.niem.niem.proxy.xsd._2_0.String)
              get_store().find_element_user(IDENTIFICATIONID$0, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.setNil();
    }
  }

  /** Inserts and returns a new empty value (as xml) as the ith "IdentificationID" element */
  public gov.niem.niem.proxy.xsd._2_0.String insertNewIdentificationID(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.proxy.xsd._2_0.String target = null;
      target =
          (gov.niem.niem.proxy.xsd._2_0.String)
              get_store().insert_element_user(IDENTIFICATIONID$0, i);
      return target;
    }
  }

  /** Appends and returns a new empty value (as xml) as the last "IdentificationID" element */
  public gov.niem.niem.proxy.xsd._2_0.String addNewIdentificationID() {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.proxy.xsd._2_0.String target = null;
      target =
          (gov.niem.niem.proxy.xsd._2_0.String) get_store().add_element_user(IDENTIFICATIONID$0);
      return target;
    }
  }

  /** Removes the ith "IdentificationID" element */
  public void removeIdentificationID(int i) {
    synchronized (monitor()) {
      check_orphaned();
      get_store().remove_element(IDENTIFICATIONID$0, i);
    }
  }

  /** Gets array of all "IdentificationCategory" elements */
  public org.apache.xmlbeans.XmlObject[] getIdentificationCategoryArray() {
    synchronized (monitor()) {
      check_orphaned();
      java.util.List targetList = new java.util.ArrayList();
      get_store().find_all_element_users(IDENTIFICATIONCATEGORY$3, targetList);
      org.apache.xmlbeans.XmlObject[] result = new org.apache.xmlbeans.XmlObject[targetList.size()];
      targetList.toArray(result);
      return result;
    }
  }

  /** Gets ith "IdentificationCategory" element */
  public org.apache.xmlbeans.XmlObject getIdentificationCategoryArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().find_element_user(IDENTIFICATIONCATEGORY$3, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target;
    }
  }

  /** Returns number of "IdentificationCategory" element */
  public int sizeOfIdentificationCategoryArray() {
    synchronized (monitor()) {
      check_orphaned();
      return get_store().count_elements(IDENTIFICATIONCATEGORY$3);
    }
  }

  /** Sets array of all "IdentificationCategory" element */
  public void setIdentificationCategoryArray(
      org.apache.xmlbeans.XmlObject[] identificationCategoryArray) {
    synchronized (monitor()) {
      check_orphaned();
      arraySetterHelper(
          identificationCategoryArray, IDENTIFICATIONCATEGORY$2, IDENTIFICATIONCATEGORY$3);
    }
  }

  /** Sets ith "IdentificationCategory" element */
  public void setIdentificationCategoryArray(
      int i, org.apache.xmlbeans.XmlObject identificationCategory) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().find_element_user(IDENTIFICATIONCATEGORY$3, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.set(identificationCategory);
    }
  }

  /** Inserts and returns a new empty value (as xml) as the ith "IdentificationCategory" element */
  public org.apache.xmlbeans.XmlObject insertNewIdentificationCategory(int i) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store()
                  .insert_element_user(IDENTIFICATIONCATEGORY$3, IDENTIFICATIONCATEGORY$2, i);
      return target;
    }
  }

  /** Appends and returns a new empty value (as xml) as the last "IdentificationCategory" element */
  public org.apache.xmlbeans.XmlObject addNewIdentificationCategory() {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject) get_store().add_element_user(IDENTIFICATIONCATEGORY$2);
      return target;
    }
  }

  /** Removes the ith "IdentificationCategory" element */
  public void removeIdentificationCategory(int i) {
    synchronized (monitor()) {
      check_orphaned();
      get_store().remove_element(IDENTIFICATIONCATEGORY$3, i);
    }
  }

  /** Gets array of all "IdentificationCategoryDescriptionText" elements */
  public gov.niem.niem.niem_core._2_0.TextType[] getIdentificationCategoryDescriptionTextArray() {
    synchronized (monitor()) {
      check_orphaned();
      java.util.List targetList = new java.util.ArrayList();
      get_store().find_all_element_users(IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4, targetList);
      gov.niem.niem.niem_core._2_0.TextType[] result =
          new gov.niem.niem.niem_core._2_0.TextType[targetList.size()];
      targetList.toArray(result);
      return result;
    }
  }

  /** Gets ith "IdentificationCategoryDescriptionText" element */
  public gov.niem.niem.niem_core._2_0.TextType getIdentificationCategoryDescriptionTextArray(
      int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.TextType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.TextType)
              get_store().find_element_user(IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target;
    }
  }

  /** Tests for nil ith "IdentificationCategoryDescriptionText" element */
  public boolean isNilIdentificationCategoryDescriptionTextArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.TextType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.TextType)
              get_store().find_element_user(IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target.isNil();
    }
  }

  /** Returns number of "IdentificationCategoryDescriptionText" element */
  public int sizeOfIdentificationCategoryDescriptionTextArray() {
    synchronized (monitor()) {
      check_orphaned();
      return get_store().count_elements(IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4);
    }
  }

  /** Sets array of all "IdentificationCategoryDescriptionText" element */
  public void setIdentificationCategoryDescriptionTextArray(
      gov.niem.niem.niem_core._2_0.TextType[] identificationCategoryDescriptionTextArray) {
    synchronized (monitor()) {
      check_orphaned();
      arraySetterHelper(
          identificationCategoryDescriptionTextArray, IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4);
    }
  }

  /** Sets ith "IdentificationCategoryDescriptionText" element */
  public void setIdentificationCategoryDescriptionTextArray(
      int i, gov.niem.niem.niem_core._2_0.TextType identificationCategoryDescriptionText) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.TextType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.TextType)
              get_store().find_element_user(IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.set(identificationCategoryDescriptionText);
    }
  }

  /** Nils the ith "IdentificationCategoryDescriptionText" element */
  public void setNilIdentificationCategoryDescriptionTextArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.TextType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.TextType)
              get_store().find_element_user(IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.setNil();
    }
  }

  /**
   * Inserts and returns a new empty value (as xml) as the ith
   * "IdentificationCategoryDescriptionText" element
   */
  public gov.niem.niem.niem_core._2_0.TextType insertNewIdentificationCategoryDescriptionText(
      int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.TextType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.TextType)
              get_store().insert_element_user(IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4, i);
      return target;
    }
  }

  /**
   * Appends and returns a new empty value (as xml) as the last
   * "IdentificationCategoryDescriptionText" element
   */
  public gov.niem.niem.niem_core._2_0.TextType addNewIdentificationCategoryDescriptionText() {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.TextType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.TextType)
              get_store().add_element_user(IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4);
      return target;
    }
  }

  /** Removes the ith "IdentificationCategoryDescriptionText" element */
  public void removeIdentificationCategoryDescriptionText(int i) {
    synchronized (monitor()) {
      check_orphaned();
      get_store().remove_element(IDENTIFICATIONCATEGORYDESCRIPTIONTEXT$4, i);
    }
  }

  /** Gets array of all "IdentificationEffectiveDate" elements */
  public gov.niem.niem.niem_core._2_0.DateType[] getIdentificationEffectiveDateArray() {
    synchronized (monitor()) {
      check_orphaned();
      java.util.List targetList = new java.util.ArrayList();
      get_store().find_all_element_users(IDENTIFICATIONEFFECTIVEDATE$6, targetList);
      gov.niem.niem.niem_core._2_0.DateType[] result =
          new gov.niem.niem.niem_core._2_0.DateType[targetList.size()];
      targetList.toArray(result);
      return result;
    }
  }

  /** Gets ith "IdentificationEffectiveDate" element */
  public gov.niem.niem.niem_core._2_0.DateType getIdentificationEffectiveDateArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().find_element_user(IDENTIFICATIONEFFECTIVEDATE$6, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target;
    }
  }

  /** Tests for nil ith "IdentificationEffectiveDate" element */
  public boolean isNilIdentificationEffectiveDateArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().find_element_user(IDENTIFICATIONEFFECTIVEDATE$6, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target.isNil();
    }
  }

  /** Returns number of "IdentificationEffectiveDate" element */
  public int sizeOfIdentificationEffectiveDateArray() {
    synchronized (monitor()) {
      check_orphaned();
      return get_store().count_elements(IDENTIFICATIONEFFECTIVEDATE$6);
    }
  }

  /** Sets array of all "IdentificationEffectiveDate" element */
  public void setIdentificationEffectiveDateArray(
      gov.niem.niem.niem_core._2_0.DateType[] identificationEffectiveDateArray) {
    synchronized (monitor()) {
      check_orphaned();
      arraySetterHelper(identificationEffectiveDateArray, IDENTIFICATIONEFFECTIVEDATE$6);
    }
  }

  /** Sets ith "IdentificationEffectiveDate" element */
  public void setIdentificationEffectiveDateArray(
      int i, gov.niem.niem.niem_core._2_0.DateType identificationEffectiveDate) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().find_element_user(IDENTIFICATIONEFFECTIVEDATE$6, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.set(identificationEffectiveDate);
    }
  }

  /** Nils the ith "IdentificationEffectiveDate" element */
  public void setNilIdentificationEffectiveDateArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().find_element_user(IDENTIFICATIONEFFECTIVEDATE$6, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.setNil();
    }
  }

  /**
   * Inserts and returns a new empty value (as xml) as the ith "IdentificationEffectiveDate" element
   */
  public gov.niem.niem.niem_core._2_0.DateType insertNewIdentificationEffectiveDate(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().insert_element_user(IDENTIFICATIONEFFECTIVEDATE$6, i);
      return target;
    }
  }

  /**
   * Appends and returns a new empty value (as xml) as the last "IdentificationEffectiveDate"
   * element
   */
  public gov.niem.niem.niem_core._2_0.DateType addNewIdentificationEffectiveDate() {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().add_element_user(IDENTIFICATIONEFFECTIVEDATE$6);
      return target;
    }
  }

  /** Removes the ith "IdentificationEffectiveDate" element */
  public void removeIdentificationEffectiveDate(int i) {
    synchronized (monitor()) {
      check_orphaned();
      get_store().remove_element(IDENTIFICATIONEFFECTIVEDATE$6, i);
    }
  }

  /** Gets array of all "IdentificationExpirationDate" elements */
  public gov.niem.niem.niem_core._2_0.DateType[] getIdentificationExpirationDateArray() {
    synchronized (monitor()) {
      check_orphaned();
      java.util.List targetList = new java.util.ArrayList();
      get_store().find_all_element_users(IDENTIFICATIONEXPIRATIONDATE$8, targetList);
      gov.niem.niem.niem_core._2_0.DateType[] result =
          new gov.niem.niem.niem_core._2_0.DateType[targetList.size()];
      targetList.toArray(result);
      return result;
    }
  }

  /** Gets ith "IdentificationExpirationDate" element */
  public gov.niem.niem.niem_core._2_0.DateType getIdentificationExpirationDateArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().find_element_user(IDENTIFICATIONEXPIRATIONDATE$8, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target;
    }
  }

  /** Tests for nil ith "IdentificationExpirationDate" element */
  public boolean isNilIdentificationExpirationDateArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().find_element_user(IDENTIFICATIONEXPIRATIONDATE$8, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target.isNil();
    }
  }

  /** Returns number of "IdentificationExpirationDate" element */
  public int sizeOfIdentificationExpirationDateArray() {
    synchronized (monitor()) {
      check_orphaned();
      return get_store().count_elements(IDENTIFICATIONEXPIRATIONDATE$8);
    }
  }

  /** Sets array of all "IdentificationExpirationDate" element */
  public void setIdentificationExpirationDateArray(
      gov.niem.niem.niem_core._2_0.DateType[] identificationExpirationDateArray) {
    synchronized (monitor()) {
      check_orphaned();
      arraySetterHelper(identificationExpirationDateArray, IDENTIFICATIONEXPIRATIONDATE$8);
    }
  }

  /** Sets ith "IdentificationExpirationDate" element */
  public void setIdentificationExpirationDateArray(
      int i, gov.niem.niem.niem_core._2_0.DateType identificationExpirationDate) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().find_element_user(IDENTIFICATIONEXPIRATIONDATE$8, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.set(identificationExpirationDate);
    }
  }

  /** Nils the ith "IdentificationExpirationDate" element */
  public void setNilIdentificationExpirationDateArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().find_element_user(IDENTIFICATIONEXPIRATIONDATE$8, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.setNil();
    }
  }

  /**
   * Inserts and returns a new empty value (as xml) as the ith "IdentificationExpirationDate"
   * element
   */
  public gov.niem.niem.niem_core._2_0.DateType insertNewIdentificationExpirationDate(int i) {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().insert_element_user(IDENTIFICATIONEXPIRATIONDATE$8, i);
      return target;
    }
  }

  /**
   * Appends and returns a new empty value (as xml) as the last "IdentificationExpirationDate"
   * element
   */
  public gov.niem.niem.niem_core._2_0.DateType addNewIdentificationExpirationDate() {
    synchronized (monitor()) {
      check_orphaned();
      gov.niem.niem.niem_core._2_0.DateType target = null;
      target =
          (gov.niem.niem.niem_core._2_0.DateType)
              get_store().add_element_user(IDENTIFICATIONEXPIRATIONDATE$8);
      return target;
    }
  }

  /** Removes the ith "IdentificationExpirationDate" element */
  public void removeIdentificationExpirationDate(int i) {
    synchronized (monitor()) {
      check_orphaned();
      get_store().remove_element(IDENTIFICATIONEXPIRATIONDATE$8, i);
    }
  }

  /** Gets array of all "IdentificationJurisdiction" elements */
  public org.apache.xmlbeans.XmlObject[] getIdentificationJurisdictionArray() {
    synchronized (monitor()) {
      check_orphaned();
      java.util.List targetList = new java.util.ArrayList();
      get_store().find_all_element_users(IDENTIFICATIONJURISDICTION$11, targetList);
      org.apache.xmlbeans.XmlObject[] result = new org.apache.xmlbeans.XmlObject[targetList.size()];
      targetList.toArray(result);
      return result;
    }
  }

  /** Gets ith "IdentificationJurisdiction" element */
  public org.apache.xmlbeans.XmlObject getIdentificationJurisdictionArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().find_element_user(IDENTIFICATIONJURISDICTION$11, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target;
    }
  }

  /** Returns number of "IdentificationJurisdiction" element */
  public int sizeOfIdentificationJurisdictionArray() {
    synchronized (monitor()) {
      check_orphaned();
      return get_store().count_elements(IDENTIFICATIONJURISDICTION$11);
    }
  }

  /** Sets array of all "IdentificationJurisdiction" element */
  public void setIdentificationJurisdictionArray(
      org.apache.xmlbeans.XmlObject[] identificationJurisdictionArray) {
    synchronized (monitor()) {
      check_orphaned();
      arraySetterHelper(
          identificationJurisdictionArray,
          IDENTIFICATIONJURISDICTION$10,
          IDENTIFICATIONJURISDICTION$11);
    }
  }

  /** Sets ith "IdentificationJurisdiction" element */
  public void setIdentificationJurisdictionArray(
      int i, org.apache.xmlbeans.XmlObject identificationJurisdiction) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().find_element_user(IDENTIFICATIONJURISDICTION$11, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.set(identificationJurisdiction);
    }
  }

  /**
   * Inserts and returns a new empty value (as xml) as the ith "IdentificationJurisdiction" element
   */
  public org.apache.xmlbeans.XmlObject insertNewIdentificationJurisdiction(int i) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store()
                  .insert_element_user(
                      IDENTIFICATIONJURISDICTION$11, IDENTIFICATIONJURISDICTION$10, i);
      return target;
    }
  }

  /**
   * Appends and returns a new empty value (as xml) as the last "IdentificationJurisdiction" element
   */
  public org.apache.xmlbeans.XmlObject addNewIdentificationJurisdiction() {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().add_element_user(IDENTIFICATIONJURISDICTION$10);
      return target;
    }
  }

  /** Removes the ith "IdentificationJurisdiction" element */
  public void removeIdentificationJurisdiction(int i) {
    synchronized (monitor()) {
      check_orphaned();
      get_store().remove_element(IDENTIFICATIONJURISDICTION$11, i);
    }
  }
}
/**
 * An XML PDMessageMetadataType(@ulex:message:structure:1.0).
 *
 * <p>This is a complex type.
 */
public class PDMessageMetadataTypeImpl
    extends _0._1.structure.message.impl.MessageMetadataAbstractTypeImpl
    implements _0._1.structure.message.PDMessageMetadataType {

  public PDMessageMetadataTypeImpl(org.apache.xmlbeans.SchemaType sType) {
    super(sType);
  }

  private static final javax.xml.namespace.QName PDMESSAGEMETADATAEXTENSIONABSTRACT$0 =
      new javax.xml.namespace.QName(
          "ulex:message:structure:1.0", "PDMessageMetadataExtensionAbstract");
  private static final org.apache.xmlbeans.QNameSet PDMESSAGEMETADATAEXTENSIONABSTRACT$1 =
      org.apache.xmlbeans.QNameSet.forArray(
          new javax.xml.namespace.QName[] {
            new javax.xml.namespace.QName(
                "ulex:message:structure:1.0", "PDMessageMetadataDomainAttribute"),
            new javax.xml.namespace.QName(
                "ulex:message:structure:1.0", "PDMessageMetadataExtensionAbstract"),
          });

  /** Gets array of all "PDMessageMetadataExtensionAbstract" elements */
  public org.apache.xmlbeans.XmlObject[] getPDMessageMetadataExtensionAbstractArray() {
    synchronized (monitor()) {
      check_orphaned();
      java.util.List targetList = new java.util.ArrayList();
      get_store().find_all_element_users(PDMESSAGEMETADATAEXTENSIONABSTRACT$1, targetList);
      org.apache.xmlbeans.XmlObject[] result = new org.apache.xmlbeans.XmlObject[targetList.size()];
      targetList.toArray(result);
      return result;
    }
  }

  /** Gets ith "PDMessageMetadataExtensionAbstract" element */
  public org.apache.xmlbeans.XmlObject getPDMessageMetadataExtensionAbstractArray(int i) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().find_element_user(PDMESSAGEMETADATAEXTENSIONABSTRACT$1, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      return target;
    }
  }

  /** Returns number of "PDMessageMetadataExtensionAbstract" element */
  public int sizeOfPDMessageMetadataExtensionAbstractArray() {
    synchronized (monitor()) {
      check_orphaned();
      return get_store().count_elements(PDMESSAGEMETADATAEXTENSIONABSTRACT$1);
    }
  }

  /** Sets array of all "PDMessageMetadataExtensionAbstract" element */
  public void setPDMessageMetadataExtensionAbstractArray(
      org.apache.xmlbeans.XmlObject[] pdMessageMetadataExtensionAbstractArray) {
    synchronized (monitor()) {
      check_orphaned();
      arraySetterHelper(
          pdMessageMetadataExtensionAbstractArray,
          PDMESSAGEMETADATAEXTENSIONABSTRACT$0,
          PDMESSAGEMETADATAEXTENSIONABSTRACT$1);
    }
  }

  /** Sets ith "PDMessageMetadataExtensionAbstract" element */
  public void setPDMessageMetadataExtensionAbstractArray(
      int i, org.apache.xmlbeans.XmlObject pdMessageMetadataExtensionAbstract) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().find_element_user(PDMESSAGEMETADATAEXTENSIONABSTRACT$1, i);
      if (target == null) {
        throw new IndexOutOfBoundsException();
      }
      target.set(pdMessageMetadataExtensionAbstract);
    }
  }

  /**
   * Inserts and returns a new empty value (as xml) as the ith "PDMessageMetadataExtensionAbstract"
   * element
   */
  public org.apache.xmlbeans.XmlObject insertNewPDMessageMetadataExtensionAbstract(int i) {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store()
                  .insert_element_user(
                      PDMESSAGEMETADATAEXTENSIONABSTRACT$1,
                      PDMESSAGEMETADATAEXTENSIONABSTRACT$0,
                      i);
      return target;
    }
  }

  /**
   * Appends and returns a new empty value (as xml) as the last "PDMessageMetadataExtensionAbstract"
   * element
   */
  public org.apache.xmlbeans.XmlObject addNewPDMessageMetadataExtensionAbstract() {
    synchronized (monitor()) {
      check_orphaned();
      org.apache.xmlbeans.XmlObject target = null;
      target =
          (org.apache.xmlbeans.XmlObject)
              get_store().add_element_user(PDMESSAGEMETADATAEXTENSIONABSTRACT$0);
      return target;
    }
  }

  /** Removes the ith "PDMessageMetadataExtensionAbstract" element */
  public void removePDMessageMetadataExtensionAbstract(int i) {
    synchronized (monitor()) {
      check_orphaned();
      get_store().remove_element(PDMESSAGEMETADATAEXTENSIONABSTRACT$1, i);
    }
  }
}