// Copyright (C) 2005-2010 Code Synthesis Tools CC
//
// This program was generated by CodeSynthesis XSD, an XML Schema to
// C++ data binding compiler.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// In addition, as a special exception, Code Synthesis Tools CC gives
// permission to link this program with the Xerces-C++ library (or with
// modified versions of Xerces-C++ that use the same license as Xerces-C++),
// and distribute linked combinations including the two. You must obey
// the GNU General Public License version 2 in all respects for all of
// the code used other than Xerces-C++. If you modify this copy of the
// program, you may extend this exception to your version of the program,
// but you are not obligated to do so. If you do not wish to do so, delete
// this exception statement from your version.
//
// Furthermore, Code Synthesis Tools CC makes a special exception for
// the Free/Libre and Open Source Software (FLOSS) which is described
// in the accompanying FLOSSE file.
//

// Begin prologue.
//
//
// End prologue.

#include <xsd/cxx/pre.hxx>

#include "EDXL-DE.hxx"

namespace edxl
{
  namespace de
  {
    // contentObjectType
    // 

    const contentObjectType::contentDescription_optional& contentObjectType::
    contentDescription () const
    {
      return this->contentDescription_;
    }

    contentObjectType::contentDescription_optional& contentObjectType::
    contentDescription ()
    {
      return this->contentDescription_;
    }

    void contentObjectType::
    contentDescription (const contentDescription_type& x)
    {
      this->contentDescription_.set (x);
    }

    void contentObjectType::
    contentDescription (const contentDescription_optional& x)
    {
      this->contentDescription_ = x;
    }

    void contentObjectType::
    contentDescription (::std::auto_ptr< contentDescription_type > x)
    {
      this->contentDescription_.set (x);
    }

    const contentObjectType::contentKeyword_sequence& contentObjectType::
    contentKeyword () const
    {
      return this->contentKeyword_;
    }

    contentObjectType::contentKeyword_sequence& contentObjectType::
    contentKeyword ()
    {
      return this->contentKeyword_;
    }

    void contentObjectType::
    contentKeyword (const contentKeyword_sequence& s)
    {
      this->contentKeyword_ = s;
    }

    const contentObjectType::incidentID_optional& contentObjectType::
    incidentID () const
    {
      return this->incidentID_;
    }

    contentObjectType::incidentID_optional& contentObjectType::
    incidentID ()
    {
      return this->incidentID_;
    }

    void contentObjectType::
    incidentID (const incidentID_type& x)
    {
      this->incidentID_.set (x);
    }

    void contentObjectType::
    incidentID (const incidentID_optional& x)
    {
      this->incidentID_ = x;
    }

    void contentObjectType::
    incidentID (::std::auto_ptr< incidentID_type > x)
    {
      this->incidentID_.set (x);
    }

    const contentObjectType::incidentDescription_optional& contentObjectType::
    incidentDescription () const
    {
      return this->incidentDescription_;
    }

    contentObjectType::incidentDescription_optional& contentObjectType::
    incidentDescription ()
    {
      return this->incidentDescription_;
    }

    void contentObjectType::
    incidentDescription (const incidentDescription_type& x)
    {
      this->incidentDescription_.set (x);
    }

    void contentObjectType::
    incidentDescription (const incidentDescription_optional& x)
    {
      this->incidentDescription_ = x;
    }

    void contentObjectType::
    incidentDescription (::std::auto_ptr< incidentDescription_type > x)
    {
      this->incidentDescription_.set (x);
    }

    const contentObjectType::originatorRole_sequence& contentObjectType::
    originatorRole () const
    {
      return this->originatorRole_;
    }

    contentObjectType::originatorRole_sequence& contentObjectType::
    originatorRole ()
    {
      return this->originatorRole_;
    }

    void contentObjectType::
    originatorRole (const originatorRole_sequence& s)
    {
      this->originatorRole_ = s;
    }

    const contentObjectType::consumerRole_sequence& contentObjectType::
    consumerRole () const
    {
      return this->consumerRole_;
    }

    contentObjectType::consumerRole_sequence& contentObjectType::
    consumerRole ()
    {
      return this->consumerRole_;
    }

    void contentObjectType::
    consumerRole (const consumerRole_sequence& s)
    {
      this->consumerRole_ = s;
    }

    const contentObjectType::confidentiality_optional& contentObjectType::
    confidentiality () const
    {
      return this->confidentiality_;
    }

    contentObjectType::confidentiality_optional& contentObjectType::
    confidentiality ()
    {
      return this->confidentiality_;
    }

    void contentObjectType::
    confidentiality (const confidentiality_type& x)
    {
      this->confidentiality_.set (x);
    }

    void contentObjectType::
    confidentiality (const confidentiality_optional& x)
    {
      this->confidentiality_ = x;
    }

    void contentObjectType::
    confidentiality (::std::auto_ptr< confidentiality_type > x)
    {
      this->confidentiality_.set (x);
    }

    const contentObjectType::nonXMLContent_optional& contentObjectType::
    nonXMLContent () const
    {
      return this->nonXMLContent_;
    }

    contentObjectType::nonXMLContent_optional& contentObjectType::
    nonXMLContent ()
    {
      return this->nonXMLContent_;
    }

    void contentObjectType::
    nonXMLContent (const nonXMLContent_type& x)
    {
      this->nonXMLContent_.set (x);
    }

    void contentObjectType::
    nonXMLContent (const nonXMLContent_optional& x)
    {
      this->nonXMLContent_ = x;
    }

    void contentObjectType::
    nonXMLContent (::std::auto_ptr< nonXMLContent_type > x)
    {
      this->nonXMLContent_.set (x);
    }

    const contentObjectType::xmlContent_optional& contentObjectType::
    xmlContent () const
    {
      return this->xmlContent_;
    }

    contentObjectType::xmlContent_optional& contentObjectType::
    xmlContent ()
    {
      return this->xmlContent_;
    }

    void contentObjectType::
    xmlContent (const xmlContent_type& x)
    {
      this->xmlContent_.set (x);
    }

    void contentObjectType::
    xmlContent (const xmlContent_optional& x)
    {
      this->xmlContent_ = x;
    }

    void contentObjectType::
    xmlContent (::std::auto_ptr< xmlContent_type > x)
    {
      this->xmlContent_.set (x);
    }


    // nonXMLContentType
    // 

    const nonXMLContentType::mimeType_type& nonXMLContentType::
    mimeType () const
    {
      return this->mimeType_.get ();
    }

    nonXMLContentType::mimeType_type& nonXMLContentType::
    mimeType ()
    {
      return this->mimeType_.get ();
    }

    void nonXMLContentType::
    mimeType (const mimeType_type& x)
    {
      this->mimeType_.set (x);
    }

    void nonXMLContentType::
    mimeType (::std::auto_ptr< mimeType_type > x)
    {
      this->mimeType_.set (x);
    }

    const nonXMLContentType::size_optional& nonXMLContentType::
    size () const
    {
      return this->size_;
    }

    nonXMLContentType::size_optional& nonXMLContentType::
    size ()
    {
      return this->size_;
    }

    void nonXMLContentType::
    size (const size_type& x)
    {
      this->size_.set (x);
    }

    void nonXMLContentType::
    size (const size_optional& x)
    {
      this->size_ = x;
    }

    const nonXMLContentType::digest_optional& nonXMLContentType::
    digest () const
    {
      return this->digest_;
    }

    nonXMLContentType::digest_optional& nonXMLContentType::
    digest ()
    {
      return this->digest_;
    }

    void nonXMLContentType::
    digest (const digest_type& x)
    {
      this->digest_.set (x);
    }

    void nonXMLContentType::
    digest (const digest_optional& x)
    {
      this->digest_ = x;
    }

    void nonXMLContentType::
    digest (::std::auto_ptr< digest_type > x)
    {
      this->digest_.set (x);
    }

    const nonXMLContentType::uri_optional& nonXMLContentType::
    uri () const
    {
      return this->uri_;
    }

    nonXMLContentType::uri_optional& nonXMLContentType::
    uri ()
    {
      return this->uri_;
    }

    void nonXMLContentType::
    uri (const uri_type& x)
    {
      this->uri_.set (x);
    }

    void nonXMLContentType::
    uri (const uri_optional& x)
    {
      this->uri_ = x;
    }

    void nonXMLContentType::
    uri (::std::auto_ptr< uri_type > x)
    {
      this->uri_.set (x);
    }

    const nonXMLContentType::contentData_optional& nonXMLContentType::
    contentData () const
    {
      return this->contentData_;
    }

    nonXMLContentType::contentData_optional& nonXMLContentType::
    contentData ()
    {
      return this->contentData_;
    }

    void nonXMLContentType::
    contentData (const contentData_type& x)
    {
      this->contentData_.set (x);
    }

    void nonXMLContentType::
    contentData (const contentData_optional& x)
    {
      this->contentData_ = x;
    }

    void nonXMLContentType::
    contentData (::std::auto_ptr< contentData_type > x)
    {
      this->contentData_.set (x);
    }


    // xmlContentType
    // 

    const xmlContentType::keyXMLContent_sequence& xmlContentType::
    keyXMLContent () const
    {
      return this->keyXMLContent_;
    }

    xmlContentType::keyXMLContent_sequence& xmlContentType::
    keyXMLContent ()
    {
      return this->keyXMLContent_;
    }

    void xmlContentType::
    keyXMLContent (const keyXMLContent_sequence& s)
    {
      this->keyXMLContent_ = s;
    }

    const xmlContentType::embeddedXMLContent_sequence& xmlContentType::
    embeddedXMLContent () const
    {
      return this->embeddedXMLContent_;
    }

    xmlContentType::embeddedXMLContent_sequence& xmlContentType::
    embeddedXMLContent ()
    {
      return this->embeddedXMLContent_;
    }

    void xmlContentType::
    embeddedXMLContent (const embeddedXMLContent_sequence& s)
    {
      this->embeddedXMLContent_ = s;
    }


    // anyXMLType
    // 


    // valueListType
    // 

    const valueListType::valueListUrn_type& valueListType::
    valueListUrn () const
    {
      return this->valueListUrn_.get ();
    }

    valueListType::valueListUrn_type& valueListType::
    valueListUrn ()
    {
      return this->valueListUrn_.get ();
    }

    void valueListType::
    valueListUrn (const valueListUrn_type& x)
    {
      this->valueListUrn_.set (x);
    }

    void valueListType::
    valueListUrn (::std::auto_ptr< valueListUrn_type > x)
    {
      this->valueListUrn_.set (x);
    }

    const valueListType::value_sequence& valueListType::
    value () const
    {
      return this->value_;
    }

    valueListType::value_sequence& valueListType::
    value ()
    {
      return this->value_;
    }

    void valueListType::
    value (const value_sequence& s)
    {
      this->value_ = s;
    }


    // valueSchemeType
    // 

    const valueSchemeType::explicitAddressScheme_type& valueSchemeType::
    explicitAddressScheme () const
    {
      return this->explicitAddressScheme_.get ();
    }

    valueSchemeType::explicitAddressScheme_type& valueSchemeType::
    explicitAddressScheme ()
    {
      return this->explicitAddressScheme_.get ();
    }

    void valueSchemeType::
    explicitAddressScheme (const explicitAddressScheme_type& x)
    {
      this->explicitAddressScheme_.set (x);
    }

    void valueSchemeType::
    explicitAddressScheme (::std::auto_ptr< explicitAddressScheme_type > x)
    {
      this->explicitAddressScheme_.set (x);
    }

    const valueSchemeType::explicitAddressValue_sequence& valueSchemeType::
    explicitAddressValue () const
    {
      return this->explicitAddressValue_;
    }

    valueSchemeType::explicitAddressValue_sequence& valueSchemeType::
    explicitAddressValue ()
    {
      return this->explicitAddressValue_;
    }

    void valueSchemeType::
    explicitAddressValue (const explicitAddressValue_sequence& s)
    {
      this->explicitAddressValue_ = s;
    }


    // targetAreaType
    // 

    const targetAreaType::circle_sequence& targetAreaType::
    circle () const
    {
      return this->circle_;
    }

    targetAreaType::circle_sequence& targetAreaType::
    circle ()
    {
      return this->circle_;
    }

    void targetAreaType::
    circle (const circle_sequence& s)
    {
      this->circle_ = s;
    }

    const targetAreaType::polygon_sequence& targetAreaType::
    polygon () const
    {
      return this->polygon_;
    }

    targetAreaType::polygon_sequence& targetAreaType::
    polygon ()
    {
      return this->polygon_;
    }

    void targetAreaType::
    polygon (const polygon_sequence& s)
    {
      this->polygon_ = s;
    }

    const targetAreaType::country_sequence& targetAreaType::
    country () const
    {
      return this->country_;
    }

    targetAreaType::country_sequence& targetAreaType::
    country ()
    {
      return this->country_;
    }

    void targetAreaType::
    country (const country_sequence& s)
    {
      this->country_ = s;
    }

    const targetAreaType::subdivision_sequence& targetAreaType::
    subdivision () const
    {
      return this->subdivision_;
    }

    targetAreaType::subdivision_sequence& targetAreaType::
    subdivision ()
    {
      return this->subdivision_;
    }

    void targetAreaType::
    subdivision (const subdivision_sequence& s)
    {
      this->subdivision_ = s;
    }

    const targetAreaType::locCodeUN_sequence& targetAreaType::
    locCodeUN () const
    {
      return this->locCodeUN_;
    }

    targetAreaType::locCodeUN_sequence& targetAreaType::
    locCodeUN ()
    {
      return this->locCodeUN_;
    }

    void targetAreaType::
    locCodeUN (const locCodeUN_sequence& s)
    {
      this->locCodeUN_ = s;
    }


    // statusValues
    // 

    statusValues::
    statusValues (value v)
    : ::xml_schema::nmtoken (_xsd_statusValues_literals_[v])
    {
    }

    statusValues::
    statusValues (const char* v)
    : ::xml_schema::nmtoken (v)
    {
    }

    statusValues::
    statusValues (const ::std::string& v)
    : ::xml_schema::nmtoken (v)
    {
    }

    statusValues::
    statusValues (const ::xml_schema::nmtoken& v)
    : ::xml_schema::nmtoken (v)
    {
    }

    statusValues::
    statusValues (const statusValues& v,
                  ::xml_schema::flags f,
                  ::xml_schema::container* c)
    : ::xml_schema::nmtoken (v, f, c)
    {
    }

    statusValues& statusValues::
    operator= (value v)
    {
      static_cast< ::xml_schema::nmtoken& > (*this) = 
      ::xml_schema::nmtoken (_xsd_statusValues_literals_[v]);

      return *this;
    }


    // typeValues
    // 

    typeValues::
    typeValues (value v)
    : ::xml_schema::nmtoken (_xsd_typeValues_literals_[v])
    {
    }

    typeValues::
    typeValues (const char* v)
    : ::xml_schema::nmtoken (v)
    {
    }

    typeValues::
    typeValues (const ::std::string& v)
    : ::xml_schema::nmtoken (v)
    {
    }

    typeValues::
    typeValues (const ::xml_schema::nmtoken& v)
    : ::xml_schema::nmtoken (v)
    {
    }

    typeValues::
    typeValues (const typeValues& v,
                ::xml_schema::flags f,
                ::xml_schema::container* c)
    : ::xml_schema::nmtoken (v, f, c)
    {
    }

    typeValues& typeValues::
    operator= (value v)
    {
      static_cast< ::xml_schema::nmtoken& > (*this) = 
      ::xml_schema::nmtoken (_xsd_typeValues_literals_[v]);

      return *this;
    }


    // EDXLDistribution
    // 

    const EDXLDistribution::distributionID_type& EDXLDistribution::
    distributionID () const
    {
      return this->distributionID_.get ();
    }

    EDXLDistribution::distributionID_type& EDXLDistribution::
    distributionID ()
    {
      return this->distributionID_.get ();
    }

    void EDXLDistribution::
    distributionID (const distributionID_type& x)
    {
      this->distributionID_.set (x);
    }

    void EDXLDistribution::
    distributionID (::std::auto_ptr< distributionID_type > x)
    {
      this->distributionID_.set (x);
    }

    const EDXLDistribution::senderID_type& EDXLDistribution::
    senderID () const
    {
      return this->senderID_.get ();
    }

    EDXLDistribution::senderID_type& EDXLDistribution::
    senderID ()
    {
      return this->senderID_.get ();
    }

    void EDXLDistribution::
    senderID (const senderID_type& x)
    {
      this->senderID_.set (x);
    }

    void EDXLDistribution::
    senderID (::std::auto_ptr< senderID_type > x)
    {
      this->senderID_.set (x);
    }

    const EDXLDistribution::dateTimeSent_type& EDXLDistribution::
    dateTimeSent () const
    {
      return this->dateTimeSent_.get ();
    }

    EDXLDistribution::dateTimeSent_type& EDXLDistribution::
    dateTimeSent ()
    {
      return this->dateTimeSent_.get ();
    }

    void EDXLDistribution::
    dateTimeSent (const dateTimeSent_type& x)
    {
      this->dateTimeSent_.set (x);
    }

    void EDXLDistribution::
    dateTimeSent (::std::auto_ptr< dateTimeSent_type > x)
    {
      this->dateTimeSent_.set (x);
    }

    const EDXLDistribution::distributionStatus_type& EDXLDistribution::
    distributionStatus () const
    {
      return this->distributionStatus_.get ();
    }

    EDXLDistribution::distributionStatus_type& EDXLDistribution::
    distributionStatus ()
    {
      return this->distributionStatus_.get ();
    }

    void EDXLDistribution::
    distributionStatus (const distributionStatus_type& x)
    {
      this->distributionStatus_.set (x);
    }

    void EDXLDistribution::
    distributionStatus (::std::auto_ptr< distributionStatus_type > x)
    {
      this->distributionStatus_.set (x);
    }

    const EDXLDistribution::distributionType_type& EDXLDistribution::
    distributionType () const
    {
      return this->distributionType_.get ();
    }

    EDXLDistribution::distributionType_type& EDXLDistribution::
    distributionType ()
    {
      return this->distributionType_.get ();
    }

    void EDXLDistribution::
    distributionType (const distributionType_type& x)
    {
      this->distributionType_.set (x);
    }

    void EDXLDistribution::
    distributionType (::std::auto_ptr< distributionType_type > x)
    {
      this->distributionType_.set (x);
    }

    const EDXLDistribution::combinedConfidentiality_type& EDXLDistribution::
    combinedConfidentiality () const
    {
      return this->combinedConfidentiality_.get ();
    }

    EDXLDistribution::combinedConfidentiality_type& EDXLDistribution::
    combinedConfidentiality ()
    {
      return this->combinedConfidentiality_.get ();
    }

    void EDXLDistribution::
    combinedConfidentiality (const combinedConfidentiality_type& x)
    {
      this->combinedConfidentiality_.set (x);
    }

    void EDXLDistribution::
    combinedConfidentiality (::std::auto_ptr< combinedConfidentiality_type > x)
    {
      this->combinedConfidentiality_.set (x);
    }

    const EDXLDistribution::language_optional& EDXLDistribution::
    language () const
    {
      return this->language_;
    }

    EDXLDistribution::language_optional& EDXLDistribution::
    language ()
    {
      return this->language_;
    }

    void EDXLDistribution::
    language (const language_type& x)
    {
      this->language_.set (x);
    }

    void EDXLDistribution::
    language (const language_optional& x)
    {
      this->language_ = x;
    }

    void EDXLDistribution::
    language (::std::auto_ptr< language_type > x)
    {
      this->language_.set (x);
    }

    const EDXLDistribution::senderRole_sequence& EDXLDistribution::
    senderRole () const
    {
      return this->senderRole_;
    }

    EDXLDistribution::senderRole_sequence& EDXLDistribution::
    senderRole ()
    {
      return this->senderRole_;
    }

    void EDXLDistribution::
    senderRole (const senderRole_sequence& s)
    {
      this->senderRole_ = s;
    }

    const EDXLDistribution::recipientRole_sequence& EDXLDistribution::
    recipientRole () const
    {
      return this->recipientRole_;
    }

    EDXLDistribution::recipientRole_sequence& EDXLDistribution::
    recipientRole ()
    {
      return this->recipientRole_;
    }

    void EDXLDistribution::
    recipientRole (const recipientRole_sequence& s)
    {
      this->recipientRole_ = s;
    }

    const EDXLDistribution::keyword_sequence& EDXLDistribution::
    keyword () const
    {
      return this->keyword_;
    }

    EDXLDistribution::keyword_sequence& EDXLDistribution::
    keyword ()
    {
      return this->keyword_;
    }

    void EDXLDistribution::
    keyword (const keyword_sequence& s)
    {
      this->keyword_ = s;
    }

    const EDXLDistribution::distributionReference_sequence& EDXLDistribution::
    distributionReference () const
    {
      return this->distributionReference_;
    }

    EDXLDistribution::distributionReference_sequence& EDXLDistribution::
    distributionReference ()
    {
      return this->distributionReference_;
    }

    void EDXLDistribution::
    distributionReference (const distributionReference_sequence& s)
    {
      this->distributionReference_ = s;
    }

    const EDXLDistribution::explicitAddress_sequence& EDXLDistribution::
    explicitAddress () const
    {
      return this->explicitAddress_;
    }

    EDXLDistribution::explicitAddress_sequence& EDXLDistribution::
    explicitAddress ()
    {
      return this->explicitAddress_;
    }

    void EDXLDistribution::
    explicitAddress (const explicitAddress_sequence& s)
    {
      this->explicitAddress_ = s;
    }

    const EDXLDistribution::targetArea_sequence& EDXLDistribution::
    targetArea () const
    {
      return this->targetArea_;
    }

    EDXLDistribution::targetArea_sequence& EDXLDistribution::
    targetArea ()
    {
      return this->targetArea_;
    }

    void EDXLDistribution::
    targetArea (const targetArea_sequence& s)
    {
      this->targetArea_ = s;
    }

    const EDXLDistribution::contentObject_sequence& EDXLDistribution::
    contentObject () const
    {
      return this->contentObject_;
    }

    EDXLDistribution::contentObject_sequence& EDXLDistribution::
    contentObject ()
    {
      return this->contentObject_;
    }

    void EDXLDistribution::
    contentObject (const contentObject_sequence& s)
    {
      this->contentObject_ = s;
    }
  }
}

#include <xsd/cxx/xml/dom/parsing-source.hxx>

namespace edxl
{
  namespace de
  {
    // contentObjectType
    //

    contentObjectType::
    contentObjectType ()
    : ::xml_schema::type (),
      contentDescription_ (::xml_schema::flags (), this),
      contentKeyword_ (::xml_schema::flags (), this),
      incidentID_ (::xml_schema::flags (), this),
      incidentDescription_ (::xml_schema::flags (), this),
      originatorRole_ (::xml_schema::flags (), this),
      consumerRole_ (::xml_schema::flags (), this),
      confidentiality_ (::xml_schema::flags (), this),
      nonXMLContent_ (::xml_schema::flags (), this),
      xmlContent_ (::xml_schema::flags (), this)
    {
    }

    contentObjectType::
    contentObjectType (const contentObjectType& x,
                       ::xml_schema::flags f,
                       ::xml_schema::container* c)
    : ::xml_schema::type (x, f, c),
      contentDescription_ (x.contentDescription_, f, this),
      contentKeyword_ (x.contentKeyword_, f, this),
      incidentID_ (x.incidentID_, f, this),
      incidentDescription_ (x.incidentDescription_, f, this),
      originatorRole_ (x.originatorRole_, f, this),
      consumerRole_ (x.consumerRole_, f, this),
      confidentiality_ (x.confidentiality_, f, this),
      nonXMLContent_ (x.nonXMLContent_, f, this),
      xmlContent_ (x.xmlContent_, f, this)
    {
    }

    contentObjectType::
    contentObjectType (const ::xercesc::DOMElement& e,
                       ::xml_schema::flags f,
                       ::xml_schema::container* c)
    : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
      contentDescription_ (f, this),
      contentKeyword_ (f, this),
      incidentID_ (f, this),
      incidentDescription_ (f, this),
      originatorRole_ (f, this),
      consumerRole_ (f, this),
      confidentiality_ (f, this),
      nonXMLContent_ (f, this),
      xmlContent_ (f, this)
    {
      if ((f & ::xml_schema::flags::base) == 0)
      {
        ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
        this->parse (p, f);
      }
    }

    void contentObjectType::
    parse (::xsd::cxx::xml::dom::parser< char >& p,
           ::xml_schema::flags f)
    {
      for (; p.more_elements (); p.next_element ())
      {
        const ::xercesc::DOMElement& i (p.cur_element ());
        const ::xsd::cxx::xml::qualified_name< char > n (
          ::xsd::cxx::xml::dom::name< char > (i));

        // contentDescription
        //
        if (n.name () == "contentDescription" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< contentDescription_type > r (
            contentDescription_traits::create (i, f, this));

          if (!this->contentDescription_)
          {
            this->contentDescription_.set (r);
            continue;
          }
        }

        // contentKeyword
        //
        if (n.name () == "contentKeyword" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< contentKeyword_type > r (
            contentKeyword_traits::create (i, f, this));

          this->contentKeyword_.push_back (r);
          continue;
        }

        // incidentID
        //
        if (n.name () == "incidentID" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< incidentID_type > r (
            incidentID_traits::create (i, f, this));

          if (!this->incidentID_)
          {
            this->incidentID_.set (r);
            continue;
          }
        }

        // incidentDescription
        //
        if (n.name () == "incidentDescription" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< incidentDescription_type > r (
            incidentDescription_traits::create (i, f, this));

          if (!this->incidentDescription_)
          {
            this->incidentDescription_.set (r);
            continue;
          }
        }

        // originatorRole
        //
        if (n.name () == "originatorRole" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< originatorRole_type > r (
            originatorRole_traits::create (i, f, this));

          this->originatorRole_.push_back (r);
          continue;
        }

        // consumerRole
        //
        if (n.name () == "consumerRole" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< consumerRole_type > r (
            consumerRole_traits::create (i, f, this));

          this->consumerRole_.push_back (r);
          continue;
        }

        // confidentiality
        //
        if (n.name () == "confidentiality" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< confidentiality_type > r (
            confidentiality_traits::create (i, f, this));

          if (!this->confidentiality_)
          {
            this->confidentiality_.set (r);
            continue;
          }
        }

        // nonXMLContent
        //
        if (n.name () == "nonXMLContent" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< nonXMLContent_type > r (
            nonXMLContent_traits::create (i, f, this));

          if (!this->nonXMLContent_)
          {
            this->nonXMLContent_.set (r);
            continue;
          }
        }

        // xmlContent
        //
        if (n.name () == "xmlContent" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< xmlContent_type > r (
            xmlContent_traits::create (i, f, this));

          if (!this->xmlContent_)
          {
            this->xmlContent_.set (r);
            continue;
          }
        }

        break;
      }
    }

    contentObjectType* contentObjectType::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class contentObjectType (*this, f, c);
    }

    contentObjectType::
    ~contentObjectType ()
    {
    }

    // nonXMLContentType
    //

    nonXMLContentType::
    nonXMLContentType (const mimeType_type& mimeType)
    : ::xml_schema::type (),
      mimeType_ (mimeType, ::xml_schema::flags (), this),
      size_ (::xml_schema::flags (), this),
      digest_ (::xml_schema::flags (), this),
      uri_ (::xml_schema::flags (), this),
      contentData_ (::xml_schema::flags (), this)
    {
    }

    nonXMLContentType::
    nonXMLContentType (const nonXMLContentType& x,
                       ::xml_schema::flags f,
                       ::xml_schema::container* c)
    : ::xml_schema::type (x, f, c),
      mimeType_ (x.mimeType_, f, this),
      size_ (x.size_, f, this),
      digest_ (x.digest_, f, this),
      uri_ (x.uri_, f, this),
      contentData_ (x.contentData_, f, this)
    {
    }

    nonXMLContentType::
    nonXMLContentType (const ::xercesc::DOMElement& e,
                       ::xml_schema::flags f,
                       ::xml_schema::container* c)
    : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
      mimeType_ (f, this),
      size_ (f, this),
      digest_ (f, this),
      uri_ (f, this),
      contentData_ (f, this)
    {
      if ((f & ::xml_schema::flags::base) == 0)
      {
        ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
        this->parse (p, f);
      }
    }

    void nonXMLContentType::
    parse (::xsd::cxx::xml::dom::parser< char >& p,
           ::xml_schema::flags f)
    {
      for (; p.more_elements (); p.next_element ())
      {
        const ::xercesc::DOMElement& i (p.cur_element ());
        const ::xsd::cxx::xml::qualified_name< char > n (
          ::xsd::cxx::xml::dom::name< char > (i));

        // mimeType
        //
        if (n.name () == "mimeType" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< mimeType_type > r (
            mimeType_traits::create (i, f, this));

          if (!mimeType_.present ())
          {
            this->mimeType_.set (r);
            continue;
          }
        }

        // size
        //
        if (n.name () == "size" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          if (!this->size_)
          {
            this->size_.set (size_traits::create (i, f, this));
            continue;
          }
        }

        // digest
        //
        if (n.name () == "digest" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< digest_type > r (
            digest_traits::create (i, f, this));

          if (!this->digest_)
          {
            this->digest_.set (r);
            continue;
          }
        }

        // uri
        //
        if (n.name () == "uri" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< uri_type > r (
            uri_traits::create (i, f, this));

          if (!this->uri_)
          {
            this->uri_.set (r);
            continue;
          }
        }

        // contentData
        //
        if (n.name () == "contentData" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< contentData_type > r (
            contentData_traits::create (i, f, this));

          if (!this->contentData_)
          {
            this->contentData_.set (r);
            continue;
          }
        }

        break;
      }

      if (!mimeType_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "mimeType",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }
    }

    nonXMLContentType* nonXMLContentType::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class nonXMLContentType (*this, f, c);
    }

    nonXMLContentType::
    ~nonXMLContentType ()
    {
    }

    // xmlContentType
    //

    xmlContentType::
    xmlContentType ()
    : ::xml_schema::type (),
      keyXMLContent_ (::xml_schema::flags (), this),
      embeddedXMLContent_ (::xml_schema::flags (), this)
    {
    }

    xmlContentType::
    xmlContentType (const xmlContentType& x,
                    ::xml_schema::flags f,
                    ::xml_schema::container* c)
    : ::xml_schema::type (x, f, c),
      keyXMLContent_ (x.keyXMLContent_, f, this),
      embeddedXMLContent_ (x.embeddedXMLContent_, f, this)
    {
    }

    xmlContentType::
    xmlContentType (const ::xercesc::DOMElement& e,
                    ::xml_schema::flags f,
                    ::xml_schema::container* c)
    : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
      keyXMLContent_ (f, this),
      embeddedXMLContent_ (f, this)
    {
      if ((f & ::xml_schema::flags::base) == 0)
      {
        ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
        this->parse (p, f);
      }
    }

    void xmlContentType::
    parse (::xsd::cxx::xml::dom::parser< char >& p,
           ::xml_schema::flags f)
    {
      for (; p.more_elements (); p.next_element ())
      {
        const ::xercesc::DOMElement& i (p.cur_element ());
        const ::xsd::cxx::xml::qualified_name< char > n (
          ::xsd::cxx::xml::dom::name< char > (i));

        // keyXMLContent
        //
        if (n.name () == "keyXMLContent" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< keyXMLContent_type > r (
            keyXMLContent_traits::create (i, f, this));

          this->keyXMLContent_.push_back (r);
          continue;
        }

        // embeddedXMLContent
        //
        if (n.name () == "embeddedXMLContent" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< embeddedXMLContent_type > r (
            embeddedXMLContent_traits::create (i, f, this));

          this->embeddedXMLContent_.push_back (r);
          continue;
        }

        break;
      }
    }

    xmlContentType* xmlContentType::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class xmlContentType (*this, f, c);
    }

    xmlContentType::
    ~xmlContentType ()
    {
    }

    // anyXMLType
    //

    anyXMLType::
    anyXMLType ()
    : ::xml_schema::type ()
    {
    }

    anyXMLType::
    anyXMLType (const anyXMLType& x,
                ::xml_schema::flags f,
                ::xml_schema::container* c)
    : ::xml_schema::type (x, f, c)
    {
    }

    anyXMLType::
    anyXMLType (const ::xercesc::DOMElement& e,
                ::xml_schema::flags f,
                ::xml_schema::container* c)
    : ::xml_schema::type (e, f | ::xml_schema::flags::base, c)
    {
      if ((f & ::xml_schema::flags::base) == 0)
      {
        ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
        this->parse (p, f);
      }
    }

    void anyXMLType::
    parse (::xsd::cxx::xml::dom::parser< char >& p,
           ::xml_schema::flags)
    {
      for (; p.more_elements (); p.next_element ())
      {
        const ::xercesc::DOMElement& i (p.cur_element ());
        const ::xsd::cxx::xml::qualified_name< char > n (
          ::xsd::cxx::xml::dom::name< char > (i));

        break;
      }
    }

    anyXMLType* anyXMLType::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class anyXMLType (*this, f, c);
    }

    anyXMLType::
    ~anyXMLType ()
    {
    }

    // valueListType
    //

    valueListType::
    valueListType (const valueListUrn_type& valueListUrn)
    : ::xml_schema::type (),
      valueListUrn_ (valueListUrn, ::xml_schema::flags (), this),
      value_ (::xml_schema::flags (), this)
    {
    }

    valueListType::
    valueListType (const valueListType& x,
                   ::xml_schema::flags f,
                   ::xml_schema::container* c)
    : ::xml_schema::type (x, f, c),
      valueListUrn_ (x.valueListUrn_, f, this),
      value_ (x.value_, f, this)
    {
    }

    valueListType::
    valueListType (const ::xercesc::DOMElement& e,
                   ::xml_schema::flags f,
                   ::xml_schema::container* c)
    : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
      valueListUrn_ (f, this),
      value_ (f, this)
    {
      if ((f & ::xml_schema::flags::base) == 0)
      {
        ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
        this->parse (p, f);
      }
    }

    void valueListType::
    parse (::xsd::cxx::xml::dom::parser< char >& p,
           ::xml_schema::flags f)
    {
      for (; p.more_elements (); p.next_element ())
      {
        const ::xercesc::DOMElement& i (p.cur_element ());
        const ::xsd::cxx::xml::qualified_name< char > n (
          ::xsd::cxx::xml::dom::name< char > (i));

        // valueListUrn
        //
        if (n.name () == "valueListUrn" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< valueListUrn_type > r (
            valueListUrn_traits::create (i, f, this));

          if (!valueListUrn_.present ())
          {
            this->valueListUrn_.set (r);
            continue;
          }
        }

        // value
        //
        if (n.name () == "value" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< value_type > r (
            value_traits::create (i, f, this));

          this->value_.push_back (r);
          continue;
        }

        break;
      }

      if (!valueListUrn_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "valueListUrn",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }
    }

    valueListType* valueListType::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class valueListType (*this, f, c);
    }

    valueListType::
    ~valueListType ()
    {
    }

    // valueSchemeType
    //

    valueSchemeType::
    valueSchemeType (const explicitAddressScheme_type& explicitAddressScheme)
    : ::xml_schema::type (),
      explicitAddressScheme_ (explicitAddressScheme, ::xml_schema::flags (), this),
      explicitAddressValue_ (::xml_schema::flags (), this)
    {
    }

    valueSchemeType::
    valueSchemeType (const valueSchemeType& x,
                     ::xml_schema::flags f,
                     ::xml_schema::container* c)
    : ::xml_schema::type (x, f, c),
      explicitAddressScheme_ (x.explicitAddressScheme_, f, this),
      explicitAddressValue_ (x.explicitAddressValue_, f, this)
    {
    }

    valueSchemeType::
    valueSchemeType (const ::xercesc::DOMElement& e,
                     ::xml_schema::flags f,
                     ::xml_schema::container* c)
    : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
      explicitAddressScheme_ (f, this),
      explicitAddressValue_ (f, this)
    {
      if ((f & ::xml_schema::flags::base) == 0)
      {
        ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
        this->parse (p, f);
      }
    }

    void valueSchemeType::
    parse (::xsd::cxx::xml::dom::parser< char >& p,
           ::xml_schema::flags f)
    {
      for (; p.more_elements (); p.next_element ())
      {
        const ::xercesc::DOMElement& i (p.cur_element ());
        const ::xsd::cxx::xml::qualified_name< char > n (
          ::xsd::cxx::xml::dom::name< char > (i));

        // explicitAddressScheme
        //
        if (n.name () == "explicitAddressScheme" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< explicitAddressScheme_type > r (
            explicitAddressScheme_traits::create (i, f, this));

          if (!explicitAddressScheme_.present ())
          {
            this->explicitAddressScheme_.set (r);
            continue;
          }
        }

        // explicitAddressValue
        //
        if (n.name () == "explicitAddressValue" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< explicitAddressValue_type > r (
            explicitAddressValue_traits::create (i, f, this));

          this->explicitAddressValue_.push_back (r);
          continue;
        }

        break;
      }

      if (!explicitAddressScheme_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "explicitAddressScheme",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }
    }

    valueSchemeType* valueSchemeType::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class valueSchemeType (*this, f, c);
    }

    valueSchemeType::
    ~valueSchemeType ()
    {
    }

    // targetAreaType
    //

    targetAreaType::
    targetAreaType ()
    : ::xml_schema::type (),
      circle_ (::xml_schema::flags (), this),
      polygon_ (::xml_schema::flags (), this),
      country_ (::xml_schema::flags (), this),
      subdivision_ (::xml_schema::flags (), this),
      locCodeUN_ (::xml_schema::flags (), this)
    {
    }

    targetAreaType::
    targetAreaType (const targetAreaType& x,
                    ::xml_schema::flags f,
                    ::xml_schema::container* c)
    : ::xml_schema::type (x, f, c),
      circle_ (x.circle_, f, this),
      polygon_ (x.polygon_, f, this),
      country_ (x.country_, f, this),
      subdivision_ (x.subdivision_, f, this),
      locCodeUN_ (x.locCodeUN_, f, this)
    {
    }

    targetAreaType::
    targetAreaType (const ::xercesc::DOMElement& e,
                    ::xml_schema::flags f,
                    ::xml_schema::container* c)
    : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
      circle_ (f, this),
      polygon_ (f, this),
      country_ (f, this),
      subdivision_ (f, this),
      locCodeUN_ (f, this)
    {
      if ((f & ::xml_schema::flags::base) == 0)
      {
        ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
        this->parse (p, f);
      }
    }

    void targetAreaType::
    parse (::xsd::cxx::xml::dom::parser< char >& p,
           ::xml_schema::flags f)
    {
      for (; p.more_elements (); p.next_element ())
      {
        const ::xercesc::DOMElement& i (p.cur_element ());
        const ::xsd::cxx::xml::qualified_name< char > n (
          ::xsd::cxx::xml::dom::name< char > (i));

        // circle
        //
        if (n.name () == "circle" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< circle_type > r (
            circle_traits::create (i, f, this));

          this->circle_.push_back (r);
          continue;
        }

        // polygon
        //
        if (n.name () == "polygon" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< polygon_type > r (
            polygon_traits::create (i, f, this));

          this->polygon_.push_back (r);
          continue;
        }

        // country
        //
        if (n.name () == "country" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< country_type > r (
            country_traits::create (i, f, this));

          this->country_.push_back (r);
          continue;
        }

        // subdivision
        //
        if (n.name () == "subdivision" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< subdivision_type > r (
            subdivision_traits::create (i, f, this));

          this->subdivision_.push_back (r);
          continue;
        }

        // locCodeUN
        //
        if (n.name () == "locCodeUN" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< locCodeUN_type > r (
            locCodeUN_traits::create (i, f, this));

          this->locCodeUN_.push_back (r);
          continue;
        }

        break;
      }
    }

    targetAreaType* targetAreaType::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class targetAreaType (*this, f, c);
    }

    targetAreaType::
    ~targetAreaType ()
    {
    }

    // statusValues
    //

    statusValues::
    statusValues (const ::xercesc::DOMElement& e,
                  ::xml_schema::flags f,
                  ::xml_schema::container* c)
    : ::xml_schema::nmtoken (e, f, c)
    {
      _xsd_statusValues_convert ();
    }

    statusValues::
    statusValues (const ::xercesc::DOMAttr& a,
                  ::xml_schema::flags f,
                  ::xml_schema::container* c)
    : ::xml_schema::nmtoken (a, f, c)
    {
      _xsd_statusValues_convert ();
    }

    statusValues::
    statusValues (const ::std::string& s,
                  const ::xercesc::DOMElement* e,
                  ::xml_schema::flags f,
                  ::xml_schema::container* c)
    : ::xml_schema::nmtoken (s, e, f, c)
    {
      _xsd_statusValues_convert ();
    }

    statusValues* statusValues::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class statusValues (*this, f, c);
    }

    statusValues::value statusValues::
    _xsd_statusValues_convert () const
    {
      ::xsd::cxx::tree::enum_comparator< char > c (_xsd_statusValues_literals_);
      const value* i (::std::lower_bound (
                        _xsd_statusValues_indexes_,
                        _xsd_statusValues_indexes_ + 4,
                        *this,
                        c));

      if (i == _xsd_statusValues_indexes_ + 4 || _xsd_statusValues_literals_[*i] != *this)
      {
        throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
      }

      return *i;
    }

    const char* const statusValues::
    _xsd_statusValues_literals_[4] =
    {
      "Actual",
      "Exercise",
      "System",
      "Test"
    };

    const statusValues::value statusValues::
    _xsd_statusValues_indexes_[4] =
    {
      ::edxl::de::statusValues::Actual,
      ::edxl::de::statusValues::Exercise,
      ::edxl::de::statusValues::System,
      ::edxl::de::statusValues::Test
    };

    // typeValues
    //

    typeValues::
    typeValues (const ::xercesc::DOMElement& e,
                ::xml_schema::flags f,
                ::xml_schema::container* c)
    : ::xml_schema::nmtoken (e, f, c)
    {
      _xsd_typeValues_convert ();
    }

    typeValues::
    typeValues (const ::xercesc::DOMAttr& a,
                ::xml_schema::flags f,
                ::xml_schema::container* c)
    : ::xml_schema::nmtoken (a, f, c)
    {
      _xsd_typeValues_convert ();
    }

    typeValues::
    typeValues (const ::std::string& s,
                const ::xercesc::DOMElement* e,
                ::xml_schema::flags f,
                ::xml_schema::container* c)
    : ::xml_schema::nmtoken (s, e, f, c)
    {
      _xsd_typeValues_convert ();
    }

    typeValues* typeValues::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class typeValues (*this, f, c);
    }

    typeValues::value typeValues::
    _xsd_typeValues_convert () const
    {
      ::xsd::cxx::tree::enum_comparator< char > c (_xsd_typeValues_literals_);
      const value* i (::std::lower_bound (
                        _xsd_typeValues_indexes_,
                        _xsd_typeValues_indexes_ + 12,
                        *this,
                        c));

      if (i == _xsd_typeValues_indexes_ + 12 || _xsd_typeValues_literals_[*i] != *this)
      {
        throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
      }

      return *i;
    }

    const char* const typeValues::
    _xsd_typeValues_literals_[12] =
    {
      "Report",
      "Update",
      "Cancel",
      "Request",
      "Response",
      "Dispatch",
      "Ack",
      "Error",
      "SensorConfiguration",
      "SensorControl",
      "SensorStatus",
      "SensorDetection"
    };

    const typeValues::value typeValues::
    _xsd_typeValues_indexes_[12] =
    {
      ::edxl::de::typeValues::Ack,
      ::edxl::de::typeValues::Cancel,
      ::edxl::de::typeValues::Dispatch,
      ::edxl::de::typeValues::Error,
      ::edxl::de::typeValues::Report,
      ::edxl::de::typeValues::Request,
      ::edxl::de::typeValues::Response,
      ::edxl::de::typeValues::SensorConfiguration,
      ::edxl::de::typeValues::SensorControl,
      ::edxl::de::typeValues::SensorDetection,
      ::edxl::de::typeValues::SensorStatus,
      ::edxl::de::typeValues::Update
    };

    // EDXLDistribution
    //

    EDXLDistribution::
    EDXLDistribution (const distributionID_type& distributionID,
                      const senderID_type& senderID,
                      const dateTimeSent_type& dateTimeSent,
                      const distributionStatus_type& distributionStatus,
                      const distributionType_type& distributionType,
                      const combinedConfidentiality_type& combinedConfidentiality)
    : ::xml_schema::type (),
      distributionID_ (distributionID, ::xml_schema::flags (), this),
      senderID_ (senderID, ::xml_schema::flags (), this),
      dateTimeSent_ (dateTimeSent, ::xml_schema::flags (), this),
      distributionStatus_ (distributionStatus, ::xml_schema::flags (), this),
      distributionType_ (distributionType, ::xml_schema::flags (), this),
      combinedConfidentiality_ (combinedConfidentiality, ::xml_schema::flags (), this),
      language_ (::xml_schema::flags (), this),
      senderRole_ (::xml_schema::flags (), this),
      recipientRole_ (::xml_schema::flags (), this),
      keyword_ (::xml_schema::flags (), this),
      distributionReference_ (::xml_schema::flags (), this),
      explicitAddress_ (::xml_schema::flags (), this),
      targetArea_ (::xml_schema::flags (), this),
      contentObject_ (::xml_schema::flags (), this)
    {
    }

    EDXLDistribution::
    EDXLDistribution (const EDXLDistribution& x,
                      ::xml_schema::flags f,
                      ::xml_schema::container* c)
    : ::xml_schema::type (x, f, c),
      distributionID_ (x.distributionID_, f, this),
      senderID_ (x.senderID_, f, this),
      dateTimeSent_ (x.dateTimeSent_, f, this),
      distributionStatus_ (x.distributionStatus_, f, this),
      distributionType_ (x.distributionType_, f, this),
      combinedConfidentiality_ (x.combinedConfidentiality_, f, this),
      language_ (x.language_, f, this),
      senderRole_ (x.senderRole_, f, this),
      recipientRole_ (x.recipientRole_, f, this),
      keyword_ (x.keyword_, f, this),
      distributionReference_ (x.distributionReference_, f, this),
      explicitAddress_ (x.explicitAddress_, f, this),
      targetArea_ (x.targetArea_, f, this),
      contentObject_ (x.contentObject_, f, this)
    {
    }

    EDXLDistribution::
    EDXLDistribution (const ::xercesc::DOMElement& e,
                      ::xml_schema::flags f,
                      ::xml_schema::container* c)
    : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
      distributionID_ (f, this),
      senderID_ (f, this),
      dateTimeSent_ (f, this),
      distributionStatus_ (f, this),
      distributionType_ (f, this),
      combinedConfidentiality_ (f, this),
      language_ (f, this),
      senderRole_ (f, this),
      recipientRole_ (f, this),
      keyword_ (f, this),
      distributionReference_ (f, this),
      explicitAddress_ (f, this),
      targetArea_ (f, this),
      contentObject_ (f, this)
    {
      if ((f & ::xml_schema::flags::base) == 0)
      {
        ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
        this->parse (p, f);
      }
    }

    void EDXLDistribution::
    parse (::xsd::cxx::xml::dom::parser< char >& p,
           ::xml_schema::flags f)
    {
      for (; p.more_elements (); p.next_element ())
      {
        const ::xercesc::DOMElement& i (p.cur_element ());
        const ::xsd::cxx::xml::qualified_name< char > n (
          ::xsd::cxx::xml::dom::name< char > (i));

        // distributionID
        //
        if (n.name () == "distributionID" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< distributionID_type > r (
            distributionID_traits::create (i, f, this));

          if (!distributionID_.present ())
          {
            this->distributionID_.set (r);
            continue;
          }
        }

        // senderID
        //
        if (n.name () == "senderID" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< senderID_type > r (
            senderID_traits::create (i, f, this));

          if (!senderID_.present ())
          {
            this->senderID_.set (r);
            continue;
          }
        }

        // dateTimeSent
        //
        if (n.name () == "dateTimeSent" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< dateTimeSent_type > r (
            dateTimeSent_traits::create (i, f, this));

          if (!dateTimeSent_.present ())
          {
            this->dateTimeSent_.set (r);
            continue;
          }
        }

        // distributionStatus
        //
        if (n.name () == "distributionStatus" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< distributionStatus_type > r (
            distributionStatus_traits::create (i, f, this));

          if (!distributionStatus_.present ())
          {
            this->distributionStatus_.set (r);
            continue;
          }
        }

        // distributionType
        //
        if (n.name () == "distributionType" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< distributionType_type > r (
            distributionType_traits::create (i, f, this));

          if (!distributionType_.present ())
          {
            this->distributionType_.set (r);
            continue;
          }
        }

        // combinedConfidentiality
        //
        if (n.name () == "combinedConfidentiality" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< combinedConfidentiality_type > r (
            combinedConfidentiality_traits::create (i, f, this));

          if (!combinedConfidentiality_.present ())
          {
            this->combinedConfidentiality_.set (r);
            continue;
          }
        }

        // language
        //
        if (n.name () == "language" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< language_type > r (
            language_traits::create (i, f, this));

          if (!this->language_)
          {
            this->language_.set (r);
            continue;
          }
        }

        // senderRole
        //
        if (n.name () == "senderRole" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< senderRole_type > r (
            senderRole_traits::create (i, f, this));

          this->senderRole_.push_back (r);
          continue;
        }

        // recipientRole
        //
        if (n.name () == "recipientRole" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< recipientRole_type > r (
            recipientRole_traits::create (i, f, this));

          this->recipientRole_.push_back (r);
          continue;
        }

        // keyword
        //
        if (n.name () == "keyword" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< keyword_type > r (
            keyword_traits::create (i, f, this));

          this->keyword_.push_back (r);
          continue;
        }

        // distributionReference
        //
        if (n.name () == "distributionReference" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< distributionReference_type > r (
            distributionReference_traits::create (i, f, this));

          this->distributionReference_.push_back (r);
          continue;
        }

        // explicitAddress
        //
        if (n.name () == "explicitAddress" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< explicitAddress_type > r (
            explicitAddress_traits::create (i, f, this));

          this->explicitAddress_.push_back (r);
          continue;
        }

        // targetArea
        //
        if (n.name () == "targetArea" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< targetArea_type > r (
            targetArea_traits::create (i, f, this));

          this->targetArea_.push_back (r);
          continue;
        }

        // contentObject
        //
        if (n.name () == "contentObject" ) // && n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
        {
          ::std::auto_ptr< contentObject_type > r (
            contentObject_traits::create (i, f, this));

          this->contentObject_.push_back (r);
          continue;
        }

        break;
      }

      if (!distributionID_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "distributionID",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }

      if (!senderID_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "senderID",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }

      if (!dateTimeSent_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "dateTimeSent",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }

      if (!distributionStatus_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "distributionStatus",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }

      if (!distributionType_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "distributionType",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }

      if (!combinedConfidentiality_.present ())
      {
        throw ::xsd::cxx::tree::expected_element< char > (
          "combinedConfidentiality",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }
    }

    EDXLDistribution* EDXLDistribution::
    _clone (::xml_schema::flags f,
            ::xml_schema::container* c) const
    {
      return new class EDXLDistribution (*this, f, c);
    }

    EDXLDistribution::
    ~EDXLDistribution ()
    {
    }
  }
}

#include <istream>
#include <xsd/cxx/xml/sax/std-input-source.hxx>
#include <xsd/cxx/tree/error-handler.hxx>

namespace edxl
{
  namespace de
  {
    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (const ::std::string& u,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0,
        (f & ::xml_schema::flags::keep_dom) == 0);

      ::xsd::cxx::tree::error_handler< char > h;

      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::parse< char > (
          u, h, p, f));

      h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();

      ::std::auto_ptr< ::edxl::de::EDXLDistribution > r (
        ::edxl::de::EDXLDistribution_ (
          d, f | ::xml_schema::flags::own_dom, p));

      return r;
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (const ::std::string& u,
                       ::xml_schema::error_handler& h,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0,
        (f & ::xml_schema::flags::keep_dom) == 0);

      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::parse< char > (
          u, h, p, f));

      if (!d.get ())
        throw ::xsd::cxx::tree::parsing< char > ();

      ::std::auto_ptr< ::edxl::de::EDXLDistribution > r (
        ::edxl::de::EDXLDistribution_ (
          d, f | ::xml_schema::flags::own_dom, p));

      return r;
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (const ::std::string& u,
                       ::xercesc::DOMErrorHandler& h,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::parse< char > (
          u, h, p, f));

      if (!d.get ())
        throw ::xsd::cxx::tree::parsing< char > ();

      ::std::auto_ptr< ::edxl::de::EDXLDistribution > r (
        ::edxl::de::EDXLDistribution_ (
          d, f | ::xml_schema::flags::own_dom, p));

      return r;
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::std::istream& is,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0,
        (f & ::xml_schema::flags::keep_dom) == 0);

      ::xsd::cxx::xml::sax::std_input_source isrc (is);
      return ::edxl::de::EDXLDistribution_ (isrc, f, p);
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::std::istream& is,
                       ::xml_schema::error_handler& h,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0,
        (f & ::xml_schema::flags::keep_dom) == 0);

      ::xsd::cxx::xml::sax::std_input_source isrc (is);
      return ::edxl::de::EDXLDistribution_ (isrc, h, f, p);
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::std::istream& is,
                       ::xercesc::DOMErrorHandler& h,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xsd::cxx::xml::sax::std_input_source isrc (is);
      return ::edxl::de::EDXLDistribution_ (isrc, h, f, p);
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::std::istream& is,
                       const ::std::string& sid,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0,
        (f & ::xml_schema::flags::keep_dom) == 0);

      ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
      return ::edxl::de::EDXLDistribution_ (isrc, f, p);
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::std::istream& is,
                       const ::std::string& sid,
                       ::xml_schema::error_handler& h,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0,
        (f & ::xml_schema::flags::keep_dom) == 0);

      ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
      return ::edxl::de::EDXLDistribution_ (isrc, h, f, p);
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::std::istream& is,
                       const ::std::string& sid,
                       ::xercesc::DOMErrorHandler& h,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
      return ::edxl::de::EDXLDistribution_ (isrc, h, f, p);
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::xercesc::InputSource& i,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xsd::cxx::tree::error_handler< char > h;

      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::parse< char > (
          i, h, p, f));

      h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();

      ::std::auto_ptr< ::edxl::de::EDXLDistribution > r (
        ::edxl::de::EDXLDistribution_ (
          d, f | ::xml_schema::flags::own_dom, p));

      return r;
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::xercesc::InputSource& i,
                       ::xml_schema::error_handler& h,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::parse< char > (
          i, h, p, f));

      if (!d.get ())
        throw ::xsd::cxx::tree::parsing< char > ();

      ::std::auto_ptr< ::edxl::de::EDXLDistribution > r (
        ::edxl::de::EDXLDistribution_ (
          d, f | ::xml_schema::flags::own_dom, p));

      return r;
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::xercesc::InputSource& i,
                       ::xercesc::DOMErrorHandler& h,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::parse< char > (
          i, h, p, f));

      if (!d.get ())
        throw ::xsd::cxx::tree::parsing< char > ();

      ::std::auto_ptr< ::edxl::de::EDXLDistribution > r (
        ::edxl::de::EDXLDistribution_ (
          d, f | ::xml_schema::flags::own_dom, p));

      return r;
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (const ::xercesc::DOMDocument& d,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties& p)
    {
      if (f & ::xml_schema::flags::keep_dom)
      {
        ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > c (
          static_cast< ::xercesc::DOMDocument* > (d.cloneNode (true)));

        ::std::auto_ptr< ::edxl::de::EDXLDistribution > r (
          ::edxl::de::EDXLDistribution_ (
            c, f | ::xml_schema::flags::own_dom, p));

        return r;
      }

      const ::xercesc::DOMElement& e (*d.getDocumentElement ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (e));

      if (n.name () == "EDXLDistribution" &&
          n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
      {
        ::std::auto_ptr< ::edxl::de::EDXLDistribution > r (
          ::xsd::cxx::tree::traits< ::edxl::de::EDXLDistribution, char >::create (
            e, f, 0));
        return r;
      }

      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "EDXLDistribution",
        "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
    }

    ::std::auto_ptr< ::edxl::de::EDXLDistribution >
    EDXLDistribution_ (::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >& d,
                       ::xml_schema::flags f,
                       const ::xml_schema::properties&)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > c (
        ((f & ::xml_schema::flags::keep_dom) &&
         !(f & ::xml_schema::flags::own_dom))
        ? static_cast< ::xercesc::DOMDocument* > (d->cloneNode (true))
        : 0);

      ::xercesc::DOMDocument& doc (c.get () ? *c : *d);
      const ::xercesc::DOMElement& e (*doc.getDocumentElement ());

      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (e));

      if (f & ::xml_schema::flags::keep_dom)
        doc.setUserData (::xml_schema::dom::tree_node_key,
                         (c.get () ? &c : &d),
                         0);

      if (n.name () == "EDXLDistribution" &&
          n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
      {
        ::std::auto_ptr< ::edxl::de::EDXLDistribution > r (
          ::xsd::cxx::tree::traits< ::edxl::de::EDXLDistribution, char >::create (
            e, f, 0));
        return r;
      }

      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "EDXLDistribution",
        "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
    }
  }
}

#include <ostream>
#include <xsd/cxx/tree/error-handler.hxx>
#include <xsd/cxx/xml/dom/serialization-source.hxx>

namespace edxl
{
  namespace de
  {
    void
    EDXLDistribution_ (::std::ostream& o,
                       const ::edxl::de::EDXLDistribution& s,
                       const ::xml_schema::namespace_infomap& m,
                       const ::std::string& e,
                       ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0);

      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::edxl::de::EDXLDistribution_ (s, m, f));

      ::xsd::cxx::tree::error_handler< char > h;

      ::xsd::cxx::xml::dom::ostream_format_target t (o);
      if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
      {
        h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
      }
    }

    void
    EDXLDistribution_ (::std::ostream& o,
                       const ::edxl::de::EDXLDistribution& s,
                       ::xml_schema::error_handler& h,
                       const ::xml_schema::namespace_infomap& m,
                       const ::std::string& e,
                       ::xml_schema::flags f)
    {
      ::xsd::cxx::xml::auto_initializer i (
        (f & ::xml_schema::flags::dont_initialize) == 0);

      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::edxl::de::EDXLDistribution_ (s, m, f));
      ::xsd::cxx::xml::dom::ostream_format_target t (o);
      if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
      {
        throw ::xsd::cxx::tree::serialization< char > ();
      }
    }

    void
    EDXLDistribution_ (::std::ostream& o,
                       const ::edxl::de::EDXLDistribution& s,
                       ::xercesc::DOMErrorHandler& h,
                       const ::xml_schema::namespace_infomap& m,
                       const ::std::string& e,
                       ::xml_schema::flags f)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::edxl::de::EDXLDistribution_ (s, m, f));
      ::xsd::cxx::xml::dom::ostream_format_target t (o);
      if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
      {
        throw ::xsd::cxx::tree::serialization< char > ();
      }
    }

    void
    EDXLDistribution_ (::xercesc::XMLFormatTarget& t,
                       const ::edxl::de::EDXLDistribution& s,
                       const ::xml_schema::namespace_infomap& m,
                       const ::std::string& e,
                       ::xml_schema::flags f)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::edxl::de::EDXLDistribution_ (s, m, f));

      ::xsd::cxx::tree::error_handler< char > h;

      if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
      {
        h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
      }
    }

    void
    EDXLDistribution_ (::xercesc::XMLFormatTarget& t,
                       const ::edxl::de::EDXLDistribution& s,
                       ::xml_schema::error_handler& h,
                       const ::xml_schema::namespace_infomap& m,
                       const ::std::string& e,
                       ::xml_schema::flags f)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::edxl::de::EDXLDistribution_ (s, m, f));
      if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
      {
        throw ::xsd::cxx::tree::serialization< char > ();
      }
    }

    void
    EDXLDistribution_ (::xercesc::XMLFormatTarget& t,
                       const ::edxl::de::EDXLDistribution& s,
                       ::xercesc::DOMErrorHandler& h,
                       const ::xml_schema::namespace_infomap& m,
                       const ::std::string& e,
                       ::xml_schema::flags f)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::edxl::de::EDXLDistribution_ (s, m, f));
      if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
      {
        throw ::xsd::cxx::tree::serialization< char > ();
      }
    }

    void
    EDXLDistribution_ (::xercesc::DOMDocument& d,
                       const ::edxl::de::EDXLDistribution& s,
                       ::xml_schema::flags)
    {
      ::xercesc::DOMElement& e (*d.getDocumentElement ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (e));

      if (n.name () == "EDXLDistribution" &&
          n.namespace_ () == "urn:oasis:names:tc:emergency:EDXL:DE:1.0")
      {
        e << s;
      }
      else
      {
        throw ::xsd::cxx::tree::unexpected_element < char > (
          n.name (),
          n.namespace_ (),
          "EDXLDistribution",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0");
      }
    }

    ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument >
    EDXLDistribution_ (const ::edxl::de::EDXLDistribution& s,
                       const ::xml_schema::namespace_infomap& m,
                       ::xml_schema::flags f)
    {
      ::xml_schema::dom::auto_ptr< ::xercesc::DOMDocument > d (
        ::xsd::cxx::xml::dom::serialize< char > (
          "EDXLDistribution",
          "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
          m, f));

      ::edxl::de::EDXLDistribution_ (*d, s, f);
      return d;
    }

    void
    operator<< (::xercesc::DOMElement& e, const contentObjectType& i)
    {
      e << static_cast< const ::xml_schema::type& > (i);

      // contentDescription
      //
      if (i.contentDescription ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "contentDescription",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.contentDescription ();
      }

      // contentKeyword
      //
      for (contentObjectType::contentKeyword_const_iterator
           b (i.contentKeyword ().begin ()), n (i.contentKeyword ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "contentKeyword",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // incidentID
      //
      if (i.incidentID ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "incidentID",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.incidentID ();
      }

      // incidentDescription
      //
      if (i.incidentDescription ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "incidentDescription",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.incidentDescription ();
      }

      // originatorRole
      //
      for (contentObjectType::originatorRole_const_iterator
           b (i.originatorRole ().begin ()), n (i.originatorRole ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "originatorRole",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // consumerRole
      //
      for (contentObjectType::consumerRole_const_iterator
           b (i.consumerRole ().begin ()), n (i.consumerRole ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "consumerRole",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // confidentiality
      //
      if (i.confidentiality ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "confidentiality",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.confidentiality ();
      }

      // nonXMLContent
      //
      if (i.nonXMLContent ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "nonXMLContent",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.nonXMLContent ();
      }

      // xmlContent
      //
      if (i.xmlContent ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "xmlContent",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.xmlContent ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e, const nonXMLContentType& i)
    {
      e << static_cast< const ::xml_schema::type& > (i);

      // mimeType
      //
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "mimeType",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << i.mimeType ();
      }

      // size
      //
      if (i.size ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "size",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.size ();
      }

      // digest
      //
      if (i.digest ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "digest",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.digest ();
      }

      // uri
      //
      if (i.uri ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "uri",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.uri ();
      }

      // contentData
      //
      if (i.contentData ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "contentData",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.contentData ();
      }
    }

    void
    operator<< (::xercesc::DOMElement& e, const xmlContentType& i)
    {
      e << static_cast< const ::xml_schema::type& > (i);

      // keyXMLContent
      //
      for (xmlContentType::keyXMLContent_const_iterator
           b (i.keyXMLContent ().begin ()), n (i.keyXMLContent ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "keyXMLContent",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // embeddedXMLContent
      //
      for (xmlContentType::embeddedXMLContent_const_iterator
           b (i.embeddedXMLContent ().begin ()), n (i.embeddedXMLContent ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "embeddedXMLContent",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }
    }

    void
    operator<< (::xercesc::DOMElement& e, const anyXMLType& i)
    {
      e << static_cast< const ::xml_schema::type& > (i);
    }

    void
    operator<< (::xercesc::DOMElement& e, const valueListType& i)
    {
      e << static_cast< const ::xml_schema::type& > (i);

      // valueListUrn
      //
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "valueListUrn",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << i.valueListUrn ();
      }

      // value
      //
      for (valueListType::value_const_iterator
           b (i.value ().begin ()), n (i.value ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "value",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }
    }

    void
    operator<< (::xercesc::DOMElement& e, const valueSchemeType& i)
    {
      e << static_cast< const ::xml_schema::type& > (i);

      // explicitAddressScheme
      //
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "explicitAddressScheme",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << i.explicitAddressScheme ();
      }

      // explicitAddressValue
      //
      for (valueSchemeType::explicitAddressValue_const_iterator
           b (i.explicitAddressValue ().begin ()), n (i.explicitAddressValue ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "explicitAddressValue",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }
    }

    void
    operator<< (::xercesc::DOMElement& e, const targetAreaType& i)
    {
      e << static_cast< const ::xml_schema::type& > (i);

      // circle
      //
      for (targetAreaType::circle_const_iterator
           b (i.circle ().begin ()), n (i.circle ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "circle",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // polygon
      //
      for (targetAreaType::polygon_const_iterator
           b (i.polygon ().begin ()), n (i.polygon ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "polygon",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // country
      //
      for (targetAreaType::country_const_iterator
           b (i.country ().begin ()), n (i.country ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "country",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // subdivision
      //
      for (targetAreaType::subdivision_const_iterator
           b (i.subdivision ().begin ()), n (i.subdivision ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "subdivision",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // locCodeUN
      //
      for (targetAreaType::locCodeUN_const_iterator
           b (i.locCodeUN ().begin ()), n (i.locCodeUN ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "locCodeUN",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }
    }

    void
    operator<< (::xercesc::DOMElement& e, const statusValues& i)
    {
      e << static_cast< const ::xml_schema::nmtoken& > (i);
    }

    void
    operator<< (::xercesc::DOMAttr& a, const statusValues& i)
    {
      a << static_cast< const ::xml_schema::nmtoken& > (i);
    }

    void
    operator<< (::xml_schema::list_stream& l,
                const statusValues& i)
    {
      l << static_cast< const ::xml_schema::nmtoken& > (i);
    }

    void
    operator<< (::xercesc::DOMElement& e, const typeValues& i)
    {
      e << static_cast< const ::xml_schema::nmtoken& > (i);
    }

    void
    operator<< (::xercesc::DOMAttr& a, const typeValues& i)
    {
      a << static_cast< const ::xml_schema::nmtoken& > (i);
    }

    void
    operator<< (::xml_schema::list_stream& l,
                const typeValues& i)
    {
      l << static_cast< const ::xml_schema::nmtoken& > (i);
    }

    void
    operator<< (::xercesc::DOMElement& e, const EDXLDistribution& i)
    {
      e << static_cast< const ::xml_schema::type& > (i);

      // distributionID
      //
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "distributionID",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << i.distributionID ();
      }

      // senderID
      //
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "senderID",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << i.senderID ();
      }

      // dateTimeSent
      //
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "dateTimeSent",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << i.dateTimeSent ();
      }

      // distributionStatus
      //
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "distributionStatus",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << i.distributionStatus ();
      }

      // distributionType
      //
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "distributionType",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << i.distributionType ();
      }

      // combinedConfidentiality
      //
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "combinedConfidentiality",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << i.combinedConfidentiality ();
      }

      // language
      //
      if (i.language ())
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "language",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *i.language ();
      }

      // senderRole
      //
      for (EDXLDistribution::senderRole_const_iterator
           b (i.senderRole ().begin ()), n (i.senderRole ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "senderRole",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // recipientRole
      //
      for (EDXLDistribution::recipientRole_const_iterator
           b (i.recipientRole ().begin ()), n (i.recipientRole ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "recipientRole",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // keyword
      //
      for (EDXLDistribution::keyword_const_iterator
           b (i.keyword ().begin ()), n (i.keyword ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "keyword",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // distributionReference
      //
      for (EDXLDistribution::distributionReference_const_iterator
           b (i.distributionReference ().begin ()), n (i.distributionReference ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "distributionReference",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // explicitAddress
      //
      for (EDXLDistribution::explicitAddress_const_iterator
           b (i.explicitAddress ().begin ()), n (i.explicitAddress ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "explicitAddress",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // targetArea
      //
      for (EDXLDistribution::targetArea_const_iterator
           b (i.targetArea ().begin ()), n (i.targetArea ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "targetArea",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }

      // contentObject
      //
      for (EDXLDistribution::contentObject_const_iterator
           b (i.contentObject ().begin ()), n (i.contentObject ().end ());
           b != n; ++b)
      {
        ::xercesc::DOMElement& s (
          ::xsd::cxx::xml::dom::create_element (
            "contentObject",
            "urn:oasis:names:tc:emergency:EDXL:DE:1.0",
            e));

        s << *b;
      }
    }
  }
}

#include <xsd/cxx/post.hxx>

// Begin epilogue.
//
//
// End epilogue.