// 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 "fpml/xmldsig-core-schema.h"

namespace xmldsig
{
  // CryptoBinary
  // 


  // SignatureType
  // 

  const SignatureType::SignedInfoType& SignatureType::
  SignedInfo () const
  {
    return this->SignedInfo_.get ();
  }

  SignatureType::SignedInfoType& SignatureType::
  SignedInfo ()
  {
    return this->SignedInfo_.get ();
  }

  void SignatureType::
  SignedInfo (const SignedInfoType& x)
  {
    this->SignedInfo_.set (x);
  }

  void SignatureType::
  SignedInfo (::std::auto_ptr< SignedInfoType > x)
  {
    this->SignedInfo_.set (x);
  }

  const SignatureType::SignatureValueType& SignatureType::
  SignatureValue () const
  {
    return this->SignatureValue_.get ();
  }

  SignatureType::SignatureValueType& SignatureType::
  SignatureValue ()
  {
    return this->SignatureValue_.get ();
  }

  void SignatureType::
  SignatureValue (const SignatureValueType& x)
  {
    this->SignatureValue_.set (x);
  }

  void SignatureType::
  SignatureValue (::std::auto_ptr< SignatureValueType > x)
  {
    this->SignatureValue_.set (x);
  }

  const SignatureType::KeyInfoOptional& SignatureType::
  KeyInfo () const
  {
    return this->KeyInfo_;
  }

  SignatureType::KeyInfoOptional& SignatureType::
  KeyInfo ()
  {
    return this->KeyInfo_;
  }

  void SignatureType::
  KeyInfo (const KeyInfoType& x)
  {
    this->KeyInfo_.set (x);
  }

  void SignatureType::
  KeyInfo (const KeyInfoOptional& x)
  {
    this->KeyInfo_ = x;
  }

  void SignatureType::
  KeyInfo (::std::auto_ptr< KeyInfoType > x)
  {
    this->KeyInfo_.set (x);
  }

  const SignatureType::ObjectSequence& SignatureType::
  Object () const
  {
    return this->Object_;
  }

  SignatureType::ObjectSequence& SignatureType::
  Object ()
  {
    return this->Object_;
  }

  void SignatureType::
  Object (const ObjectSequence& s)
  {
    this->Object_ = s;
  }

  const SignatureType::IdOptional& SignatureType::
  Id () const
  {
    return this->Id_;
  }

  SignatureType::IdOptional& SignatureType::
  Id ()
  {
    return this->Id_;
  }

  void SignatureType::
  Id (const IdType& x)
  {
    this->Id_.set (x);
  }

  void SignatureType::
  Id (const IdOptional& x)
  {
    this->Id_ = x;
  }

  void SignatureType::
  Id (::std::auto_ptr< IdType > x)
  {
    this->Id_.set (x);
  }


  // SignatureValueType
  // 

  const SignatureValueType::IdOptional& SignatureValueType::
  Id () const
  {
    return this->Id_;
  }

  SignatureValueType::IdOptional& SignatureValueType::
  Id ()
  {
    return this->Id_;
  }

  void SignatureValueType::
  Id (const IdType& x)
  {
    this->Id_.set (x);
  }

  void SignatureValueType::
  Id (const IdOptional& x)
  {
    this->Id_ = x;
  }

  void SignatureValueType::
  Id (::std::auto_ptr< IdType > x)
  {
    this->Id_.set (x);
  }


  // SignedInfoType
  // 

  const SignedInfoType::CanonicalizationMethodType& SignedInfoType::
  CanonicalizationMethod () const
  {
    return this->CanonicalizationMethod_.get ();
  }

  SignedInfoType::CanonicalizationMethodType& SignedInfoType::
  CanonicalizationMethod ()
  {
    return this->CanonicalizationMethod_.get ();
  }

  void SignedInfoType::
  CanonicalizationMethod (const CanonicalizationMethodType& x)
  {
    this->CanonicalizationMethod_.set (x);
  }

  void SignedInfoType::
  CanonicalizationMethod (::std::auto_ptr< CanonicalizationMethodType > x)
  {
    this->CanonicalizationMethod_.set (x);
  }

  const SignedInfoType::SignatureMethodType& SignedInfoType::
  SignatureMethod () const
  {
    return this->SignatureMethod_.get ();
  }

  SignedInfoType::SignatureMethodType& SignedInfoType::
  SignatureMethod ()
  {
    return this->SignatureMethod_.get ();
  }

  void SignedInfoType::
  SignatureMethod (const SignatureMethodType& x)
  {
    this->SignatureMethod_.set (x);
  }

  void SignedInfoType::
  SignatureMethod (::std::auto_ptr< SignatureMethodType > x)
  {
    this->SignatureMethod_.set (x);
  }

  const SignedInfoType::ReferenceSequence& SignedInfoType::
  Reference () const
  {
    return this->Reference_;
  }

  SignedInfoType::ReferenceSequence& SignedInfoType::
  Reference ()
  {
    return this->Reference_;
  }

  void SignedInfoType::
  Reference (const ReferenceSequence& s)
  {
    this->Reference_ = s;
  }

  const SignedInfoType::IdOptional& SignedInfoType::
  Id () const
  {
    return this->Id_;
  }

  SignedInfoType::IdOptional& SignedInfoType::
  Id ()
  {
    return this->Id_;
  }

  void SignedInfoType::
  Id (const IdType& x)
  {
    this->Id_.set (x);
  }

  void SignedInfoType::
  Id (const IdOptional& x)
  {
    this->Id_ = x;
  }

  void SignedInfoType::
  Id (::std::auto_ptr< IdType > x)
  {
    this->Id_.set (x);
  }


  // CanonicalizationMethodType
  // 

  const CanonicalizationMethodType::AlgorithmType& CanonicalizationMethodType::
  Algorithm () const
  {
    return this->Algorithm_.get ();
  }

  CanonicalizationMethodType::AlgorithmType& CanonicalizationMethodType::
  Algorithm ()
  {
    return this->Algorithm_.get ();
  }

  void CanonicalizationMethodType::
  Algorithm (const AlgorithmType& x)
  {
    this->Algorithm_.set (x);
  }

  void CanonicalizationMethodType::
  Algorithm (::std::auto_ptr< AlgorithmType > x)
  {
    this->Algorithm_.set (x);
  }


  // SignatureMethodType
  // 

  const SignatureMethodType::HMACOutputLengthOptional& SignatureMethodType::
  HMACOutputLength () const
  {
    return this->HMACOutputLength_;
  }

  SignatureMethodType::HMACOutputLengthOptional& SignatureMethodType::
  HMACOutputLength ()
  {
    return this->HMACOutputLength_;
  }

  void SignatureMethodType::
  HMACOutputLength (const HMACOutputLengthType& x)
  {
    this->HMACOutputLength_.set (x);
  }

  void SignatureMethodType::
  HMACOutputLength (const HMACOutputLengthOptional& x)
  {
    this->HMACOutputLength_ = x;
  }

  void SignatureMethodType::
  HMACOutputLength (::std::auto_ptr< HMACOutputLengthType > x)
  {
    this->HMACOutputLength_.set (x);
  }

  const SignatureMethodType::AlgorithmType& SignatureMethodType::
  Algorithm () const
  {
    return this->Algorithm_.get ();
  }

  SignatureMethodType::AlgorithmType& SignatureMethodType::
  Algorithm ()
  {
    return this->Algorithm_.get ();
  }

  void SignatureMethodType::
  Algorithm (const AlgorithmType& x)
  {
    this->Algorithm_.set (x);
  }

  void SignatureMethodType::
  Algorithm (::std::auto_ptr< AlgorithmType > x)
  {
    this->Algorithm_.set (x);
  }


  // ReferenceType
  // 

  const ReferenceType::TransformsOptional& ReferenceType::
  Transforms () const
  {
    return this->Transforms_;
  }

  ReferenceType::TransformsOptional& ReferenceType::
  Transforms ()
  {
    return this->Transforms_;
  }

  void ReferenceType::
  Transforms (const TransformsType& x)
  {
    this->Transforms_.set (x);
  }

  void ReferenceType::
  Transforms (const TransformsOptional& x)
  {
    this->Transforms_ = x;
  }

  void ReferenceType::
  Transforms (::std::auto_ptr< TransformsType > x)
  {
    this->Transforms_.set (x);
  }

  const ReferenceType::DigestMethodType& ReferenceType::
  DigestMethod () const
  {
    return this->DigestMethod_.get ();
  }

  ReferenceType::DigestMethodType& ReferenceType::
  DigestMethod ()
  {
    return this->DigestMethod_.get ();
  }

  void ReferenceType::
  DigestMethod (const DigestMethodType& x)
  {
    this->DigestMethod_.set (x);
  }

  void ReferenceType::
  DigestMethod (::std::auto_ptr< DigestMethodType > x)
  {
    this->DigestMethod_.set (x);
  }

  const ReferenceType::DigestValueType& ReferenceType::
  DigestValue () const
  {
    return this->DigestValue_.get ();
  }

  ReferenceType::DigestValueType& ReferenceType::
  DigestValue ()
  {
    return this->DigestValue_.get ();
  }

  void ReferenceType::
  DigestValue (const DigestValueType& x)
  {
    this->DigestValue_.set (x);
  }

  void ReferenceType::
  DigestValue (::std::auto_ptr< DigestValueType > x)
  {
    this->DigestValue_.set (x);
  }

  const ReferenceType::IdOptional& ReferenceType::
  Id () const
  {
    return this->Id_;
  }

  ReferenceType::IdOptional& ReferenceType::
  Id ()
  {
    return this->Id_;
  }

  void ReferenceType::
  Id (const IdType& x)
  {
    this->Id_.set (x);
  }

  void ReferenceType::
  Id (const IdOptional& x)
  {
    this->Id_ = x;
  }

  void ReferenceType::
  Id (::std::auto_ptr< IdType > x)
  {
    this->Id_.set (x);
  }

  const ReferenceType::URIOptional& ReferenceType::
  URI () const
  {
    return this->URI_;
  }

  ReferenceType::URIOptional& ReferenceType::
  URI ()
  {
    return this->URI_;
  }

  void ReferenceType::
  URI (const URIType& x)
  {
    this->URI_.set (x);
  }

  void ReferenceType::
  URI (const URIOptional& x)
  {
    this->URI_ = x;
  }

  void ReferenceType::
  URI (::std::auto_ptr< URIType > x)
  {
    this->URI_.set (x);
  }

  const ReferenceType::TypeOptional& ReferenceType::
  Type () const
  {
    return this->Type_;
  }

  ReferenceType::TypeOptional& ReferenceType::
  Type ()
  {
    return this->Type_;
  }

  void ReferenceType::
  Type (const TypeType& x)
  {
    this->Type_.set (x);
  }

  void ReferenceType::
  Type (const TypeOptional& x)
  {
    this->Type_ = x;
  }

  void ReferenceType::
  Type (::std::auto_ptr< TypeType > x)
  {
    this->Type_.set (x);
  }


  // TransformsType
  // 

  const TransformsType::TransformSequence& TransformsType::
  Transform () const
  {
    return this->Transform_;
  }

  TransformsType::TransformSequence& TransformsType::
  Transform ()
  {
    return this->Transform_;
  }

  void TransformsType::
  Transform (const TransformSequence& s)
  {
    this->Transform_ = s;
  }


  // TransformType
  // 

  const TransformType::XPathSequence& TransformType::
  XPath () const
  {
    return this->XPath_;
  }

  TransformType::XPathSequence& TransformType::
  XPath ()
  {
    return this->XPath_;
  }

  void TransformType::
  XPath (const XPathSequence& s)
  {
    this->XPath_ = s;
  }

  const TransformType::AlgorithmType& TransformType::
  Algorithm () const
  {
    return this->Algorithm_.get ();
  }

  TransformType::AlgorithmType& TransformType::
  Algorithm ()
  {
    return this->Algorithm_.get ();
  }

  void TransformType::
  Algorithm (const AlgorithmType& x)
  {
    this->Algorithm_.set (x);
  }

  void TransformType::
  Algorithm (::std::auto_ptr< AlgorithmType > x)
  {
    this->Algorithm_.set (x);
  }


  // DigestMethodType
  // 

  const DigestMethodType::AlgorithmType& DigestMethodType::
  Algorithm () const
  {
    return this->Algorithm_.get ();
  }

  DigestMethodType::AlgorithmType& DigestMethodType::
  Algorithm ()
  {
    return this->Algorithm_.get ();
  }

  void DigestMethodType::
  Algorithm (const AlgorithmType& x)
  {
    this->Algorithm_.set (x);
  }

  void DigestMethodType::
  Algorithm (::std::auto_ptr< AlgorithmType > x)
  {
    this->Algorithm_.set (x);
  }


  // DigestValueType
  // 


  // KeyInfoType
  // 

  const KeyInfoType::KeyNameSequence& KeyInfoType::
  KeyName () const
  {
    return this->KeyName_;
  }

  KeyInfoType::KeyNameSequence& KeyInfoType::
  KeyName ()
  {
    return this->KeyName_;
  }

  void KeyInfoType::
  KeyName (const KeyNameSequence& s)
  {
    this->KeyName_ = s;
  }

  const KeyInfoType::KeyValueSequence& KeyInfoType::
  KeyValue () const
  {
    return this->KeyValue_;
  }

  KeyInfoType::KeyValueSequence& KeyInfoType::
  KeyValue ()
  {
    return this->KeyValue_;
  }

  void KeyInfoType::
  KeyValue (const KeyValueSequence& s)
  {
    this->KeyValue_ = s;
  }

  const KeyInfoType::RetrievalMethodSequence& KeyInfoType::
  RetrievalMethod () const
  {
    return this->RetrievalMethod_;
  }

  KeyInfoType::RetrievalMethodSequence& KeyInfoType::
  RetrievalMethod ()
  {
    return this->RetrievalMethod_;
  }

  void KeyInfoType::
  RetrievalMethod (const RetrievalMethodSequence& s)
  {
    this->RetrievalMethod_ = s;
  }

  const KeyInfoType::X509DataSequence& KeyInfoType::
  X509Data () const
  {
    return this->X509Data_;
  }

  KeyInfoType::X509DataSequence& KeyInfoType::
  X509Data ()
  {
    return this->X509Data_;
  }

  void KeyInfoType::
  X509Data (const X509DataSequence& s)
  {
    this->X509Data_ = s;
  }

  const KeyInfoType::PGPDataSequence& KeyInfoType::
  PGPData () const
  {
    return this->PGPData_;
  }

  KeyInfoType::PGPDataSequence& KeyInfoType::
  PGPData ()
  {
    return this->PGPData_;
  }

  void KeyInfoType::
  PGPData (const PGPDataSequence& s)
  {
    this->PGPData_ = s;
  }

  const KeyInfoType::SPKIDataSequence& KeyInfoType::
  SPKIData () const
  {
    return this->SPKIData_;
  }

  KeyInfoType::SPKIDataSequence& KeyInfoType::
  SPKIData ()
  {
    return this->SPKIData_;
  }

  void KeyInfoType::
  SPKIData (const SPKIDataSequence& s)
  {
    this->SPKIData_ = s;
  }

  const KeyInfoType::MgmtDataSequence& KeyInfoType::
  MgmtData () const
  {
    return this->MgmtData_;
  }

  KeyInfoType::MgmtDataSequence& KeyInfoType::
  MgmtData ()
  {
    return this->MgmtData_;
  }

  void KeyInfoType::
  MgmtData (const MgmtDataSequence& s)
  {
    this->MgmtData_ = s;
  }

  const KeyInfoType::IdOptional& KeyInfoType::
  Id () const
  {
    return this->Id_;
  }

  KeyInfoType::IdOptional& KeyInfoType::
  Id ()
  {
    return this->Id_;
  }

  void KeyInfoType::
  Id (const IdType& x)
  {
    this->Id_.set (x);
  }

  void KeyInfoType::
  Id (const IdOptional& x)
  {
    this->Id_ = x;
  }

  void KeyInfoType::
  Id (::std::auto_ptr< IdType > x)
  {
    this->Id_.set (x);
  }


  // KeyValueType
  // 

  const KeyValueType::DSAKeyValueOptional& KeyValueType::
  DSAKeyValue () const
  {
    return this->DSAKeyValue_;
  }

  KeyValueType::DSAKeyValueOptional& KeyValueType::
  DSAKeyValue ()
  {
    return this->DSAKeyValue_;
  }

  void KeyValueType::
  DSAKeyValue (const DSAKeyValueType& x)
  {
    this->DSAKeyValue_.set (x);
  }

  void KeyValueType::
  DSAKeyValue (const DSAKeyValueOptional& x)
  {
    this->DSAKeyValue_ = x;
  }

  void KeyValueType::
  DSAKeyValue (::std::auto_ptr< DSAKeyValueType > x)
  {
    this->DSAKeyValue_.set (x);
  }

  const KeyValueType::RSAKeyValueOptional& KeyValueType::
  RSAKeyValue () const
  {
    return this->RSAKeyValue_;
  }

  KeyValueType::RSAKeyValueOptional& KeyValueType::
  RSAKeyValue ()
  {
    return this->RSAKeyValue_;
  }

  void KeyValueType::
  RSAKeyValue (const RSAKeyValueType& x)
  {
    this->RSAKeyValue_.set (x);
  }

  void KeyValueType::
  RSAKeyValue (const RSAKeyValueOptional& x)
  {
    this->RSAKeyValue_ = x;
  }

  void KeyValueType::
  RSAKeyValue (::std::auto_ptr< RSAKeyValueType > x)
  {
    this->RSAKeyValue_.set (x);
  }


  // RetrievalMethodType
  // 

  const RetrievalMethodType::TransformsOptional& RetrievalMethodType::
  Transforms () const
  {
    return this->Transforms_;
  }

  RetrievalMethodType::TransformsOptional& RetrievalMethodType::
  Transforms ()
  {
    return this->Transforms_;
  }

  void RetrievalMethodType::
  Transforms (const TransformsType& x)
  {
    this->Transforms_.set (x);
  }

  void RetrievalMethodType::
  Transforms (const TransformsOptional& x)
  {
    this->Transforms_ = x;
  }

  void RetrievalMethodType::
  Transforms (::std::auto_ptr< TransformsType > x)
  {
    this->Transforms_.set (x);
  }

  const RetrievalMethodType::URIOptional& RetrievalMethodType::
  URI () const
  {
    return this->URI_;
  }

  RetrievalMethodType::URIOptional& RetrievalMethodType::
  URI ()
  {
    return this->URI_;
  }

  void RetrievalMethodType::
  URI (const URIType& x)
  {
    this->URI_.set (x);
  }

  void RetrievalMethodType::
  URI (const URIOptional& x)
  {
    this->URI_ = x;
  }

  void RetrievalMethodType::
  URI (::std::auto_ptr< URIType > x)
  {
    this->URI_.set (x);
  }

  const RetrievalMethodType::TypeOptional& RetrievalMethodType::
  Type () const
  {
    return this->Type_;
  }

  RetrievalMethodType::TypeOptional& RetrievalMethodType::
  Type ()
  {
    return this->Type_;
  }

  void RetrievalMethodType::
  Type (const TypeType& x)
  {
    this->Type_.set (x);
  }

  void RetrievalMethodType::
  Type (const TypeOptional& x)
  {
    this->Type_ = x;
  }

  void RetrievalMethodType::
  Type (::std::auto_ptr< TypeType > x)
  {
    this->Type_.set (x);
  }


  // X509DataType
  // 

  const X509DataType::X509IssuerSerialSequence& X509DataType::
  X509IssuerSerial () const
  {
    return this->X509IssuerSerial_;
  }

  X509DataType::X509IssuerSerialSequence& X509DataType::
  X509IssuerSerial ()
  {
    return this->X509IssuerSerial_;
  }

  void X509DataType::
  X509IssuerSerial (const X509IssuerSerialSequence& s)
  {
    this->X509IssuerSerial_ = s;
  }

  const X509DataType::X509SKISequence& X509DataType::
  X509SKI () const
  {
    return this->X509SKI_;
  }

  X509DataType::X509SKISequence& X509DataType::
  X509SKI ()
  {
    return this->X509SKI_;
  }

  void X509DataType::
  X509SKI (const X509SKISequence& s)
  {
    this->X509SKI_ = s;
  }

  const X509DataType::X509SubjectNameSequence& X509DataType::
  X509SubjectName () const
  {
    return this->X509SubjectName_;
  }

  X509DataType::X509SubjectNameSequence& X509DataType::
  X509SubjectName ()
  {
    return this->X509SubjectName_;
  }

  void X509DataType::
  X509SubjectName (const X509SubjectNameSequence& s)
  {
    this->X509SubjectName_ = s;
  }

  const X509DataType::X509CertificateSequence& X509DataType::
  X509Certificate () const
  {
    return this->X509Certificate_;
  }

  X509DataType::X509CertificateSequence& X509DataType::
  X509Certificate ()
  {
    return this->X509Certificate_;
  }

  void X509DataType::
  X509Certificate (const X509CertificateSequence& s)
  {
    this->X509Certificate_ = s;
  }

  const X509DataType::X509CRLSequence& X509DataType::
  X509CRL () const
  {
    return this->X509CRL_;
  }

  X509DataType::X509CRLSequence& X509DataType::
  X509CRL ()
  {
    return this->X509CRL_;
  }

  void X509DataType::
  X509CRL (const X509CRLSequence& s)
  {
    this->X509CRL_ = s;
  }


  // X509IssuerSerialType
  // 

  const X509IssuerSerialType::X509IssuerNameType& X509IssuerSerialType::
  X509IssuerName () const
  {
    return this->X509IssuerName_.get ();
  }

  X509IssuerSerialType::X509IssuerNameType& X509IssuerSerialType::
  X509IssuerName ()
  {
    return this->X509IssuerName_.get ();
  }

  void X509IssuerSerialType::
  X509IssuerName (const X509IssuerNameType& x)
  {
    this->X509IssuerName_.set (x);
  }

  void X509IssuerSerialType::
  X509IssuerName (::std::auto_ptr< X509IssuerNameType > x)
  {
    this->X509IssuerName_.set (x);
  }

  const X509IssuerSerialType::X509SerialNumberType& X509IssuerSerialType::
  X509SerialNumber () const
  {
    return this->X509SerialNumber_.get ();
  }

  X509IssuerSerialType::X509SerialNumberType& X509IssuerSerialType::
  X509SerialNumber ()
  {
    return this->X509SerialNumber_.get ();
  }

  void X509IssuerSerialType::
  X509SerialNumber (const X509SerialNumberType& x)
  {
    this->X509SerialNumber_.set (x);
  }


  // PGPDataType
  // 

  const PGPDataType::PGPKeyIDOptional& PGPDataType::
  PGPKeyID () const
  {
    return this->PGPKeyID_;
  }

  PGPDataType::PGPKeyIDOptional& PGPDataType::
  PGPKeyID ()
  {
    return this->PGPKeyID_;
  }

  void PGPDataType::
  PGPKeyID (const PGPKeyIDType& x)
  {
    this->PGPKeyID_.set (x);
  }

  void PGPDataType::
  PGPKeyID (const PGPKeyIDOptional& x)
  {
    this->PGPKeyID_ = x;
  }

  void PGPDataType::
  PGPKeyID (::std::auto_ptr< PGPKeyIDType > x)
  {
    this->PGPKeyID_.set (x);
  }

  const PGPDataType::PGPKeyPacketOptional& PGPDataType::
  PGPKeyPacket () const
  {
    return this->PGPKeyPacket_;
  }

  PGPDataType::PGPKeyPacketOptional& PGPDataType::
  PGPKeyPacket ()
  {
    return this->PGPKeyPacket_;
  }

  void PGPDataType::
  PGPKeyPacket (const PGPKeyPacketType& x)
  {
    this->PGPKeyPacket_.set (x);
  }

  void PGPDataType::
  PGPKeyPacket (const PGPKeyPacketOptional& x)
  {
    this->PGPKeyPacket_ = x;
  }

  void PGPDataType::
  PGPKeyPacket (::std::auto_ptr< PGPKeyPacketType > x)
  {
    this->PGPKeyPacket_.set (x);
  }


  // SPKIDataType
  // 

  const SPKIDataType::SPKISexpSequence& SPKIDataType::
  SPKISexp () const
  {
    return this->SPKISexp_;
  }

  SPKIDataType::SPKISexpSequence& SPKIDataType::
  SPKISexp ()
  {
    return this->SPKISexp_;
  }

  void SPKIDataType::
  SPKISexp (const SPKISexpSequence& s)
  {
    this->SPKISexp_ = s;
  }


  // ObjectType
  // 

  const ObjectType::IdOptional& ObjectType::
  Id () const
  {
    return this->Id_;
  }

  ObjectType::IdOptional& ObjectType::
  Id ()
  {
    return this->Id_;
  }

  void ObjectType::
  Id (const IdType& x)
  {
    this->Id_.set (x);
  }

  void ObjectType::
  Id (const IdOptional& x)
  {
    this->Id_ = x;
  }

  void ObjectType::
  Id (::std::auto_ptr< IdType > x)
  {
    this->Id_.set (x);
  }

  const ObjectType::MimeTypeOptional& ObjectType::
  MimeType () const
  {
    return this->MimeType_;
  }

  ObjectType::MimeTypeOptional& ObjectType::
  MimeType ()
  {
    return this->MimeType_;
  }

  void ObjectType::
  MimeType (const MimeTypeType& x)
  {
    this->MimeType_.set (x);
  }

  void ObjectType::
  MimeType (const MimeTypeOptional& x)
  {
    this->MimeType_ = x;
  }

  void ObjectType::
  MimeType (::std::auto_ptr< MimeTypeType > x)
  {
    this->MimeType_.set (x);
  }

  const ObjectType::EncodingOptional& ObjectType::
  Encoding () const
  {
    return this->Encoding_;
  }

  ObjectType::EncodingOptional& ObjectType::
  Encoding ()
  {
    return this->Encoding_;
  }

  void ObjectType::
  Encoding (const EncodingType& x)
  {
    this->Encoding_.set (x);
  }

  void ObjectType::
  Encoding (const EncodingOptional& x)
  {
    this->Encoding_ = x;
  }

  void ObjectType::
  Encoding (::std::auto_ptr< EncodingType > x)
  {
    this->Encoding_.set (x);
  }


  // ManifestType
  // 

  const ManifestType::ReferenceSequence& ManifestType::
  Reference () const
  {
    return this->Reference_;
  }

  ManifestType::ReferenceSequence& ManifestType::
  Reference ()
  {
    return this->Reference_;
  }

  void ManifestType::
  Reference (const ReferenceSequence& s)
  {
    this->Reference_ = s;
  }

  const ManifestType::IdOptional& ManifestType::
  Id () const
  {
    return this->Id_;
  }

  ManifestType::IdOptional& ManifestType::
  Id ()
  {
    return this->Id_;
  }

  void ManifestType::
  Id (const IdType& x)
  {
    this->Id_.set (x);
  }

  void ManifestType::
  Id (const IdOptional& x)
  {
    this->Id_ = x;
  }

  void ManifestType::
  Id (::std::auto_ptr< IdType > x)
  {
    this->Id_.set (x);
  }


  // SignaturePropertiesType
  // 

  const SignaturePropertiesType::SignaturePropertySequence& SignaturePropertiesType::
  SignatureProperty () const
  {
    return this->SignatureProperty_;
  }

  SignaturePropertiesType::SignaturePropertySequence& SignaturePropertiesType::
  SignatureProperty ()
  {
    return this->SignatureProperty_;
  }

  void SignaturePropertiesType::
  SignatureProperty (const SignaturePropertySequence& s)
  {
    this->SignatureProperty_ = s;
  }

  const SignaturePropertiesType::IdOptional& SignaturePropertiesType::
  Id () const
  {
    return this->Id_;
  }

  SignaturePropertiesType::IdOptional& SignaturePropertiesType::
  Id ()
  {
    return this->Id_;
  }

  void SignaturePropertiesType::
  Id (const IdType& x)
  {
    this->Id_.set (x);
  }

  void SignaturePropertiesType::
  Id (const IdOptional& x)
  {
    this->Id_ = x;
  }

  void SignaturePropertiesType::
  Id (::std::auto_ptr< IdType > x)
  {
    this->Id_.set (x);
  }


  // SignaturePropertyType
  // 

  const SignaturePropertyType::TargetType& SignaturePropertyType::
  Target () const
  {
    return this->Target_.get ();
  }

  SignaturePropertyType::TargetType& SignaturePropertyType::
  Target ()
  {
    return this->Target_.get ();
  }

  void SignaturePropertyType::
  Target (const TargetType& x)
  {
    this->Target_.set (x);
  }

  void SignaturePropertyType::
  Target (::std::auto_ptr< TargetType > x)
  {
    this->Target_.set (x);
  }

  const SignaturePropertyType::IdOptional& SignaturePropertyType::
  Id () const
  {
    return this->Id_;
  }

  SignaturePropertyType::IdOptional& SignaturePropertyType::
  Id ()
  {
    return this->Id_;
  }

  void SignaturePropertyType::
  Id (const IdType& x)
  {
    this->Id_.set (x);
  }

  void SignaturePropertyType::
  Id (const IdOptional& x)
  {
    this->Id_ = x;
  }

  void SignaturePropertyType::
  Id (::std::auto_ptr< IdType > x)
  {
    this->Id_.set (x);
  }


  // HMACOutputLengthType
  // 


  // DSAKeyValueType
  // 

  const DSAKeyValueType::POptional& DSAKeyValueType::
  P () const
  {
    return this->P_;
  }

  DSAKeyValueType::POptional& DSAKeyValueType::
  P ()
  {
    return this->P_;
  }

  void DSAKeyValueType::
  P (const PType& x)
  {
    this->P_.set (x);
  }

  void DSAKeyValueType::
  P (const POptional& x)
  {
    this->P_ = x;
  }

  void DSAKeyValueType::
  P (::std::auto_ptr< PType > x)
  {
    this->P_.set (x);
  }

  const DSAKeyValueType::QOptional& DSAKeyValueType::
  Q () const
  {
    return this->Q_;
  }

  DSAKeyValueType::QOptional& DSAKeyValueType::
  Q ()
  {
    return this->Q_;
  }

  void DSAKeyValueType::
  Q (const QType& x)
  {
    this->Q_.set (x);
  }

  void DSAKeyValueType::
  Q (const QOptional& x)
  {
    this->Q_ = x;
  }

  void DSAKeyValueType::
  Q (::std::auto_ptr< QType > x)
  {
    this->Q_.set (x);
  }

  const DSAKeyValueType::GOptional& DSAKeyValueType::
  G () const
  {
    return this->G_;
  }

  DSAKeyValueType::GOptional& DSAKeyValueType::
  G ()
  {
    return this->G_;
  }

  void DSAKeyValueType::
  G (const GType& x)
  {
    this->G_.set (x);
  }

  void DSAKeyValueType::
  G (const GOptional& x)
  {
    this->G_ = x;
  }

  void DSAKeyValueType::
  G (::std::auto_ptr< GType > x)
  {
    this->G_.set (x);
  }

  const DSAKeyValueType::YType& DSAKeyValueType::
  Y () const
  {
    return this->Y_.get ();
  }

  DSAKeyValueType::YType& DSAKeyValueType::
  Y ()
  {
    return this->Y_.get ();
  }

  void DSAKeyValueType::
  Y (const YType& x)
  {
    this->Y_.set (x);
  }

  void DSAKeyValueType::
  Y (::std::auto_ptr< YType > x)
  {
    this->Y_.set (x);
  }

  const DSAKeyValueType::JOptional& DSAKeyValueType::
  J () const
  {
    return this->J_;
  }

  DSAKeyValueType::JOptional& DSAKeyValueType::
  J ()
  {
    return this->J_;
  }

  void DSAKeyValueType::
  J (const JType& x)
  {
    this->J_.set (x);
  }

  void DSAKeyValueType::
  J (const JOptional& x)
  {
    this->J_ = x;
  }

  void DSAKeyValueType::
  J (::std::auto_ptr< JType > x)
  {
    this->J_.set (x);
  }

  const DSAKeyValueType::SeedOptional& DSAKeyValueType::
  Seed () const
  {
    return this->Seed_;
  }

  DSAKeyValueType::SeedOptional& DSAKeyValueType::
  Seed ()
  {
    return this->Seed_;
  }

  void DSAKeyValueType::
  Seed (const SeedType& x)
  {
    this->Seed_.set (x);
  }

  void DSAKeyValueType::
  Seed (const SeedOptional& x)
  {
    this->Seed_ = x;
  }

  void DSAKeyValueType::
  Seed (::std::auto_ptr< SeedType > x)
  {
    this->Seed_.set (x);
  }

  const DSAKeyValueType::PgenCounterOptional& DSAKeyValueType::
  PgenCounter () const
  {
    return this->PgenCounter_;
  }

  DSAKeyValueType::PgenCounterOptional& DSAKeyValueType::
  PgenCounter ()
  {
    return this->PgenCounter_;
  }

  void DSAKeyValueType::
  PgenCounter (const PgenCounterType& x)
  {
    this->PgenCounter_.set (x);
  }

  void DSAKeyValueType::
  PgenCounter (const PgenCounterOptional& x)
  {
    this->PgenCounter_ = x;
  }

  void DSAKeyValueType::
  PgenCounter (::std::auto_ptr< PgenCounterType > x)
  {
    this->PgenCounter_.set (x);
  }


  // RSAKeyValueType
  // 

  const RSAKeyValueType::ModulusType& RSAKeyValueType::
  Modulus () const
  {
    return this->Modulus_.get ();
  }

  RSAKeyValueType::ModulusType& RSAKeyValueType::
  Modulus ()
  {
    return this->Modulus_.get ();
  }

  void RSAKeyValueType::
  Modulus (const ModulusType& x)
  {
    this->Modulus_.set (x);
  }

  void RSAKeyValueType::
  Modulus (::std::auto_ptr< ModulusType > x)
  {
    this->Modulus_.set (x);
  }

  const RSAKeyValueType::ExponentType& RSAKeyValueType::
  Exponent () const
  {
    return this->Exponent_.get ();
  }

  RSAKeyValueType::ExponentType& RSAKeyValueType::
  Exponent ()
  {
    return this->Exponent_.get ();
  }

  void RSAKeyValueType::
  Exponent (const ExponentType& x)
  {
    this->Exponent_.set (x);
  }

  void RSAKeyValueType::
  Exponent (::std::auto_ptr< ExponentType > x)
  {
    this->Exponent_.set (x);
  }
}

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

namespace xmldsig
{
  // CryptoBinary
  //

  CryptoBinary::
  CryptoBinary ()
  : ::xml_schema::Base64Binary ()
  {
  }

  CryptoBinary::
  CryptoBinary (const ::xml_schema::Base64Binary& _xsd_Base64Binary_base)
  : ::xml_schema::Base64Binary (_xsd_Base64Binary_base)
  {
  }

  CryptoBinary::
  CryptoBinary (const CryptoBinary& x,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (x, f, c)
  {
  }

  CryptoBinary::
  CryptoBinary (const ::DOMElement& e,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (e, f, c)
  {
  }

  CryptoBinary::
  CryptoBinary (const ::DOMAttr& a,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (a, f, c)
  {
  }

  CryptoBinary::
  CryptoBinary (const ::std::string& s,
                const ::DOMElement* e,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (s, e, f, c)
  {
  }

  CryptoBinary* CryptoBinary::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class CryptoBinary (*this, f, c);
  }

  CryptoBinary::
  ~CryptoBinary ()
  {
  }

  // SignatureType
  //

  SignatureType::
  SignatureType (const SignedInfoType& SignedInfo,
                 const SignatureValueType& SignatureValue)
  : ::xml_schema::Type (),
    SignedInfo_ (SignedInfo, ::xml_schema::Flags (), this),
    SignatureValue_ (SignatureValue, ::xml_schema::Flags (), this),
    KeyInfo_ (::xml_schema::Flags (), this),
    Object_ (::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  SignatureType::
  SignatureType (::std::auto_ptr< SignedInfoType >& SignedInfo,
                 ::std::auto_ptr< SignatureValueType >& SignatureValue)
  : ::xml_schema::Type (),
    SignedInfo_ (SignedInfo, ::xml_schema::Flags (), this),
    SignatureValue_ (SignatureValue, ::xml_schema::Flags (), this),
    KeyInfo_ (::xml_schema::Flags (), this),
    Object_ (::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  SignatureType::
  SignatureType (const SignatureType& x,
                 ::xml_schema::Flags f,
                 ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    SignedInfo_ (x.SignedInfo_, f, this),
    SignatureValue_ (x.SignatureValue_, f, this),
    KeyInfo_ (x.KeyInfo_, f, this),
    Object_ (x.Object_, f, this),
    Id_ (x.Id_, f, this)
  {
  }

  SignatureType::
  SignatureType (const ::DOMElement& e,
                 ::xml_schema::Flags f,
                 ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    SignedInfo_ (f, this),
    SignatureValue_ (f, this),
    KeyInfo_ (f, this),
    Object_ (f, this),
    Id_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // SignedInfo
      //
      if (n.name () == "SignedInfo" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< SignedInfoType > r (
          SignedInfoTraits::create (i, f, this));

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

      // SignatureValue
      //
      if (n.name () == "SignatureValue" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< SignatureValueType > r (
          SignatureValueTraits::create (i, f, this));

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

      // KeyInfo
      //
      if (n.name () == "KeyInfo" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< KeyInfoType > r (
          KeyInfoTraits::create (i, f, this));

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

      // Object
      //
      if (n.name () == "Object" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< ObjectType > r (
          ObjectTraits::create (i, f, this));

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

      break;
    }

    if (!SignedInfo_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "SignedInfo",
        "http://www.w3.org/2000/09/xmldsig#");
    }

    if (!SignatureValue_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "SignatureValue",
        "http://www.w3.org/2000/09/xmldsig#");
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Id" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< IdType > r (
          IdTraits::create (i, f, this));

        this->Id_.set (r);
        continue;
      }
    }
  }

  SignatureType* SignatureType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class SignatureType (*this, f, c);
  }

  SignatureType::
  ~SignatureType ()
  {
  }

  // SignatureValueType
  //

  SignatureValueType::
  SignatureValueType ()
  : ::xml_schema::Base64Binary (),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  SignatureValueType::
  SignatureValueType (const ::xml_schema::Base64Binary& _xsd_Base64Binary_base)
  : ::xml_schema::Base64Binary (_xsd_Base64Binary_base),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  SignatureValueType::
  SignatureValueType (const SignatureValueType& x,
                      ::xml_schema::Flags f,
                      ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (x, f, c),
    Id_ (x.Id_, f, this)
  {
  }

  SignatureValueType::
  SignatureValueType (const ::DOMElement& e,
                      ::xml_schema::Flags f,
                      ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (e, f | ::xml_schema::Flags::base, c),
    Id_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, false, true);
      this->parse (p, f);
    }
  }

  void SignatureValueType::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::Flags f)
  {
    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Id" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< IdType > r (
          IdTraits::create (i, f, this));

        this->Id_.set (r);
        continue;
      }
    }
  }

  SignatureValueType* SignatureValueType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class SignatureValueType (*this, f, c);
  }

  SignatureValueType::
  ~SignatureValueType ()
  {
  }

  // SignedInfoType
  //

  SignedInfoType::
  SignedInfoType (const CanonicalizationMethodType& CanonicalizationMethod,
                  const SignatureMethodType& SignatureMethod)
  : ::xml_schema::Type (),
    CanonicalizationMethod_ (CanonicalizationMethod, ::xml_schema::Flags (), this),
    SignatureMethod_ (SignatureMethod, ::xml_schema::Flags (), this),
    Reference_ (::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  SignedInfoType::
  SignedInfoType (::std::auto_ptr< CanonicalizationMethodType >& CanonicalizationMethod,
                  ::std::auto_ptr< SignatureMethodType >& SignatureMethod)
  : ::xml_schema::Type (),
    CanonicalizationMethod_ (CanonicalizationMethod, ::xml_schema::Flags (), this),
    SignatureMethod_ (SignatureMethod, ::xml_schema::Flags (), this),
    Reference_ (::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  SignedInfoType::
  SignedInfoType (const SignedInfoType& x,
                  ::xml_schema::Flags f,
                  ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    CanonicalizationMethod_ (x.CanonicalizationMethod_, f, this),
    SignatureMethod_ (x.SignatureMethod_, f, this),
    Reference_ (x.Reference_, f, this),
    Id_ (x.Id_, f, this)
  {
  }

  SignedInfoType::
  SignedInfoType (const ::DOMElement& e,
                  ::xml_schema::Flags f,
                  ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    CanonicalizationMethod_ (f, this),
    SignatureMethod_ (f, this),
    Reference_ (f, this),
    Id_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // CanonicalizationMethod
      //
      if (n.name () == "CanonicalizationMethod" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< CanonicalizationMethodType > r (
          CanonicalizationMethodTraits::create (i, f, this));

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

      // SignatureMethod
      //
      if (n.name () == "SignatureMethod" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< SignatureMethodType > r (
          SignatureMethodTraits::create (i, f, this));

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

      // Reference
      //
      if (n.name () == "Reference" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< ReferenceType > r (
          ReferenceTraits::create (i, f, this));

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

      break;
    }

    if (!CanonicalizationMethod_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "CanonicalizationMethod",
        "http://www.w3.org/2000/09/xmldsig#");
    }

    if (!SignatureMethod_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "SignatureMethod",
        "http://www.w3.org/2000/09/xmldsig#");
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Id" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< IdType > r (
          IdTraits::create (i, f, this));

        this->Id_.set (r);
        continue;
      }
    }
  }

  SignedInfoType* SignedInfoType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class SignedInfoType (*this, f, c);
  }

  SignedInfoType::
  ~SignedInfoType ()
  {
  }

  // CanonicalizationMethodType
  //

  CanonicalizationMethodType::
  CanonicalizationMethodType (const AlgorithmType& Algorithm)
  : ::xml_schema::Type (),
    Algorithm_ (Algorithm, ::xml_schema::Flags (), this)
  {
  }

  CanonicalizationMethodType::
  CanonicalizationMethodType (const CanonicalizationMethodType& x,
                              ::xml_schema::Flags f,
                              ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    Algorithm_ (x.Algorithm_, f, this)
  {
  }

  CanonicalizationMethodType::
  CanonicalizationMethodType (const ::DOMElement& e,
                              ::xml_schema::Flags f,
                              ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    Algorithm_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Algorithm" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< AlgorithmType > r (
          AlgorithmTraits::create (i, f, this));

        this->Algorithm_.set (r);
        continue;
      }
    }

    if (!Algorithm_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "Algorithm",
        "");
    }
  }

  CanonicalizationMethodType* CanonicalizationMethodType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class CanonicalizationMethodType (*this, f, c);
  }

  CanonicalizationMethodType::
  ~CanonicalizationMethodType ()
  {
  }

  // SignatureMethodType
  //

  SignatureMethodType::
  SignatureMethodType (const AlgorithmType& Algorithm)
  : ::xml_schema::Type (),
    HMACOutputLength_ (::xml_schema::Flags (), this),
    Algorithm_ (Algorithm, ::xml_schema::Flags (), this)
  {
  }

  SignatureMethodType::
  SignatureMethodType (const SignatureMethodType& x,
                       ::xml_schema::Flags f,
                       ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    HMACOutputLength_ (x.HMACOutputLength_, f, this),
    Algorithm_ (x.Algorithm_, f, this)
  {
  }

  SignatureMethodType::
  SignatureMethodType (const ::DOMElement& e,
                       ::xml_schema::Flags f,
                       ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    HMACOutputLength_ (f, this),
    Algorithm_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // HMACOutputLength
      //
      if (n.name () == "HMACOutputLength" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< HMACOutputLengthType > r (
          HMACOutputLengthTraits::create (i, f, this));

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Algorithm" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< AlgorithmType > r (
          AlgorithmTraits::create (i, f, this));

        this->Algorithm_.set (r);
        continue;
      }
    }

    if (!Algorithm_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "Algorithm",
        "");
    }
  }

  SignatureMethodType* SignatureMethodType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class SignatureMethodType (*this, f, c);
  }

  SignatureMethodType::
  ~SignatureMethodType ()
  {
  }

  // ReferenceType
  //

  ReferenceType::
  ReferenceType (const DigestMethodType& DigestMethod,
                 const DigestValueType& DigestValue)
  : ::xml_schema::Type (),
    Transforms_ (::xml_schema::Flags (), this),
    DigestMethod_ (DigestMethod, ::xml_schema::Flags (), this),
    DigestValue_ (DigestValue, ::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this),
    URI_ (::xml_schema::Flags (), this),
    Type_ (::xml_schema::Flags (), this)
  {
  }

  ReferenceType::
  ReferenceType (::std::auto_ptr< DigestMethodType >& DigestMethod,
                 const DigestValueType& DigestValue)
  : ::xml_schema::Type (),
    Transforms_ (::xml_schema::Flags (), this),
    DigestMethod_ (DigestMethod, ::xml_schema::Flags (), this),
    DigestValue_ (DigestValue, ::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this),
    URI_ (::xml_schema::Flags (), this),
    Type_ (::xml_schema::Flags (), this)
  {
  }

  ReferenceType::
  ReferenceType (const ReferenceType& x,
                 ::xml_schema::Flags f,
                 ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    Transforms_ (x.Transforms_, f, this),
    DigestMethod_ (x.DigestMethod_, f, this),
    DigestValue_ (x.DigestValue_, f, this),
    Id_ (x.Id_, f, this),
    URI_ (x.URI_, f, this),
    Type_ (x.Type_, f, this)
  {
  }

  ReferenceType::
  ReferenceType (const ::DOMElement& e,
                 ::xml_schema::Flags f,
                 ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    Transforms_ (f, this),
    DigestMethod_ (f, this),
    DigestValue_ (f, this),
    Id_ (f, this),
    URI_ (f, this),
    Type_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // Transforms
      //
      if (n.name () == "Transforms" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< TransformsType > r (
          TransformsTraits::create (i, f, this));

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

      // DigestMethod
      //
      if (n.name () == "DigestMethod" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< DigestMethodType > r (
          DigestMethodTraits::create (i, f, this));

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

      // DigestValue
      //
      if (n.name () == "DigestValue" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< DigestValueType > r (
          DigestValueTraits::create (i, f, this));

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

      break;
    }

    if (!DigestMethod_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "DigestMethod",
        "http://www.w3.org/2000/09/xmldsig#");
    }

    if (!DigestValue_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "DigestValue",
        "http://www.w3.org/2000/09/xmldsig#");
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Id" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< IdType > r (
          IdTraits::create (i, f, this));

        this->Id_.set (r);
        continue;
      }

      if (n.name () == "URI" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< URIType > r (
          URITraits::create (i, f, this));

        this->URI_.set (r);
        continue;
      }

      if (n.name () == "Type" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< TypeType > r (
          TypeTraits::create (i, f, this));

        this->Type_.set (r);
        continue;
      }
    }
  }

  ReferenceType* ReferenceType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class ReferenceType (*this, f, c);
  }

  ReferenceType::
  ~ReferenceType ()
  {
  }

  // TransformsType
  //

  TransformsType::
  TransformsType ()
  : ::xml_schema::Type (),
    Transform_ (::xml_schema::Flags (), this)
  {
  }

  TransformsType::
  TransformsType (const TransformsType& x,
                  ::xml_schema::Flags f,
                  ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    Transform_ (x.Transform_, f, this)
  {
  }

  TransformsType::
  TransformsType (const ::DOMElement& e,
                  ::xml_schema::Flags f,
                  ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    Transform_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
      this->parse (p, f);
    }
  }

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

      // Transform
      //
      if (n.name () == "Transform" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< TransformType > r (
          TransformTraits::create (i, f, this));

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

      break;
    }
  }

  TransformsType* TransformsType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class TransformsType (*this, f, c);
  }

  TransformsType::
  ~TransformsType ()
  {
  }

  // TransformType
  //

  TransformType::
  TransformType (const AlgorithmType& Algorithm)
  : ::xml_schema::Type (),
    XPath_ (::xml_schema::Flags (), this),
    Algorithm_ (Algorithm, ::xml_schema::Flags (), this)
  {
  }

  TransformType::
  TransformType (const TransformType& x,
                 ::xml_schema::Flags f,
                 ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    XPath_ (x.XPath_, f, this),
    Algorithm_ (x.Algorithm_, f, this)
  {
  }

  TransformType::
  TransformType (const ::DOMElement& e,
                 ::xml_schema::Flags f,
                 ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    XPath_ (f, this),
    Algorithm_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // XPath
      //
      if (n.name () == "XPath" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< XPathType > r (
          XPathTraits::create (i, f, this));

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Algorithm" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< AlgorithmType > r (
          AlgorithmTraits::create (i, f, this));

        this->Algorithm_.set (r);
        continue;
      }
    }

    if (!Algorithm_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "Algorithm",
        "");
    }
  }

  TransformType* TransformType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class TransformType (*this, f, c);
  }

  TransformType::
  ~TransformType ()
  {
  }

  // DigestMethodType
  //

  DigestMethodType::
  DigestMethodType (const AlgorithmType& Algorithm)
  : ::xml_schema::Type (),
    Algorithm_ (Algorithm, ::xml_schema::Flags (), this)
  {
  }

  DigestMethodType::
  DigestMethodType (const DigestMethodType& x,
                    ::xml_schema::Flags f,
                    ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    Algorithm_ (x.Algorithm_, f, this)
  {
  }

  DigestMethodType::
  DigestMethodType (const ::DOMElement& e,
                    ::xml_schema::Flags f,
                    ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    Algorithm_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Algorithm" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< AlgorithmType > r (
          AlgorithmTraits::create (i, f, this));

        this->Algorithm_.set (r);
        continue;
      }
    }

    if (!Algorithm_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "Algorithm",
        "");
    }
  }

  DigestMethodType* DigestMethodType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class DigestMethodType (*this, f, c);
  }

  DigestMethodType::
  ~DigestMethodType ()
  {
  }

  // DigestValueType
  //

  DigestValueType::
  DigestValueType ()
  : ::xml_schema::Base64Binary ()
  {
  }

  DigestValueType::
  DigestValueType (const ::xml_schema::Base64Binary& _xsd_Base64Binary_base)
  : ::xml_schema::Base64Binary (_xsd_Base64Binary_base)
  {
  }

  DigestValueType::
  DigestValueType (const DigestValueType& x,
                   ::xml_schema::Flags f,
                   ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (x, f, c)
  {
  }

  DigestValueType::
  DigestValueType (const ::DOMElement& e,
                   ::xml_schema::Flags f,
                   ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (e, f, c)
  {
  }

  DigestValueType::
  DigestValueType (const ::DOMAttr& a,
                   ::xml_schema::Flags f,
                   ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (a, f, c)
  {
  }

  DigestValueType::
  DigestValueType (const ::std::string& s,
                   const ::DOMElement* e,
                   ::xml_schema::Flags f,
                   ::xml_schema::Container* c)
  : ::xml_schema::Base64Binary (s, e, f, c)
  {
  }

  DigestValueType* DigestValueType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class DigestValueType (*this, f, c);
  }

  DigestValueType::
  ~DigestValueType ()
  {
  }

  // KeyInfoType
  //

  KeyInfoType::
  KeyInfoType ()
  : ::xml_schema::Type (),
    KeyName_ (::xml_schema::Flags (), this),
    KeyValue_ (::xml_schema::Flags (), this),
    RetrievalMethod_ (::xml_schema::Flags (), this),
    X509Data_ (::xml_schema::Flags (), this),
    PGPData_ (::xml_schema::Flags (), this),
    SPKIData_ (::xml_schema::Flags (), this),
    MgmtData_ (::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  KeyInfoType::
  KeyInfoType (const KeyInfoType& x,
               ::xml_schema::Flags f,
               ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    KeyName_ (x.KeyName_, f, this),
    KeyValue_ (x.KeyValue_, f, this),
    RetrievalMethod_ (x.RetrievalMethod_, f, this),
    X509Data_ (x.X509Data_, f, this),
    PGPData_ (x.PGPData_, f, this),
    SPKIData_ (x.SPKIData_, f, this),
    MgmtData_ (x.MgmtData_, f, this),
    Id_ (x.Id_, f, this)
  {
  }

  KeyInfoType::
  KeyInfoType (const ::DOMElement& e,
               ::xml_schema::Flags f,
               ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    KeyName_ (f, this),
    KeyValue_ (f, this),
    RetrievalMethod_ (f, this),
    X509Data_ (f, this),
    PGPData_ (f, this),
    SPKIData_ (f, this),
    MgmtData_ (f, this),
    Id_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // KeyName
      //
      if (n.name () == "KeyName" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< KeyNameType > r (
          KeyNameTraits::create (i, f, this));

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

      // KeyValue
      //
      if (n.name () == "KeyValue" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< KeyValueType > r (
          KeyValueTraits::create (i, f, this));

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

      // RetrievalMethod
      //
      if (n.name () == "RetrievalMethod" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< RetrievalMethodType > r (
          RetrievalMethodTraits::create (i, f, this));

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

      // X509Data
      //
      if (n.name () == "X509Data" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< X509DataType > r (
          X509DataTraits::create (i, f, this));

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

      // PGPData
      //
      if (n.name () == "PGPData" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< PGPDataType > r (
          PGPDataTraits::create (i, f, this));

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

      // SPKIData
      //
      if (n.name () == "SPKIData" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< SPKIDataType > r (
          SPKIDataTraits::create (i, f, this));

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

      // MgmtData
      //
      if (n.name () == "MgmtData" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< MgmtDataType > r (
          MgmtDataTraits::create (i, f, this));

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Id" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< IdType > r (
          IdTraits::create (i, f, this));

        this->Id_.set (r);
        continue;
      }
    }
  }

  KeyInfoType* KeyInfoType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class KeyInfoType (*this, f, c);
  }

  KeyInfoType::
  ~KeyInfoType ()
  {
  }

  // KeyValueType
  //

  KeyValueType::
  KeyValueType ()
  : ::xml_schema::Type (),
    DSAKeyValue_ (::xml_schema::Flags (), this),
    RSAKeyValue_ (::xml_schema::Flags (), this)
  {
  }

  KeyValueType::
  KeyValueType (const KeyValueType& x,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    DSAKeyValue_ (x.DSAKeyValue_, f, this),
    RSAKeyValue_ (x.RSAKeyValue_, f, this)
  {
  }

  KeyValueType::
  KeyValueType (const ::DOMElement& e,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    DSAKeyValue_ (f, this),
    RSAKeyValue_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
      this->parse (p, f);
    }
  }

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

      // DSAKeyValue
      //
      if (n.name () == "DSAKeyValue" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< DSAKeyValueType > r (
          DSAKeyValueTraits::create (i, f, this));

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

      // RSAKeyValue
      //
      if (n.name () == "RSAKeyValue" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< RSAKeyValueType > r (
          RSAKeyValueTraits::create (i, f, this));

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

      break;
    }
  }

  KeyValueType* KeyValueType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class KeyValueType (*this, f, c);
  }

  KeyValueType::
  ~KeyValueType ()
  {
  }

  // RetrievalMethodType
  //

  RetrievalMethodType::
  RetrievalMethodType ()
  : ::xml_schema::Type (),
    Transforms_ (::xml_schema::Flags (), this),
    URI_ (::xml_schema::Flags (), this),
    Type_ (::xml_schema::Flags (), this)
  {
  }

  RetrievalMethodType::
  RetrievalMethodType (const RetrievalMethodType& x,
                       ::xml_schema::Flags f,
                       ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    Transforms_ (x.Transforms_, f, this),
    URI_ (x.URI_, f, this),
    Type_ (x.Type_, f, this)
  {
  }

  RetrievalMethodType::
  RetrievalMethodType (const ::DOMElement& e,
                       ::xml_schema::Flags f,
                       ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    Transforms_ (f, this),
    URI_ (f, this),
    Type_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // Transforms
      //
      if (n.name () == "Transforms" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< TransformsType > r (
          TransformsTraits::create (i, f, this));

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "URI" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< URIType > r (
          URITraits::create (i, f, this));

        this->URI_.set (r);
        continue;
      }

      if (n.name () == "Type" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< TypeType > r (
          TypeTraits::create (i, f, this));

        this->Type_.set (r);
        continue;
      }
    }
  }

  RetrievalMethodType* RetrievalMethodType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class RetrievalMethodType (*this, f, c);
  }

  RetrievalMethodType::
  ~RetrievalMethodType ()
  {
  }

  // X509DataType
  //

  X509DataType::
  X509DataType ()
  : ::xml_schema::Type (),
    X509IssuerSerial_ (::xml_schema::Flags (), this),
    X509SKI_ (::xml_schema::Flags (), this),
    X509SubjectName_ (::xml_schema::Flags (), this),
    X509Certificate_ (::xml_schema::Flags (), this),
    X509CRL_ (::xml_schema::Flags (), this)
  {
  }

  X509DataType::
  X509DataType (const X509DataType& x,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    X509IssuerSerial_ (x.X509IssuerSerial_, f, this),
    X509SKI_ (x.X509SKI_, f, this),
    X509SubjectName_ (x.X509SubjectName_, f, this),
    X509Certificate_ (x.X509Certificate_, f, this),
    X509CRL_ (x.X509CRL_, f, this)
  {
  }

  X509DataType::
  X509DataType (const ::DOMElement& e,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    X509IssuerSerial_ (f, this),
    X509SKI_ (f, this),
    X509SubjectName_ (f, this),
    X509Certificate_ (f, this),
    X509CRL_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
      this->parse (p, f);
    }
  }

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

      // X509IssuerSerial
      //
      if (n.name () == "X509IssuerSerial" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< X509IssuerSerialType > r (
          X509IssuerSerialTraits::create (i, f, this));

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

      // X509SKI
      //
      if (n.name () == "X509SKI" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< X509SKIType > r (
          X509SKITraits::create (i, f, this));

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

      // X509SubjectName
      //
      if (n.name () == "X509SubjectName" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< X509SubjectNameType > r (
          X509SubjectNameTraits::create (i, f, this));

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

      // X509Certificate
      //
      if (n.name () == "X509Certificate" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< X509CertificateType > r (
          X509CertificateTraits::create (i, f, this));

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

      // X509CRL
      //
      if (n.name () == "X509CRL" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< X509CRLType > r (
          X509CRLTraits::create (i, f, this));

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

      break;
    }
  }

  X509DataType* X509DataType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class X509DataType (*this, f, c);
  }

  X509DataType::
  ~X509DataType ()
  {
  }

  // X509IssuerSerialType
  //

  X509IssuerSerialType::
  X509IssuerSerialType (const X509IssuerNameType& X509IssuerName,
                        const X509SerialNumberType& X509SerialNumber)
  : ::xml_schema::Type (),
    X509IssuerName_ (X509IssuerName, ::xml_schema::Flags (), this),
    X509SerialNumber_ (X509SerialNumber, ::xml_schema::Flags (), this)
  {
  }

  X509IssuerSerialType::
  X509IssuerSerialType (const X509IssuerSerialType& x,
                        ::xml_schema::Flags f,
                        ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    X509IssuerName_ (x.X509IssuerName_, f, this),
    X509SerialNumber_ (x.X509SerialNumber_, f, this)
  {
  }

  X509IssuerSerialType::
  X509IssuerSerialType (const ::DOMElement& e,
                        ::xml_schema::Flags f,
                        ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    X509IssuerName_ (f, this),
    X509SerialNumber_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
      this->parse (p, f);
    }
  }

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

      // X509IssuerName
      //
      if (n.name () == "X509IssuerName" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< X509IssuerNameType > r (
          X509IssuerNameTraits::create (i, f, this));

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

      // X509SerialNumber
      //
      if (n.name () == "X509SerialNumber" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        if (!X509SerialNumber_.present ())
        {
          this->X509SerialNumber_.set (X509SerialNumberTraits::create (i, f, this));
          continue;
        }
      }

      break;
    }

    if (!X509IssuerName_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "X509IssuerName",
        "http://www.w3.org/2000/09/xmldsig#");
    }

    if (!X509SerialNumber_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "X509SerialNumber",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  X509IssuerSerialType* X509IssuerSerialType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class X509IssuerSerialType (*this, f, c);
  }

  X509IssuerSerialType::
  ~X509IssuerSerialType ()
  {
  }

  // PGPDataType
  //

  PGPDataType::
  PGPDataType ()
  : ::xml_schema::Type (),
    PGPKeyID_ (::xml_schema::Flags (), this),
    PGPKeyPacket_ (::xml_schema::Flags (), this)
  {
  }

  PGPDataType::
  PGPDataType (const PGPDataType& x,
               ::xml_schema::Flags f,
               ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    PGPKeyID_ (x.PGPKeyID_, f, this),
    PGPKeyPacket_ (x.PGPKeyPacket_, f, this)
  {
  }

  PGPDataType::
  PGPDataType (const ::DOMElement& e,
               ::xml_schema::Flags f,
               ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    PGPKeyID_ (f, this),
    PGPKeyPacket_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
      this->parse (p, f);
    }
  }

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

      // PGPKeyID
      //
      if (n.name () == "PGPKeyID" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< PGPKeyIDType > r (
          PGPKeyIDTraits::create (i, f, this));

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

      // PGPKeyPacket
      //
      if (n.name () == "PGPKeyPacket" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< PGPKeyPacketType > r (
          PGPKeyPacketTraits::create (i, f, this));

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

      break;
    }
  }

  PGPDataType* PGPDataType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class PGPDataType (*this, f, c);
  }

  PGPDataType::
  ~PGPDataType ()
  {
  }

  // SPKIDataType
  //

  SPKIDataType::
  SPKIDataType ()
  : ::xml_schema::Type (),
    SPKISexp_ (::xml_schema::Flags (), this)
  {
  }

  SPKIDataType::
  SPKIDataType (const SPKIDataType& x,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    SPKISexp_ (x.SPKISexp_, f, this)
  {
  }

  SPKIDataType::
  SPKIDataType (const ::DOMElement& e,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    SPKISexp_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
      this->parse (p, f);
    }
  }

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

      // SPKISexp
      //
      if (n.name () == "SPKISexp" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< SPKISexpType > r (
          SPKISexpTraits::create (i, f, this));

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

      break;
    }
  }

  SPKIDataType* SPKIDataType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class SPKIDataType (*this, f, c);
  }

  SPKIDataType::
  ~SPKIDataType ()
  {
  }

  // ObjectType
  //

  ObjectType::
  ObjectType ()
  : ::xml_schema::Type (),
    Id_ (::xml_schema::Flags (), this),
    MimeType_ (::xml_schema::Flags (), this),
    Encoding_ (::xml_schema::Flags (), this)
  {
  }

  ObjectType::
  ObjectType (const ObjectType& x,
              ::xml_schema::Flags f,
              ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    Id_ (x.Id_, f, this),
    MimeType_ (x.MimeType_, f, this),
    Encoding_ (x.Encoding_, f, this)
  {
  }

  ObjectType::
  ObjectType (const ::DOMElement& e,
              ::xml_schema::Flags f,
              ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    Id_ (f, this),
    MimeType_ (f, this),
    Encoding_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Id" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< IdType > r (
          IdTraits::create (i, f, this));

        this->Id_.set (r);
        continue;
      }

      if (n.name () == "MimeType" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< MimeTypeType > r (
          MimeTypeTraits::create (i, f, this));

        this->MimeType_.set (r);
        continue;
      }

      if (n.name () == "Encoding" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< EncodingType > r (
          EncodingTraits::create (i, f, this));

        this->Encoding_.set (r);
        continue;
      }
    }
  }

  ObjectType* ObjectType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class ObjectType (*this, f, c);
  }

  ObjectType::
  ~ObjectType ()
  {
  }

  // ManifestType
  //

  ManifestType::
  ManifestType ()
  : ::xml_schema::Type (),
    Reference_ (::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  ManifestType::
  ManifestType (const ManifestType& x,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    Reference_ (x.Reference_, f, this),
    Id_ (x.Id_, f, this)
  {
  }

  ManifestType::
  ManifestType (const ::DOMElement& e,
                ::xml_schema::Flags f,
                ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    Reference_ (f, this),
    Id_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // Reference
      //
      if (n.name () == "Reference" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< ReferenceType > r (
          ReferenceTraits::create (i, f, this));

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Id" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< IdType > r (
          IdTraits::create (i, f, this));

        this->Id_.set (r);
        continue;
      }
    }
  }

  ManifestType* ManifestType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class ManifestType (*this, f, c);
  }

  ManifestType::
  ~ManifestType ()
  {
  }

  // SignaturePropertiesType
  //

  SignaturePropertiesType::
  SignaturePropertiesType ()
  : ::xml_schema::Type (),
    SignatureProperty_ (::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  SignaturePropertiesType::
  SignaturePropertiesType (const SignaturePropertiesType& x,
                           ::xml_schema::Flags f,
                           ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    SignatureProperty_ (x.SignatureProperty_, f, this),
    Id_ (x.Id_, f, this)
  {
  }

  SignaturePropertiesType::
  SignaturePropertiesType (const ::DOMElement& e,
                           ::xml_schema::Flags f,
                           ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    SignatureProperty_ (f, this),
    Id_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      // SignatureProperty
      //
      if (n.name () == "SignatureProperty" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< SignaturePropertyType > r (
          SignaturePropertyTraits::create (i, f, this));

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Id" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< IdType > r (
          IdTraits::create (i, f, this));

        this->Id_.set (r);
        continue;
      }
    }
  }

  SignaturePropertiesType* SignaturePropertiesType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class SignaturePropertiesType (*this, f, c);
  }

  SignaturePropertiesType::
  ~SignaturePropertiesType ()
  {
  }

  // SignaturePropertyType
  //

  SignaturePropertyType::
  SignaturePropertyType (const TargetType& Target)
  : ::xml_schema::Type (),
    Target_ (Target, ::xml_schema::Flags (), this),
    Id_ (::xml_schema::Flags (), this)
  {
  }

  SignaturePropertyType::
  SignaturePropertyType (const SignaturePropertyType& x,
                         ::xml_schema::Flags f,
                         ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    Target_ (x.Target_, f, this),
    Id_ (x.Id_, f, this)
  {
  }

  SignaturePropertyType::
  SignaturePropertyType (const ::DOMElement& e,
                         ::xml_schema::Flags f,
                         ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    Target_ (f, this),
    Id_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, true);
      this->parse (p, f);
    }
  }

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

      break;
    }

    while (p.more_attributes ())
    {
      const ::DOMAttr& i (p.next_attribute ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      if (n.name () == "Target" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< TargetType > r (
          TargetTraits::create (i, f, this));

        this->Target_.set (r);
        continue;
      }

      if (n.name () == "Id" && n.namespace_ ().empty ())
      {
        ::std::auto_ptr< IdType > r (
          IdTraits::create (i, f, this));

        this->Id_.set (r);
        continue;
      }
    }

    if (!Target_.present ())
    {
      throw ::xsd::cxx::tree::expected_attribute< char > (
        "Target",
        "");
    }
  }

  SignaturePropertyType* SignaturePropertyType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class SignaturePropertyType (*this, f, c);
  }

  SignaturePropertyType::
  ~SignaturePropertyType ()
  {
  }

  // HMACOutputLengthType
  //

  HMACOutputLengthType::
  HMACOutputLengthType (const ::xml_schema::Integer& _xsd_Integer_base)
  : ::xsd::cxx::tree::fundamental_base< ::xml_schema::Integer, char, ::xml_schema::SimpleType > (_xsd_Integer_base)
  {
  }

  HMACOutputLengthType::
  HMACOutputLengthType (const HMACOutputLengthType& x,
                        ::xml_schema::Flags f,
                        ::xml_schema::Container* c)
  : ::xsd::cxx::tree::fundamental_base< ::xml_schema::Integer, char, ::xml_schema::SimpleType > (x, f, c)
  {
  }

  HMACOutputLengthType::
  HMACOutputLengthType (const ::DOMElement& e,
                        ::xml_schema::Flags f,
                        ::xml_schema::Container* c)
  : ::xsd::cxx::tree::fundamental_base< ::xml_schema::Integer, char, ::xml_schema::SimpleType > (e, f, c)
  {
  }

  HMACOutputLengthType::
  HMACOutputLengthType (const ::DOMAttr& a,
                        ::xml_schema::Flags f,
                        ::xml_schema::Container* c)
  : ::xsd::cxx::tree::fundamental_base< ::xml_schema::Integer, char, ::xml_schema::SimpleType > (a, f, c)
  {
  }

  HMACOutputLengthType::
  HMACOutputLengthType (const ::std::string& s,
                        const ::DOMElement* e,
                        ::xml_schema::Flags f,
                        ::xml_schema::Container* c)
  : ::xsd::cxx::tree::fundamental_base< ::xml_schema::Integer, char, ::xml_schema::SimpleType > (s, e, f, c)
  {
  }

  HMACOutputLengthType* HMACOutputLengthType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class HMACOutputLengthType (*this, f, c);
  }

  HMACOutputLengthType::
  ~HMACOutputLengthType ()
  {
  }

  // DSAKeyValueType
  //

  DSAKeyValueType::
  DSAKeyValueType (const YType& Y)
  : ::xml_schema::Type (),
    P_ (::xml_schema::Flags (), this),
    Q_ (::xml_schema::Flags (), this),
    G_ (::xml_schema::Flags (), this),
    Y_ (Y, ::xml_schema::Flags (), this),
    J_ (::xml_schema::Flags (), this),
    Seed_ (::xml_schema::Flags (), this),
    PgenCounter_ (::xml_schema::Flags (), this)
  {
  }

  DSAKeyValueType::
  DSAKeyValueType (const DSAKeyValueType& x,
                   ::xml_schema::Flags f,
                   ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    P_ (x.P_, f, this),
    Q_ (x.Q_, f, this),
    G_ (x.G_, f, this),
    Y_ (x.Y_, f, this),
    J_ (x.J_, f, this),
    Seed_ (x.Seed_, f, this),
    PgenCounter_ (x.PgenCounter_, f, this)
  {
  }

  DSAKeyValueType::
  DSAKeyValueType (const ::DOMElement& e,
                   ::xml_schema::Flags f,
                   ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    P_ (f, this),
    Q_ (f, this),
    G_ (f, this),
    Y_ (f, this),
    J_ (f, this),
    Seed_ (f, this),
    PgenCounter_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
      this->parse (p, f);
    }
  }

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

      // P
      //
      if (n.name () == "P" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< PType > r (
          PTraits::create (i, f, this));

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

      // Q
      //
      if (n.name () == "Q" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< QType > r (
          QTraits::create (i, f, this));

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

      // G
      //
      if (n.name () == "G" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< GType > r (
          GTraits::create (i, f, this));

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

      // Y
      //
      if (n.name () == "Y" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< YType > r (
          YTraits::create (i, f, this));

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

      // J
      //
      if (n.name () == "J" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< JType > r (
          JTraits::create (i, f, this));

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

      // Seed
      //
      if (n.name () == "Seed" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< SeedType > r (
          SeedTraits::create (i, f, this));

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

      // PgenCounter
      //
      if (n.name () == "PgenCounter" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< PgenCounterType > r (
          PgenCounterTraits::create (i, f, this));

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

      break;
    }

    if (!Y_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "Y",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  DSAKeyValueType* DSAKeyValueType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class DSAKeyValueType (*this, f, c);
  }

  DSAKeyValueType::
  ~DSAKeyValueType ()
  {
  }

  // RSAKeyValueType
  //

  RSAKeyValueType::
  RSAKeyValueType (const ModulusType& Modulus,
                   const ExponentType& Exponent)
  : ::xml_schema::Type (),
    Modulus_ (Modulus, ::xml_schema::Flags (), this),
    Exponent_ (Exponent, ::xml_schema::Flags (), this)
  {
  }

  RSAKeyValueType::
  RSAKeyValueType (const RSAKeyValueType& x,
                   ::xml_schema::Flags f,
                   ::xml_schema::Container* c)
  : ::xml_schema::Type (x, f, c),
    Modulus_ (x.Modulus_, f, this),
    Exponent_ (x.Exponent_, f, this)
  {
  }

  RSAKeyValueType::
  RSAKeyValueType (const ::DOMElement& e,
                   ::xml_schema::Flags f,
                   ::xml_schema::Container* c)
  : ::xml_schema::Type (e, f | ::xml_schema::Flags::base, c),
    Modulus_ (f, this),
    Exponent_ (f, this)
  {
    if ((f & ::xml_schema::Flags::base) == 0)
    {
      ::xsd::cxx::xml::dom::parser< char > p (e, true, false);
      this->parse (p, f);
    }
  }

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

      // Modulus
      //
      if (n.name () == "Modulus" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< ModulusType > r (
          ModulusTraits::create (i, f, this));

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

      // Exponent
      //
      if (n.name () == "Exponent" && n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
      {
        ::std::auto_ptr< ExponentType > r (
          ExponentTraits::create (i, f, this));

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

      break;
    }

    if (!Modulus_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "Modulus",
        "http://www.w3.org/2000/09/xmldsig#");
    }

    if (!Exponent_.present ())
    {
      throw ::xsd::cxx::tree::expected_element< char > (
        "Exponent",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  RSAKeyValueType* RSAKeyValueType::
  _clone (::xml_schema::Flags f,
          ::xml_schema::Container* c) const
  {
    return new class RSAKeyValueType (*this, f, c);
  }

  RSAKeyValueType::
  ~RSAKeyValueType ()
  {
  }
}

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

namespace xmldsig
{
  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureType > r (
      ::xmldsig::Signature (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (const ::std::string& u,
             ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureType > r (
      ::xmldsig::Signature (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (const ::std::string& u,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureType > r (
      ::xmldsig::Signature (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::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 ::xmldsig::Signature (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::std::istream& is,
             ::xml_schema::ErrorHandler& 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 ::xmldsig::Signature (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::std::istream& is,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::Signature (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::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 ::xmldsig::Signature (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::std::istream& is,
             const ::std::string& sid,
             ::xml_schema::ErrorHandler& 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 ::xmldsig::Signature (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::std::istream& is,
             const ::std::string& sid,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::Signature (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::InputSource& i,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::SignatureType > r (
      ::xmldsig::Signature (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::InputSource& i,
             ::xml_schema::ErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureType > r (
      ::xmldsig::Signature (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::InputSource& i,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureType > r (
      ::xmldsig::Signature (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (const ::DOMDocument& d,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::SignatureType > r (
        ::xmldsig::Signature (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "Signature" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignatureType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignatureType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Signature",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignatureType >
  Signature (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "Signature" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignatureType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignatureType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Signature",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureValueType > r (
      ::xmldsig::SignatureValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (const ::std::string& u,
                  ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureValueType > r (
      ::xmldsig::SignatureValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (const ::std::string& u,
                  ::DOMErrorHandler& h,
                  ::xml_schema::Flags f,
                  const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureValueType > r (
      ::xmldsig::SignatureValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::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 ::xmldsig::SignatureValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::std::istream& is,
                  ::xml_schema::ErrorHandler& 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 ::xmldsig::SignatureValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::std::istream& is,
                  ::DOMErrorHandler& h,
                  ::xml_schema::Flags f,
                  const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::SignatureValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::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 ::xmldsig::SignatureValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::std::istream& is,
                  const ::std::string& sid,
                  ::xml_schema::ErrorHandler& 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 ::xmldsig::SignatureValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::std::istream& is,
                  const ::std::string& sid,
                  ::DOMErrorHandler& h,
                  ::xml_schema::Flags f,
                  const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::SignatureValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::InputSource& i,
                  ::xml_schema::Flags f,
                  const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::SignatureValueType > r (
      ::xmldsig::SignatureValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::InputSource& i,
                  ::xml_schema::ErrorHandler& h,
                  ::xml_schema::Flags f,
                  const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureValueType > r (
      ::xmldsig::SignatureValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::InputSource& i,
                  ::DOMErrorHandler& h,
                  ::xml_schema::Flags f,
                  const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureValueType > r (
      ::xmldsig::SignatureValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (const ::DOMDocument& d,
                  ::xml_schema::Flags f,
                  const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::SignatureValueType > r (
        ::xmldsig::SignatureValue (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "SignatureValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignatureValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignatureValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignatureValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignatureValueType >
  SignatureValue (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
                  ::xml_schema::Flags f,
                  const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "SignatureValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignatureValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignatureValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignatureValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignedInfoType > r (
      ::xmldsig::SignedInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (const ::std::string& u,
              ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignedInfoType > r (
      ::xmldsig::SignedInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (const ::std::string& u,
              ::DOMErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignedInfoType > r (
      ::xmldsig::SignedInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::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 ::xmldsig::SignedInfo (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::std::istream& is,
              ::xml_schema::ErrorHandler& 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 ::xmldsig::SignedInfo (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::std::istream& is,
              ::DOMErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::SignedInfo (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::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 ::xmldsig::SignedInfo (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::std::istream& is,
              const ::std::string& sid,
              ::xml_schema::ErrorHandler& 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 ::xmldsig::SignedInfo (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::std::istream& is,
              const ::std::string& sid,
              ::DOMErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::SignedInfo (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::InputSource& i,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::SignedInfoType > r (
      ::xmldsig::SignedInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::InputSource& i,
              ::xml_schema::ErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignedInfoType > r (
      ::xmldsig::SignedInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::InputSource& i,
              ::DOMErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignedInfoType > r (
      ::xmldsig::SignedInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (const ::DOMDocument& d,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::SignedInfoType > r (
        ::xmldsig::SignedInfo (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "SignedInfo" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignedInfoType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignedInfoType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignedInfo",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignedInfoType >
  SignedInfo (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "SignedInfo" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignedInfoType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignedInfoType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignedInfo",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType > r (
      ::xmldsig::CanonicalizationMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (const ::std::string& u,
                          ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType > r (
      ::xmldsig::CanonicalizationMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (const ::std::string& u,
                          ::DOMErrorHandler& h,
                          ::xml_schema::Flags f,
                          const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType > r (
      ::xmldsig::CanonicalizationMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::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 ::xmldsig::CanonicalizationMethod (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::std::istream& is,
                          ::xml_schema::ErrorHandler& 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 ::xmldsig::CanonicalizationMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::std::istream& is,
                          ::DOMErrorHandler& h,
                          ::xml_schema::Flags f,
                          const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::CanonicalizationMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::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 ::xmldsig::CanonicalizationMethod (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::std::istream& is,
                          const ::std::string& sid,
                          ::xml_schema::ErrorHandler& 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 ::xmldsig::CanonicalizationMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::std::istream& is,
                          const ::std::string& sid,
                          ::DOMErrorHandler& h,
                          ::xml_schema::Flags f,
                          const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::CanonicalizationMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::InputSource& i,
                          ::xml_schema::Flags f,
                          const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType > r (
      ::xmldsig::CanonicalizationMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::InputSource& i,
                          ::xml_schema::ErrorHandler& h,
                          ::xml_schema::Flags f,
                          const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType > r (
      ::xmldsig::CanonicalizationMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::InputSource& i,
                          ::DOMErrorHandler& h,
                          ::xml_schema::Flags f,
                          const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType > r (
      ::xmldsig::CanonicalizationMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (const ::DOMDocument& d,
                          ::xml_schema::Flags f,
                          const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType > r (
        ::xmldsig::CanonicalizationMethod (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "CanonicalizationMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::CanonicalizationMethodType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "CanonicalizationMethod",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType >
  CanonicalizationMethod (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
                          ::xml_schema::Flags f,
                          const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "CanonicalizationMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::CanonicalizationMethodType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::CanonicalizationMethodType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "CanonicalizationMethod",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureMethodType > r (
      ::xmldsig::SignatureMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (const ::std::string& u,
                   ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureMethodType > r (
      ::xmldsig::SignatureMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (const ::std::string& u,
                   ::DOMErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureMethodType > r (
      ::xmldsig::SignatureMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::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 ::xmldsig::SignatureMethod (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::std::istream& is,
                   ::xml_schema::ErrorHandler& 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 ::xmldsig::SignatureMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::std::istream& is,
                   ::DOMErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::SignatureMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::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 ::xmldsig::SignatureMethod (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::std::istream& is,
                   const ::std::string& sid,
                   ::xml_schema::ErrorHandler& 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 ::xmldsig::SignatureMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::std::istream& is,
                   const ::std::string& sid,
                   ::DOMErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::SignatureMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::InputSource& i,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::SignatureMethodType > r (
      ::xmldsig::SignatureMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::InputSource& i,
                   ::xml_schema::ErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureMethodType > r (
      ::xmldsig::SignatureMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::InputSource& i,
                   ::DOMErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignatureMethodType > r (
      ::xmldsig::SignatureMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (const ::DOMDocument& d,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::SignatureMethodType > r (
        ::xmldsig::SignatureMethod (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "SignatureMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignatureMethodType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignatureMethodType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignatureMethod",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignatureMethodType >
  SignatureMethod (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "SignatureMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignatureMethodType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignatureMethodType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignatureMethod",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ReferenceType > r (
      ::xmldsig::Reference (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (const ::std::string& u,
             ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ReferenceType > r (
      ::xmldsig::Reference (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (const ::std::string& u,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ReferenceType > r (
      ::xmldsig::Reference (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::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 ::xmldsig::Reference (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::std::istream& is,
             ::xml_schema::ErrorHandler& 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 ::xmldsig::Reference (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::std::istream& is,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::Reference (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::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 ::xmldsig::Reference (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::std::istream& is,
             const ::std::string& sid,
             ::xml_schema::ErrorHandler& 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 ::xmldsig::Reference (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::std::istream& is,
             const ::std::string& sid,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::Reference (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::InputSource& i,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::ReferenceType > r (
      ::xmldsig::Reference (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::InputSource& i,
             ::xml_schema::ErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ReferenceType > r (
      ::xmldsig::Reference (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::InputSource& i,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ReferenceType > r (
      ::xmldsig::Reference (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (const ::DOMDocument& d,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::ReferenceType > r (
        ::xmldsig::Reference (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "Reference" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::ReferenceType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::ReferenceType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Reference",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::ReferenceType >
  Reference (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "Reference" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::ReferenceType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::ReferenceType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Reference",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformsType > r (
      ::xmldsig::Transforms (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (const ::std::string& u,
              ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformsType > r (
      ::xmldsig::Transforms (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (const ::std::string& u,
              ::DOMErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformsType > r (
      ::xmldsig::Transforms (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::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 ::xmldsig::Transforms (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::std::istream& is,
              ::xml_schema::ErrorHandler& 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 ::xmldsig::Transforms (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::std::istream& is,
              ::DOMErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::Transforms (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::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 ::xmldsig::Transforms (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::std::istream& is,
              const ::std::string& sid,
              ::xml_schema::ErrorHandler& 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 ::xmldsig::Transforms (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::std::istream& is,
              const ::std::string& sid,
              ::DOMErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::Transforms (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::InputSource& i,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::TransformsType > r (
      ::xmldsig::Transforms (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::InputSource& i,
              ::xml_schema::ErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformsType > r (
      ::xmldsig::Transforms (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::InputSource& i,
              ::DOMErrorHandler& h,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformsType > r (
      ::xmldsig::Transforms (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (const ::DOMDocument& d,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::TransformsType > r (
        ::xmldsig::Transforms (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "Transforms" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::TransformsType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::TransformsType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Transforms",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::TransformsType >
  Transforms (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
              ::xml_schema::Flags f,
              const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "Transforms" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::TransformsType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::TransformsType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Transforms",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformType > r (
      ::xmldsig::Transform (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (const ::std::string& u,
             ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformType > r (
      ::xmldsig::Transform (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (const ::std::string& u,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformType > r (
      ::xmldsig::Transform (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::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 ::xmldsig::Transform (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::std::istream& is,
             ::xml_schema::ErrorHandler& 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 ::xmldsig::Transform (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::std::istream& is,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::Transform (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::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 ::xmldsig::Transform (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::std::istream& is,
             const ::std::string& sid,
             ::xml_schema::ErrorHandler& 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 ::xmldsig::Transform (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::std::istream& is,
             const ::std::string& sid,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::Transform (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::InputSource& i,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::TransformType > r (
      ::xmldsig::Transform (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::InputSource& i,
             ::xml_schema::ErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformType > r (
      ::xmldsig::Transform (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::InputSource& i,
             ::DOMErrorHandler& h,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::TransformType > r (
      ::xmldsig::Transform (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (const ::DOMDocument& d,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::TransformType > r (
        ::xmldsig::Transform (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "Transform" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::TransformType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::TransformType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Transform",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::TransformType >
  Transform (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
             ::xml_schema::Flags f,
             const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "Transform" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::TransformType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::TransformType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Transform",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestMethodType > r (
      ::xmldsig::DigestMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (const ::std::string& u,
                ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestMethodType > r (
      ::xmldsig::DigestMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (const ::std::string& u,
                ::DOMErrorHandler& h,
                ::xml_schema::Flags f,
                const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestMethodType > r (
      ::xmldsig::DigestMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::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 ::xmldsig::DigestMethod (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::std::istream& is,
                ::xml_schema::ErrorHandler& 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 ::xmldsig::DigestMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::std::istream& is,
                ::DOMErrorHandler& h,
                ::xml_schema::Flags f,
                const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::DigestMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::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 ::xmldsig::DigestMethod (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::std::istream& is,
                const ::std::string& sid,
                ::xml_schema::ErrorHandler& 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 ::xmldsig::DigestMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::std::istream& is,
                const ::std::string& sid,
                ::DOMErrorHandler& h,
                ::xml_schema::Flags f,
                const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::DigestMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::InputSource& i,
                ::xml_schema::Flags f,
                const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::DigestMethodType > r (
      ::xmldsig::DigestMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::InputSource& i,
                ::xml_schema::ErrorHandler& h,
                ::xml_schema::Flags f,
                const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestMethodType > r (
      ::xmldsig::DigestMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::InputSource& i,
                ::DOMErrorHandler& h,
                ::xml_schema::Flags f,
                const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestMethodType > r (
      ::xmldsig::DigestMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (const ::DOMDocument& d,
                ::xml_schema::Flags f,
                const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::DigestMethodType > r (
        ::xmldsig::DigestMethod (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "DigestMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::DigestMethodType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::DigestMethodType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "DigestMethod",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::DigestMethodType >
  DigestMethod (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
                ::xml_schema::Flags f,
                const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "DigestMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::DigestMethodType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::DigestMethodType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "DigestMethod",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestValueType > r (
      ::xmldsig::DigestValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (const ::std::string& u,
               ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestValueType > r (
      ::xmldsig::DigestValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (const ::std::string& u,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestValueType > r (
      ::xmldsig::DigestValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::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 ::xmldsig::DigestValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::std::istream& is,
               ::xml_schema::ErrorHandler& 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 ::xmldsig::DigestValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::std::istream& is,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::DigestValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::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 ::xmldsig::DigestValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::std::istream& is,
               const ::std::string& sid,
               ::xml_schema::ErrorHandler& 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 ::xmldsig::DigestValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::std::istream& is,
               const ::std::string& sid,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::DigestValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::InputSource& i,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::DigestValueType > r (
      ::xmldsig::DigestValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::InputSource& i,
               ::xml_schema::ErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestValueType > r (
      ::xmldsig::DigestValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::InputSource& i,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DigestValueType > r (
      ::xmldsig::DigestValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (const ::DOMDocument& d,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::DigestValueType > r (
        ::xmldsig::DigestValue (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "DigestValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::DigestValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::DigestValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "DigestValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::DigestValueType >
  DigestValue (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "DigestValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::DigestValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::DigestValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "DigestValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyInfoType > r (
      ::xmldsig::KeyInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (const ::std::string& u,
           ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyInfoType > r (
      ::xmldsig::KeyInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (const ::std::string& u,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyInfoType > r (
      ::xmldsig::KeyInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::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 ::xmldsig::KeyInfo (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::std::istream& is,
           ::xml_schema::ErrorHandler& 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 ::xmldsig::KeyInfo (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::std::istream& is,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::KeyInfo (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::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 ::xmldsig::KeyInfo (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::std::istream& is,
           const ::std::string& sid,
           ::xml_schema::ErrorHandler& 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 ::xmldsig::KeyInfo (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::std::istream& is,
           const ::std::string& sid,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::KeyInfo (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::InputSource& i,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::KeyInfoType > r (
      ::xmldsig::KeyInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::InputSource& i,
           ::xml_schema::ErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyInfoType > r (
      ::xmldsig::KeyInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::InputSource& i,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyInfoType > r (
      ::xmldsig::KeyInfo (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (const ::DOMDocument& d,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::KeyInfoType > r (
        ::xmldsig::KeyInfo (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "KeyInfo" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::KeyInfoType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::KeyInfoType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "KeyInfo",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::KeyInfoType >
  KeyInfo (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "KeyInfo" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::KeyInfoType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::KeyInfoType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "KeyInfo",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::KeyName (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (const ::std::string& u,
           ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::KeyName (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (const ::std::string& u,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::KeyName (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::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 ::xmldsig::KeyName (isrc, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::std::istream& is,
           ::xml_schema::ErrorHandler& 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 ::xmldsig::KeyName (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::std::istream& is,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::KeyName (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::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 ::xmldsig::KeyName (isrc, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::std::istream& is,
           const ::std::string& sid,
           ::xml_schema::ErrorHandler& 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 ::xmldsig::KeyName (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::std::istream& is,
           const ::std::string& sid,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::KeyName (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::InputSource& i,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::KeyName (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::InputSource& i,
           ::xml_schema::ErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::KeyName (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::InputSource& i,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::KeyName (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (const ::DOMDocument& d,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xml_schema::String > r (
        ::xmldsig::KeyName (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "KeyName" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xml_schema::String > r (
        ::xsd::cxx::tree::traits< ::xml_schema::String, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "KeyName",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xml_schema::String >
  KeyName (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "KeyName" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xml_schema::String > r (
        ::xsd::cxx::tree::traits< ::xml_schema::String, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "KeyName",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::MgmtData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (const ::std::string& u,
            ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::MgmtData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (const ::std::string& u,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::MgmtData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::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 ::xmldsig::MgmtData (isrc, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::std::istream& is,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::MgmtData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::std::istream& is,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::MgmtData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::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 ::xmldsig::MgmtData (isrc, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::std::istream& is,
            const ::std::string& sid,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::MgmtData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::std::istream& is,
            const ::std::string& sid,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::MgmtData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::InputSource& i,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::MgmtData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::InputSource& i,
            ::xml_schema::ErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::MgmtData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::InputSource& i,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xml_schema::String > r (
      ::xmldsig::MgmtData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (const ::DOMDocument& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xml_schema::String > r (
        ::xmldsig::MgmtData (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "MgmtData" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xml_schema::String > r (
        ::xsd::cxx::tree::traits< ::xml_schema::String, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "MgmtData",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xml_schema::String >
  MgmtData (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "MgmtData" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xml_schema::String > r (
        ::xsd::cxx::tree::traits< ::xml_schema::String, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "MgmtData",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyValueType > r (
      ::xmldsig::KeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (const ::std::string& u,
            ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyValueType > r (
      ::xmldsig::KeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (const ::std::string& u,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyValueType > r (
      ::xmldsig::KeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::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 ::xmldsig::KeyValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::std::istream& is,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::KeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::std::istream& is,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::KeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::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 ::xmldsig::KeyValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::std::istream& is,
            const ::std::string& sid,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::KeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::std::istream& is,
            const ::std::string& sid,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::KeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::InputSource& i,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::KeyValueType > r (
      ::xmldsig::KeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::InputSource& i,
            ::xml_schema::ErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyValueType > r (
      ::xmldsig::KeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::InputSource& i,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::KeyValueType > r (
      ::xmldsig::KeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (const ::DOMDocument& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::KeyValueType > r (
        ::xmldsig::KeyValue (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "KeyValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::KeyValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::KeyValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "KeyValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::KeyValueType >
  KeyValue (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "KeyValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::KeyValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::KeyValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "KeyValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RetrievalMethodType > r (
      ::xmldsig::RetrievalMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (const ::std::string& u,
                   ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RetrievalMethodType > r (
      ::xmldsig::RetrievalMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (const ::std::string& u,
                   ::DOMErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RetrievalMethodType > r (
      ::xmldsig::RetrievalMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::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 ::xmldsig::RetrievalMethod (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::std::istream& is,
                   ::xml_schema::ErrorHandler& 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 ::xmldsig::RetrievalMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::std::istream& is,
                   ::DOMErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::RetrievalMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::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 ::xmldsig::RetrievalMethod (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::std::istream& is,
                   const ::std::string& sid,
                   ::xml_schema::ErrorHandler& 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 ::xmldsig::RetrievalMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::std::istream& is,
                   const ::std::string& sid,
                   ::DOMErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::RetrievalMethod (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::InputSource& i,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::RetrievalMethodType > r (
      ::xmldsig::RetrievalMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::InputSource& i,
                   ::xml_schema::ErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RetrievalMethodType > r (
      ::xmldsig::RetrievalMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::InputSource& i,
                   ::DOMErrorHandler& h,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RetrievalMethodType > r (
      ::xmldsig::RetrievalMethod (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (const ::DOMDocument& d,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::RetrievalMethodType > r (
        ::xmldsig::RetrievalMethod (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "RetrievalMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::RetrievalMethodType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::RetrievalMethodType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "RetrievalMethod",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::RetrievalMethodType >
  RetrievalMethod (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
                   ::xml_schema::Flags f,
                   const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "RetrievalMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::RetrievalMethodType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::RetrievalMethodType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "RetrievalMethod",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::X509DataType > r (
      ::xmldsig::X509Data (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (const ::std::string& u,
            ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::X509DataType > r (
      ::xmldsig::X509Data (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (const ::std::string& u,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::X509DataType > r (
      ::xmldsig::X509Data (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::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 ::xmldsig::X509Data (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::std::istream& is,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::X509Data (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::std::istream& is,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::X509Data (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::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 ::xmldsig::X509Data (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::std::istream& is,
            const ::std::string& sid,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::X509Data (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::std::istream& is,
            const ::std::string& sid,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::X509Data (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::InputSource& i,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::X509DataType > r (
      ::xmldsig::X509Data (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::InputSource& i,
            ::xml_schema::ErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::X509DataType > r (
      ::xmldsig::X509Data (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::InputSource& i,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::X509DataType > r (
      ::xmldsig::X509Data (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (const ::DOMDocument& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::X509DataType > r (
        ::xmldsig::X509Data (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "X509Data" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::X509DataType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::X509DataType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "X509Data",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::X509DataType >
  X509Data (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "X509Data" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::X509DataType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::X509DataType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "X509Data",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::PGPDataType > r (
      ::xmldsig::PGPData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (const ::std::string& u,
           ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::PGPDataType > r (
      ::xmldsig::PGPData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (const ::std::string& u,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::PGPDataType > r (
      ::xmldsig::PGPData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::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 ::xmldsig::PGPData (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::std::istream& is,
           ::xml_schema::ErrorHandler& 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 ::xmldsig::PGPData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::std::istream& is,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::PGPData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::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 ::xmldsig::PGPData (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::std::istream& is,
           const ::std::string& sid,
           ::xml_schema::ErrorHandler& 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 ::xmldsig::PGPData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::std::istream& is,
           const ::std::string& sid,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::PGPData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::InputSource& i,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::PGPDataType > r (
      ::xmldsig::PGPData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::InputSource& i,
           ::xml_schema::ErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::PGPDataType > r (
      ::xmldsig::PGPData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::InputSource& i,
           ::DOMErrorHandler& h,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::PGPDataType > r (
      ::xmldsig::PGPData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (const ::DOMDocument& d,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::PGPDataType > r (
        ::xmldsig::PGPData (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "PGPData" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::PGPDataType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::PGPDataType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "PGPData",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::PGPDataType >
  PGPData (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
           ::xml_schema::Flags f,
           const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "PGPData" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::PGPDataType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::PGPDataType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "PGPData",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SPKIDataType > r (
      ::xmldsig::SPKIData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (const ::std::string& u,
            ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SPKIDataType > r (
      ::xmldsig::SPKIData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (const ::std::string& u,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SPKIDataType > r (
      ::xmldsig::SPKIData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::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 ::xmldsig::SPKIData (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::std::istream& is,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::SPKIData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::std::istream& is,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::SPKIData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::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 ::xmldsig::SPKIData (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::std::istream& is,
            const ::std::string& sid,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::SPKIData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::std::istream& is,
            const ::std::string& sid,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::SPKIData (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::InputSource& i,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::SPKIDataType > r (
      ::xmldsig::SPKIData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::InputSource& i,
            ::xml_schema::ErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SPKIDataType > r (
      ::xmldsig::SPKIData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::InputSource& i,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SPKIDataType > r (
      ::xmldsig::SPKIData (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (const ::DOMDocument& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::SPKIDataType > r (
        ::xmldsig::SPKIData (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "SPKIData" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SPKIDataType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SPKIDataType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SPKIData",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SPKIDataType >
  SPKIData (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "SPKIData" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SPKIDataType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SPKIDataType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SPKIData",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ObjectType > r (
      ::xmldsig::Object (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (const ::std::string& u,
          ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ObjectType > r (
      ::xmldsig::Object (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (const ::std::string& u,
          ::DOMErrorHandler& h,
          ::xml_schema::Flags f,
          const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ObjectType > r (
      ::xmldsig::Object (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::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 ::xmldsig::Object (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::std::istream& is,
          ::xml_schema::ErrorHandler& 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 ::xmldsig::Object (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::std::istream& is,
          ::DOMErrorHandler& h,
          ::xml_schema::Flags f,
          const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::Object (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::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 ::xmldsig::Object (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::std::istream& is,
          const ::std::string& sid,
          ::xml_schema::ErrorHandler& 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 ::xmldsig::Object (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::std::istream& is,
          const ::std::string& sid,
          ::DOMErrorHandler& h,
          ::xml_schema::Flags f,
          const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::Object (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::InputSource& i,
          ::xml_schema::Flags f,
          const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::ObjectType > r (
      ::xmldsig::Object (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::InputSource& i,
          ::xml_schema::ErrorHandler& h,
          ::xml_schema::Flags f,
          const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ObjectType > r (
      ::xmldsig::Object (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::InputSource& i,
          ::DOMErrorHandler& h,
          ::xml_schema::Flags f,
          const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ObjectType > r (
      ::xmldsig::Object (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (const ::DOMDocument& d,
          ::xml_schema::Flags f,
          const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::ObjectType > r (
        ::xmldsig::Object (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "Object" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::ObjectType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::ObjectType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Object",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::ObjectType >
  Object (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
          ::xml_schema::Flags f,
          const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "Object" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::ObjectType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::ObjectType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Object",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ManifestType > r (
      ::xmldsig::Manifest (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (const ::std::string& u,
            ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ManifestType > r (
      ::xmldsig::Manifest (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (const ::std::string& u,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ManifestType > r (
      ::xmldsig::Manifest (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::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 ::xmldsig::Manifest (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::std::istream& is,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::Manifest (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::std::istream& is,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::Manifest (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::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 ::xmldsig::Manifest (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::std::istream& is,
            const ::std::string& sid,
            ::xml_schema::ErrorHandler& 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 ::xmldsig::Manifest (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::std::istream& is,
            const ::std::string& sid,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::Manifest (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::InputSource& i,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::ManifestType > r (
      ::xmldsig::Manifest (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::InputSource& i,
            ::xml_schema::ErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ManifestType > r (
      ::xmldsig::Manifest (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::InputSource& i,
            ::DOMErrorHandler& h,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::ManifestType > r (
      ::xmldsig::Manifest (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (const ::DOMDocument& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::ManifestType > r (
        ::xmldsig::Manifest (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "Manifest" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::ManifestType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::ManifestType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Manifest",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::ManifestType >
  Manifest (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
            ::xml_schema::Flags f,
            const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "Manifest" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::ManifestType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::ManifestType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "Manifest",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertiesType > r (
      ::xmldsig::SignatureProperties (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (const ::std::string& u,
                       ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertiesType > r (
      ::xmldsig::SignatureProperties (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (const ::std::string& u,
                       ::DOMErrorHandler& h,
                       ::xml_schema::Flags f,
                       const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertiesType > r (
      ::xmldsig::SignatureProperties (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::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 ::xmldsig::SignatureProperties (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::std::istream& is,
                       ::xml_schema::ErrorHandler& 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 ::xmldsig::SignatureProperties (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::std::istream& is,
                       ::DOMErrorHandler& h,
                       ::xml_schema::Flags f,
                       const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::SignatureProperties (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::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 ::xmldsig::SignatureProperties (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::std::istream& is,
                       const ::std::string& sid,
                       ::xml_schema::ErrorHandler& 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 ::xmldsig::SignatureProperties (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::std::istream& is,
                       const ::std::string& sid,
                       ::DOMErrorHandler& h,
                       ::xml_schema::Flags f,
                       const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::SignatureProperties (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::InputSource& i,
                       ::xml_schema::Flags f,
                       const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertiesType > r (
      ::xmldsig::SignatureProperties (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::InputSource& i,
                       ::xml_schema::ErrorHandler& h,
                       ::xml_schema::Flags f,
                       const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertiesType > r (
      ::xmldsig::SignatureProperties (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::InputSource& i,
                       ::DOMErrorHandler& h,
                       ::xml_schema::Flags f,
                       const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertiesType > r (
      ::xmldsig::SignatureProperties (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (const ::DOMDocument& d,
                       ::xml_schema::Flags f,
                       const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::SignaturePropertiesType > r (
        ::xmldsig::SignatureProperties (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "SignatureProperties" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignaturePropertiesType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignaturePropertiesType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignatureProperties",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertiesType >
  SignatureProperties (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
                       ::xml_schema::Flags f,
                       const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "SignatureProperties" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignaturePropertiesType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignaturePropertiesType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignatureProperties",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertyType > r (
      ::xmldsig::SignatureProperty (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (const ::std::string& u,
                     ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertyType > r (
      ::xmldsig::SignatureProperty (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (const ::std::string& u,
                     ::DOMErrorHandler& h,
                     ::xml_schema::Flags f,
                     const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertyType > r (
      ::xmldsig::SignatureProperty (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::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 ::xmldsig::SignatureProperty (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::std::istream& is,
                     ::xml_schema::ErrorHandler& 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 ::xmldsig::SignatureProperty (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::std::istream& is,
                     ::DOMErrorHandler& h,
                     ::xml_schema::Flags f,
                     const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::SignatureProperty (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::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 ::xmldsig::SignatureProperty (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::std::istream& is,
                     const ::std::string& sid,
                     ::xml_schema::ErrorHandler& 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 ::xmldsig::SignatureProperty (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::std::istream& is,
                     const ::std::string& sid,
                     ::DOMErrorHandler& h,
                     ::xml_schema::Flags f,
                     const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::SignatureProperty (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::InputSource& i,
                     ::xml_schema::Flags f,
                     const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertyType > r (
      ::xmldsig::SignatureProperty (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::InputSource& i,
                     ::xml_schema::ErrorHandler& h,
                     ::xml_schema::Flags f,
                     const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertyType > r (
      ::xmldsig::SignatureProperty (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::InputSource& i,
                     ::DOMErrorHandler& h,
                     ::xml_schema::Flags f,
                     const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::SignaturePropertyType > r (
      ::xmldsig::SignatureProperty (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (const ::DOMDocument& d,
                     ::xml_schema::Flags f,
                     const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::SignaturePropertyType > r (
        ::xmldsig::SignatureProperty (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "SignatureProperty" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignaturePropertyType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignaturePropertyType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignatureProperty",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::SignaturePropertyType >
  SignatureProperty (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
                     ::xml_schema::Flags f,
                     const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "SignatureProperty" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::SignaturePropertyType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::SignaturePropertyType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "SignatureProperty",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DSAKeyValueType > r (
      ::xmldsig::DSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (const ::std::string& u,
               ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DSAKeyValueType > r (
      ::xmldsig::DSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (const ::std::string& u,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DSAKeyValueType > r (
      ::xmldsig::DSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::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 ::xmldsig::DSAKeyValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::std::istream& is,
               ::xml_schema::ErrorHandler& 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 ::xmldsig::DSAKeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::std::istream& is,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::DSAKeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::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 ::xmldsig::DSAKeyValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::std::istream& is,
               const ::std::string& sid,
               ::xml_schema::ErrorHandler& 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 ::xmldsig::DSAKeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::std::istream& is,
               const ::std::string& sid,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::DSAKeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::InputSource& i,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::DSAKeyValueType > r (
      ::xmldsig::DSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::InputSource& i,
               ::xml_schema::ErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DSAKeyValueType > r (
      ::xmldsig::DSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::InputSource& i,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::DSAKeyValueType > r (
      ::xmldsig::DSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (const ::DOMDocument& d,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::DSAKeyValueType > r (
        ::xmldsig::DSAKeyValue (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "DSAKeyValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::DSAKeyValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::DSAKeyValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "DSAKeyValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::DSAKeyValueType >
  DSAKeyValue (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "DSAKeyValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::DSAKeyValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::DSAKeyValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "DSAKeyValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RSAKeyValueType > r (
      ::xmldsig::RSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (const ::std::string& u,
               ::xml_schema::ErrorHandler& 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< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RSAKeyValueType > r (
      ::xmldsig::RSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (const ::std::string& u,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        u, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RSAKeyValueType > r (
      ::xmldsig::RSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::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 ::xmldsig::RSAKeyValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::std::istream& is,
               ::xml_schema::ErrorHandler& 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 ::xmldsig::RSAKeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::std::istream& is,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is);
    return ::xmldsig::RSAKeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::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 ::xmldsig::RSAKeyValue (isrc, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::std::istream& is,
               const ::std::string& sid,
               ::xml_schema::ErrorHandler& 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 ::xmldsig::RSAKeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::std::istream& is,
               const ::std::string& sid,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
    return ::xmldsig::RSAKeyValue (isrc, h, f, p);
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::InputSource& i,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xsd::cxx::tree::error_handler< char > h;

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

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

    ::std::auto_ptr< ::xmldsig::RSAKeyValueType > r (
      ::xmldsig::RSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::InputSource& i,
               ::xml_schema::ErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RSAKeyValueType > r (
      ::xmldsig::RSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::InputSource& i,
               ::DOMErrorHandler& h,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::parse< char > (
        i, h, p, f));

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

    ::std::auto_ptr< ::xmldsig::RSAKeyValueType > r (
      ::xmldsig::RSAKeyValue (
        d, f | ::xml_schema::Flags::own_dom, p));

    return r;
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (const ::DOMDocument& d,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties& p)
  {
    if (f & ::xml_schema::Flags::keep_dom)
    {
      ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
        static_cast< ::DOMDocument* > (d.cloneNode (true)));

      ::std::auto_ptr< ::xmldsig::RSAKeyValueType > r (
        ::xmldsig::RSAKeyValue (
          c, f | ::xml_schema::Flags::own_dom, p));

      return r;
    }

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

    if (n.name () == "RSAKeyValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::RSAKeyValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::RSAKeyValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "RSAKeyValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }

  ::std::auto_ptr< ::xmldsig::RSAKeyValueType >
  RSAKeyValue (::xml_schema::dom::auto_ptr< ::DOMDocument >& d,
               ::xml_schema::Flags f,
               const ::xml_schema::Properties&)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > c (
      ((f & ::xml_schema::Flags::keep_dom) &&
       !(f & ::xml_schema::Flags::own_dom))
      ? static_cast< ::DOMDocument* > (d->cloneNode (true))
      : 0);

    ::DOMDocument& doc (c.get () ? *c : *d);
    const ::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 () == "RSAKeyValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      ::std::auto_ptr< ::xmldsig::RSAKeyValueType > r (
        ::xsd::cxx::tree::traits< ::xmldsig::RSAKeyValueType, char >::create (
          e, f, 0));
      return r;
    }

    throw ::xsd::cxx::tree::unexpected_element < char > (
      n.name (),
      n.namespace_ (),
      "RSAKeyValue",
      "http://www.w3.org/2000/09/xmldsig#");
  }
}

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

namespace xmldsig
{
  void
  operator<< (::DOMElement& e, const CryptoBinary& i)
  {
    e << static_cast< const ::xml_schema::Base64Binary& > (i);
  }

  void
  operator<< (::DOMAttr& a, const CryptoBinary& i)
  {
    a << static_cast< const ::xml_schema::Base64Binary& > (i);
  }

  void
  operator<< (::xml_schema::ListStream& l,
              const CryptoBinary& i)
  {
    l << static_cast< const ::xml_schema::Base64Binary& > (i);
  }

  void
  Signature (::std::ostream& o,
             const ::xmldsig::SignatureType& s,
             const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Signature (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
  Signature (::std::ostream& o,
             const ::xmldsig::SignatureType& s,
             ::xml_schema::ErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Signature (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
  Signature (::std::ostream& o,
             const ::xmldsig::SignatureType& s,
             ::DOMErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Signature (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
  Signature (::XMLFormatTarget& t,
             const ::xmldsig::SignatureType& s,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Signature (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
  Signature (::XMLFormatTarget& t,
             const ::xmldsig::SignatureType& s,
             ::xml_schema::ErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Signature (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Signature (::XMLFormatTarget& t,
             const ::xmldsig::SignatureType& s,
             ::DOMErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Signature (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Signature (::DOMDocument& d,
             const ::xmldsig::SignatureType& s,
             ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "Signature" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "Signature",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  Signature (const ::xmldsig::SignatureType& s,
             const ::xml_schema::NamespaceInfomap& m,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "Signature",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::Signature (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const SignatureType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // SignedInfo
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SignedInfo",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.SignedInfo ();
    }

    // SignatureValue
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SignatureValue",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.SignatureValue ();
    }

    // KeyInfo
    //
    if (i.KeyInfo ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "KeyInfo",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.KeyInfo ();
    }

    // Object
    //
    for (SignatureType::ObjectConstIterator
         b (i.Object ().begin ()), n (i.Object ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Object",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // Id
    //
    if (i.Id ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Id",
          e));

      a << *i.Id ();
    }
  }

  void
  SignatureValue (::std::ostream& o,
                  const ::xmldsig::SignatureValueType& s,
                  const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignatureValue (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
  SignatureValue (::std::ostream& o,
                  const ::xmldsig::SignatureValueType& s,
                  ::xml_schema::ErrorHandler& h,
                  const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignatureValue (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
  SignatureValue (::std::ostream& o,
                  const ::xmldsig::SignatureValueType& s,
                  ::DOMErrorHandler& h,
                  const ::xml_schema::NamespaceInfomap& m,
                  const ::std::string& e,
                  ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureValue (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
  SignatureValue (::XMLFormatTarget& t,
                  const ::xmldsig::SignatureValueType& s,
                  const ::xml_schema::NamespaceInfomap& m,
                  const ::std::string& e,
                  ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureValue (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
  SignatureValue (::XMLFormatTarget& t,
                  const ::xmldsig::SignatureValueType& s,
                  ::xml_schema::ErrorHandler& h,
                  const ::xml_schema::NamespaceInfomap& m,
                  const ::std::string& e,
                  ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignatureValue (::XMLFormatTarget& t,
                  const ::xmldsig::SignatureValueType& s,
                  ::DOMErrorHandler& h,
                  const ::xml_schema::NamespaceInfomap& m,
                  const ::std::string& e,
                  ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignatureValue (::DOMDocument& d,
                  const ::xmldsig::SignatureValueType& s,
                  ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "SignatureValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "SignatureValue",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  SignatureValue (const ::xmldsig::SignatureValueType& s,
                  const ::xml_schema::NamespaceInfomap& m,
                  ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "SignatureValue",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::SignatureValue (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const SignatureValueType& i)
  {
    e << static_cast< const ::xml_schema::Base64Binary& > (i);

    // Id
    //
    if (i.Id ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Id",
          e));

      a << *i.Id ();
    }
  }

  void
  SignedInfo (::std::ostream& o,
              const ::xmldsig::SignedInfoType& s,
              const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignedInfo (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
  SignedInfo (::std::ostream& o,
              const ::xmldsig::SignedInfoType& s,
              ::xml_schema::ErrorHandler& h,
              const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignedInfo (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
  SignedInfo (::std::ostream& o,
              const ::xmldsig::SignedInfoType& s,
              ::DOMErrorHandler& h,
              const ::xml_schema::NamespaceInfomap& m,
              const ::std::string& e,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignedInfo (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
  SignedInfo (::XMLFormatTarget& t,
              const ::xmldsig::SignedInfoType& s,
              const ::xml_schema::NamespaceInfomap& m,
              const ::std::string& e,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignedInfo (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
  SignedInfo (::XMLFormatTarget& t,
              const ::xmldsig::SignedInfoType& s,
              ::xml_schema::ErrorHandler& h,
              const ::xml_schema::NamespaceInfomap& m,
              const ::std::string& e,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignedInfo (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignedInfo (::XMLFormatTarget& t,
              const ::xmldsig::SignedInfoType& s,
              ::DOMErrorHandler& h,
              const ::xml_schema::NamespaceInfomap& m,
              const ::std::string& e,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignedInfo (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignedInfo (::DOMDocument& d,
              const ::xmldsig::SignedInfoType& s,
              ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "SignedInfo" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "SignedInfo",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  SignedInfo (const ::xmldsig::SignedInfoType& s,
              const ::xml_schema::NamespaceInfomap& m,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "SignedInfo",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::SignedInfo (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const SignedInfoType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // CanonicalizationMethod
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "CanonicalizationMethod",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.CanonicalizationMethod ();
    }

    // SignatureMethod
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SignatureMethod",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.SignatureMethod ();
    }

    // Reference
    //
    for (SignedInfoType::ReferenceConstIterator
         b (i.Reference ().begin ()), n (i.Reference ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Reference",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // Id
    //
    if (i.Id ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Id",
          e));

      a << *i.Id ();
    }
  }

  void
  CanonicalizationMethod (::std::ostream& o,
                          const ::xmldsig::CanonicalizationMethodType& s,
                          const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::CanonicalizationMethod (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
  CanonicalizationMethod (::std::ostream& o,
                          const ::xmldsig::CanonicalizationMethodType& s,
                          ::xml_schema::ErrorHandler& h,
                          const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::CanonicalizationMethod (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
  CanonicalizationMethod (::std::ostream& o,
                          const ::xmldsig::CanonicalizationMethodType& s,
                          ::DOMErrorHandler& h,
                          const ::xml_schema::NamespaceInfomap& m,
                          const ::std::string& e,
                          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::CanonicalizationMethod (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
  CanonicalizationMethod (::XMLFormatTarget& t,
                          const ::xmldsig::CanonicalizationMethodType& s,
                          const ::xml_schema::NamespaceInfomap& m,
                          const ::std::string& e,
                          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::CanonicalizationMethod (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
  CanonicalizationMethod (::XMLFormatTarget& t,
                          const ::xmldsig::CanonicalizationMethodType& s,
                          ::xml_schema::ErrorHandler& h,
                          const ::xml_schema::NamespaceInfomap& m,
                          const ::std::string& e,
                          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::CanonicalizationMethod (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  CanonicalizationMethod (::XMLFormatTarget& t,
                          const ::xmldsig::CanonicalizationMethodType& s,
                          ::DOMErrorHandler& h,
                          const ::xml_schema::NamespaceInfomap& m,
                          const ::std::string& e,
                          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::CanonicalizationMethod (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  CanonicalizationMethod (::DOMDocument& d,
                          const ::xmldsig::CanonicalizationMethodType& s,
                          ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "CanonicalizationMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "CanonicalizationMethod",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  CanonicalizationMethod (const ::xmldsig::CanonicalizationMethodType& s,
                          const ::xml_schema::NamespaceInfomap& m,
                          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "CanonicalizationMethod",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::CanonicalizationMethod (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const CanonicalizationMethodType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // Algorithm
    //
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Algorithm",
          e));

      a << i.Algorithm ();
    }
  }

  void
  SignatureMethod (::std::ostream& o,
                   const ::xmldsig::SignatureMethodType& s,
                   const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignatureMethod (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
  SignatureMethod (::std::ostream& o,
                   const ::xmldsig::SignatureMethodType& s,
                   ::xml_schema::ErrorHandler& h,
                   const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignatureMethod (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
  SignatureMethod (::std::ostream& o,
                   const ::xmldsig::SignatureMethodType& s,
                   ::DOMErrorHandler& h,
                   const ::xml_schema::NamespaceInfomap& m,
                   const ::std::string& e,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureMethod (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
  SignatureMethod (::XMLFormatTarget& t,
                   const ::xmldsig::SignatureMethodType& s,
                   const ::xml_schema::NamespaceInfomap& m,
                   const ::std::string& e,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureMethod (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
  SignatureMethod (::XMLFormatTarget& t,
                   const ::xmldsig::SignatureMethodType& s,
                   ::xml_schema::ErrorHandler& h,
                   const ::xml_schema::NamespaceInfomap& m,
                   const ::std::string& e,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureMethod (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignatureMethod (::XMLFormatTarget& t,
                   const ::xmldsig::SignatureMethodType& s,
                   ::DOMErrorHandler& h,
                   const ::xml_schema::NamespaceInfomap& m,
                   const ::std::string& e,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureMethod (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignatureMethod (::DOMDocument& d,
                   const ::xmldsig::SignatureMethodType& s,
                   ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "SignatureMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "SignatureMethod",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  SignatureMethod (const ::xmldsig::SignatureMethodType& s,
                   const ::xml_schema::NamespaceInfomap& m,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "SignatureMethod",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::SignatureMethod (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const SignatureMethodType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // HMACOutputLength
    //
    if (i.HMACOutputLength ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "HMACOutputLength",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.HMACOutputLength ();
    }

    // Algorithm
    //
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Algorithm",
          e));

      a << i.Algorithm ();
    }
  }

  void
  Reference (::std::ostream& o,
             const ::xmldsig::ReferenceType& s,
             const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Reference (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
  Reference (::std::ostream& o,
             const ::xmldsig::ReferenceType& s,
             ::xml_schema::ErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Reference (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
  Reference (::std::ostream& o,
             const ::xmldsig::ReferenceType& s,
             ::DOMErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Reference (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
  Reference (::XMLFormatTarget& t,
             const ::xmldsig::ReferenceType& s,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Reference (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
  Reference (::XMLFormatTarget& t,
             const ::xmldsig::ReferenceType& s,
             ::xml_schema::ErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Reference (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Reference (::XMLFormatTarget& t,
             const ::xmldsig::ReferenceType& s,
             ::DOMErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Reference (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Reference (::DOMDocument& d,
             const ::xmldsig::ReferenceType& s,
             ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "Reference" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "Reference",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  Reference (const ::xmldsig::ReferenceType& s,
             const ::xml_schema::NamespaceInfomap& m,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "Reference",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::Reference (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const ReferenceType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // Transforms
    //
    if (i.Transforms ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Transforms",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.Transforms ();
    }

    // DigestMethod
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "DigestMethod",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.DigestMethod ();
    }

    // DigestValue
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "DigestValue",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.DigestValue ();
    }

    // Id
    //
    if (i.Id ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Id",
          e));

      a << *i.Id ();
    }

    // URI
    //
    if (i.URI ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "URI",
          e));

      a << *i.URI ();
    }

    // Type
    //
    if (i.Type ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Type",
          e));

      a << *i.Type ();
    }
  }

  void
  Transforms (::std::ostream& o,
              const ::xmldsig::TransformsType& s,
              const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Transforms (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
  Transforms (::std::ostream& o,
              const ::xmldsig::TransformsType& s,
              ::xml_schema::ErrorHandler& h,
              const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Transforms (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
  Transforms (::std::ostream& o,
              const ::xmldsig::TransformsType& s,
              ::DOMErrorHandler& h,
              const ::xml_schema::NamespaceInfomap& m,
              const ::std::string& e,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Transforms (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
  Transforms (::XMLFormatTarget& t,
              const ::xmldsig::TransformsType& s,
              const ::xml_schema::NamespaceInfomap& m,
              const ::std::string& e,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Transforms (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
  Transforms (::XMLFormatTarget& t,
              const ::xmldsig::TransformsType& s,
              ::xml_schema::ErrorHandler& h,
              const ::xml_schema::NamespaceInfomap& m,
              const ::std::string& e,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Transforms (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Transforms (::XMLFormatTarget& t,
              const ::xmldsig::TransformsType& s,
              ::DOMErrorHandler& h,
              const ::xml_schema::NamespaceInfomap& m,
              const ::std::string& e,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Transforms (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Transforms (::DOMDocument& d,
              const ::xmldsig::TransformsType& s,
              ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "Transforms" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "Transforms",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  Transforms (const ::xmldsig::TransformsType& s,
              const ::xml_schema::NamespaceInfomap& m,
              ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "Transforms",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::Transforms (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const TransformsType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // Transform
    //
    for (TransformsType::TransformConstIterator
         b (i.Transform ().begin ()), n (i.Transform ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Transform",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }
  }

  void
  Transform (::std::ostream& o,
             const ::xmldsig::TransformType& s,
             const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Transform (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
  Transform (::std::ostream& o,
             const ::xmldsig::TransformType& s,
             ::xml_schema::ErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Transform (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
  Transform (::std::ostream& o,
             const ::xmldsig::TransformType& s,
             ::DOMErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Transform (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
  Transform (::XMLFormatTarget& t,
             const ::xmldsig::TransformType& s,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Transform (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
  Transform (::XMLFormatTarget& t,
             const ::xmldsig::TransformType& s,
             ::xml_schema::ErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Transform (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Transform (::XMLFormatTarget& t,
             const ::xmldsig::TransformType& s,
             ::DOMErrorHandler& h,
             const ::xml_schema::NamespaceInfomap& m,
             const ::std::string& e,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Transform (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Transform (::DOMDocument& d,
             const ::xmldsig::TransformType& s,
             ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "Transform" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "Transform",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  Transform (const ::xmldsig::TransformType& s,
             const ::xml_schema::NamespaceInfomap& m,
             ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "Transform",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::Transform (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const TransformType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // XPath
    //
    for (TransformType::XPathConstIterator
         b (i.XPath ().begin ()), n (i.XPath ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "XPath",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // Algorithm
    //
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Algorithm",
          e));

      a << i.Algorithm ();
    }
  }

  void
  DigestMethod (::std::ostream& o,
                const ::xmldsig::DigestMethodType& s,
                const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::DigestMethod (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
  DigestMethod (::std::ostream& o,
                const ::xmldsig::DigestMethodType& s,
                ::xml_schema::ErrorHandler& h,
                const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::DigestMethod (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
  DigestMethod (::std::ostream& o,
                const ::xmldsig::DigestMethodType& s,
                ::DOMErrorHandler& h,
                const ::xml_schema::NamespaceInfomap& m,
                const ::std::string& e,
                ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DigestMethod (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
  DigestMethod (::XMLFormatTarget& t,
                const ::xmldsig::DigestMethodType& s,
                const ::xml_schema::NamespaceInfomap& m,
                const ::std::string& e,
                ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DigestMethod (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
  DigestMethod (::XMLFormatTarget& t,
                const ::xmldsig::DigestMethodType& s,
                ::xml_schema::ErrorHandler& h,
                const ::xml_schema::NamespaceInfomap& m,
                const ::std::string& e,
                ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DigestMethod (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  DigestMethod (::XMLFormatTarget& t,
                const ::xmldsig::DigestMethodType& s,
                ::DOMErrorHandler& h,
                const ::xml_schema::NamespaceInfomap& m,
                const ::std::string& e,
                ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DigestMethod (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  DigestMethod (::DOMDocument& d,
                const ::xmldsig::DigestMethodType& s,
                ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "DigestMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "DigestMethod",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  DigestMethod (const ::xmldsig::DigestMethodType& s,
                const ::xml_schema::NamespaceInfomap& m,
                ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "DigestMethod",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::DigestMethod (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const DigestMethodType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // Algorithm
    //
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Algorithm",
          e));

      a << i.Algorithm ();
    }
  }

  void
  DigestValue (::std::ostream& o,
               const ::xmldsig::DigestValueType& s,
               const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::DigestValue (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
  DigestValue (::std::ostream& o,
               const ::xmldsig::DigestValueType& s,
               ::xml_schema::ErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::DigestValue (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
  DigestValue (::std::ostream& o,
               const ::xmldsig::DigestValueType& s,
               ::DOMErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DigestValue (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
  DigestValue (::XMLFormatTarget& t,
               const ::xmldsig::DigestValueType& s,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DigestValue (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
  DigestValue (::XMLFormatTarget& t,
               const ::xmldsig::DigestValueType& s,
               ::xml_schema::ErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DigestValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  DigestValue (::XMLFormatTarget& t,
               const ::xmldsig::DigestValueType& s,
               ::DOMErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DigestValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  DigestValue (::DOMDocument& d,
               const ::xmldsig::DigestValueType& s,
               ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "DigestValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "DigestValue",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  DigestValue (const ::xmldsig::DigestValueType& s,
               const ::xml_schema::NamespaceInfomap& m,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "DigestValue",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::DigestValue (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const DigestValueType& i)
  {
    e << static_cast< const ::xml_schema::Base64Binary& > (i);
  }

  void
  operator<< (::DOMAttr& a, const DigestValueType& i)
  {
    a << static_cast< const ::xml_schema::Base64Binary& > (i);
  }

  void
  operator<< (::xml_schema::ListStream& l,
              const DigestValueType& i)
  {
    l << static_cast< const ::xml_schema::Base64Binary& > (i);
  }

  void
  KeyInfo (::std::ostream& o,
           const ::xmldsig::KeyInfoType& s,
           const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::KeyInfo (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
  KeyInfo (::std::ostream& o,
           const ::xmldsig::KeyInfoType& s,
           ::xml_schema::ErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::KeyInfo (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
  KeyInfo (::std::ostream& o,
           const ::xmldsig::KeyInfoType& s,
           ::DOMErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyInfo (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
  KeyInfo (::XMLFormatTarget& t,
           const ::xmldsig::KeyInfoType& s,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyInfo (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
  KeyInfo (::XMLFormatTarget& t,
           const ::xmldsig::KeyInfoType& s,
           ::xml_schema::ErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyInfo (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  KeyInfo (::XMLFormatTarget& t,
           const ::xmldsig::KeyInfoType& s,
           ::DOMErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyInfo (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  KeyInfo (::DOMDocument& d,
           const ::xmldsig::KeyInfoType& s,
           ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "KeyInfo" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "KeyInfo",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  KeyInfo (const ::xmldsig::KeyInfoType& s,
           const ::xml_schema::NamespaceInfomap& m,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "KeyInfo",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::KeyInfo (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const KeyInfoType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // KeyName
    //
    for (KeyInfoType::KeyNameConstIterator
         b (i.KeyName ().begin ()), n (i.KeyName ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "KeyName",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // KeyValue
    //
    for (KeyInfoType::KeyValueConstIterator
         b (i.KeyValue ().begin ()), n (i.KeyValue ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "KeyValue",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // RetrievalMethod
    //
    for (KeyInfoType::RetrievalMethodConstIterator
         b (i.RetrievalMethod ().begin ()), n (i.RetrievalMethod ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "RetrievalMethod",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // X509Data
    //
    for (KeyInfoType::X509DataConstIterator
         b (i.X509Data ().begin ()), n (i.X509Data ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "X509Data",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // PGPData
    //
    for (KeyInfoType::PGPDataConstIterator
         b (i.PGPData ().begin ()), n (i.PGPData ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "PGPData",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // SPKIData
    //
    for (KeyInfoType::SPKIDataConstIterator
         b (i.SPKIData ().begin ()), n (i.SPKIData ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SPKIData",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // MgmtData
    //
    for (KeyInfoType::MgmtDataConstIterator
         b (i.MgmtData ().begin ()), n (i.MgmtData ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "MgmtData",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // Id
    //
    if (i.Id ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Id",
          e));

      a << *i.Id ();
    }
  }

  void
  KeyName (::std::ostream& o,
           const ::xml_schema::String& s,
           const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::KeyName (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
  KeyName (::std::ostream& o,
           const ::xml_schema::String& s,
           ::xml_schema::ErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::KeyName (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
  KeyName (::std::ostream& o,
           const ::xml_schema::String& s,
           ::DOMErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyName (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
  KeyName (::XMLFormatTarget& t,
           const ::xml_schema::String& s,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyName (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
  KeyName (::XMLFormatTarget& t,
           const ::xml_schema::String& s,
           ::xml_schema::ErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyName (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  KeyName (::XMLFormatTarget& t,
           const ::xml_schema::String& s,
           ::DOMErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyName (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  KeyName (::DOMDocument& d,
           const ::xml_schema::String& s,
           ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "KeyName" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "KeyName",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  KeyName (const ::xml_schema::String& s,
           const ::xml_schema::NamespaceInfomap& m,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "KeyName",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::KeyName (*d, s, f);
    return d;
  }

  void
  MgmtData (::std::ostream& o,
            const ::xml_schema::String& s,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::MgmtData (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
  MgmtData (::std::ostream& o,
            const ::xml_schema::String& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::MgmtData (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
  MgmtData (::std::ostream& o,
            const ::xml_schema::String& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::MgmtData (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
  MgmtData (::XMLFormatTarget& t,
            const ::xml_schema::String& s,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::MgmtData (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
  MgmtData (::XMLFormatTarget& t,
            const ::xml_schema::String& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::MgmtData (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  MgmtData (::XMLFormatTarget& t,
            const ::xml_schema::String& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::MgmtData (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  MgmtData (::DOMDocument& d,
            const ::xml_schema::String& s,
            ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "MgmtData" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "MgmtData",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  MgmtData (const ::xml_schema::String& s,
            const ::xml_schema::NamespaceInfomap& m,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "MgmtData",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::MgmtData (*d, s, f);
    return d;
  }

  void
  KeyValue (::std::ostream& o,
            const ::xmldsig::KeyValueType& s,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::KeyValue (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
  KeyValue (::std::ostream& o,
            const ::xmldsig::KeyValueType& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::KeyValue (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
  KeyValue (::std::ostream& o,
            const ::xmldsig::KeyValueType& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyValue (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
  KeyValue (::XMLFormatTarget& t,
            const ::xmldsig::KeyValueType& s,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyValue (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
  KeyValue (::XMLFormatTarget& t,
            const ::xmldsig::KeyValueType& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  KeyValue (::XMLFormatTarget& t,
            const ::xmldsig::KeyValueType& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::KeyValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  KeyValue (::DOMDocument& d,
            const ::xmldsig::KeyValueType& s,
            ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "KeyValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "KeyValue",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  KeyValue (const ::xmldsig::KeyValueType& s,
            const ::xml_schema::NamespaceInfomap& m,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "KeyValue",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::KeyValue (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const KeyValueType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // DSAKeyValue
    //
    if (i.DSAKeyValue ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "DSAKeyValue",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.DSAKeyValue ();
    }

    // RSAKeyValue
    //
    if (i.RSAKeyValue ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "RSAKeyValue",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

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

  void
  RetrievalMethod (::std::ostream& o,
                   const ::xmldsig::RetrievalMethodType& s,
                   const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::RetrievalMethod (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
  RetrievalMethod (::std::ostream& o,
                   const ::xmldsig::RetrievalMethodType& s,
                   ::xml_schema::ErrorHandler& h,
                   const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::RetrievalMethod (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
  RetrievalMethod (::std::ostream& o,
                   const ::xmldsig::RetrievalMethodType& s,
                   ::DOMErrorHandler& h,
                   const ::xml_schema::NamespaceInfomap& m,
                   const ::std::string& e,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::RetrievalMethod (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
  RetrievalMethod (::XMLFormatTarget& t,
                   const ::xmldsig::RetrievalMethodType& s,
                   const ::xml_schema::NamespaceInfomap& m,
                   const ::std::string& e,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::RetrievalMethod (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
  RetrievalMethod (::XMLFormatTarget& t,
                   const ::xmldsig::RetrievalMethodType& s,
                   ::xml_schema::ErrorHandler& h,
                   const ::xml_schema::NamespaceInfomap& m,
                   const ::std::string& e,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::RetrievalMethod (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  RetrievalMethod (::XMLFormatTarget& t,
                   const ::xmldsig::RetrievalMethodType& s,
                   ::DOMErrorHandler& h,
                   const ::xml_schema::NamespaceInfomap& m,
                   const ::std::string& e,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::RetrievalMethod (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  RetrievalMethod (::DOMDocument& d,
                   const ::xmldsig::RetrievalMethodType& s,
                   ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "RetrievalMethod" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "RetrievalMethod",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  RetrievalMethod (const ::xmldsig::RetrievalMethodType& s,
                   const ::xml_schema::NamespaceInfomap& m,
                   ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "RetrievalMethod",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::RetrievalMethod (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const RetrievalMethodType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // Transforms
    //
    if (i.Transforms ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Transforms",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.Transforms ();
    }

    // URI
    //
    if (i.URI ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "URI",
          e));

      a << *i.URI ();
    }

    // Type
    //
    if (i.Type ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Type",
          e));

      a << *i.Type ();
    }
  }

  void
  X509Data (::std::ostream& o,
            const ::xmldsig::X509DataType& s,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::X509Data (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
  X509Data (::std::ostream& o,
            const ::xmldsig::X509DataType& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::X509Data (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
  X509Data (::std::ostream& o,
            const ::xmldsig::X509DataType& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::X509Data (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
  X509Data (::XMLFormatTarget& t,
            const ::xmldsig::X509DataType& s,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::X509Data (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
  X509Data (::XMLFormatTarget& t,
            const ::xmldsig::X509DataType& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::X509Data (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  X509Data (::XMLFormatTarget& t,
            const ::xmldsig::X509DataType& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::X509Data (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  X509Data (::DOMDocument& d,
            const ::xmldsig::X509DataType& s,
            ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "X509Data" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "X509Data",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  X509Data (const ::xmldsig::X509DataType& s,
            const ::xml_schema::NamespaceInfomap& m,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "X509Data",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::X509Data (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const X509DataType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // X509IssuerSerial
    //
    for (X509DataType::X509IssuerSerialConstIterator
         b (i.X509IssuerSerial ().begin ()), n (i.X509IssuerSerial ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "X509IssuerSerial",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // X509SKI
    //
    for (X509DataType::X509SKIConstIterator
         b (i.X509SKI ().begin ()), n (i.X509SKI ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "X509SKI",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // X509SubjectName
    //
    for (X509DataType::X509SubjectNameConstIterator
         b (i.X509SubjectName ().begin ()), n (i.X509SubjectName ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "X509SubjectName",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // X509Certificate
    //
    for (X509DataType::X509CertificateConstIterator
         b (i.X509Certificate ().begin ()), n (i.X509Certificate ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "X509Certificate",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // X509CRL
    //
    for (X509DataType::X509CRLConstIterator
         b (i.X509CRL ().begin ()), n (i.X509CRL ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "X509CRL",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }
  }

  void
  operator<< (::DOMElement& e, const X509IssuerSerialType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // X509IssuerName
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "X509IssuerName",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.X509IssuerName ();
    }

    // X509SerialNumber
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "X509SerialNumber",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.X509SerialNumber ();
    }
  }

  void
  PGPData (::std::ostream& o,
           const ::xmldsig::PGPDataType& s,
           const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::PGPData (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
  PGPData (::std::ostream& o,
           const ::xmldsig::PGPDataType& s,
           ::xml_schema::ErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::PGPData (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
  PGPData (::std::ostream& o,
           const ::xmldsig::PGPDataType& s,
           ::DOMErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::PGPData (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
  PGPData (::XMLFormatTarget& t,
           const ::xmldsig::PGPDataType& s,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::PGPData (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
  PGPData (::XMLFormatTarget& t,
           const ::xmldsig::PGPDataType& s,
           ::xml_schema::ErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::PGPData (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  PGPData (::XMLFormatTarget& t,
           const ::xmldsig::PGPDataType& s,
           ::DOMErrorHandler& h,
           const ::xml_schema::NamespaceInfomap& m,
           const ::std::string& e,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::PGPData (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  PGPData (::DOMDocument& d,
           const ::xmldsig::PGPDataType& s,
           ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "PGPData" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "PGPData",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  PGPData (const ::xmldsig::PGPDataType& s,
           const ::xml_schema::NamespaceInfomap& m,
           ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "PGPData",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::PGPData (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const PGPDataType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // PGPKeyID
    //
    if (i.PGPKeyID ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "PGPKeyID",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.PGPKeyID ();
    }

    // PGPKeyPacket
    //
    if (i.PGPKeyPacket ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "PGPKeyPacket",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

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

  void
  SPKIData (::std::ostream& o,
            const ::xmldsig::SPKIDataType& s,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SPKIData (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
  SPKIData (::std::ostream& o,
            const ::xmldsig::SPKIDataType& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SPKIData (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
  SPKIData (::std::ostream& o,
            const ::xmldsig::SPKIDataType& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SPKIData (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
  SPKIData (::XMLFormatTarget& t,
            const ::xmldsig::SPKIDataType& s,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SPKIData (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
  SPKIData (::XMLFormatTarget& t,
            const ::xmldsig::SPKIDataType& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SPKIData (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SPKIData (::XMLFormatTarget& t,
            const ::xmldsig::SPKIDataType& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SPKIData (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SPKIData (::DOMDocument& d,
            const ::xmldsig::SPKIDataType& s,
            ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "SPKIData" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "SPKIData",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  SPKIData (const ::xmldsig::SPKIDataType& s,
            const ::xml_schema::NamespaceInfomap& m,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "SPKIData",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::SPKIData (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const SPKIDataType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // SPKISexp
    //
    for (SPKIDataType::SPKISexpConstIterator
         b (i.SPKISexp ().begin ()), n (i.SPKISexp ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SPKISexp",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }
  }

  void
  Object (::std::ostream& o,
          const ::xmldsig::ObjectType& s,
          const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Object (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
  Object (::std::ostream& o,
          const ::xmldsig::ObjectType& s,
          ::xml_schema::ErrorHandler& h,
          const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Object (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
  Object (::std::ostream& o,
          const ::xmldsig::ObjectType& s,
          ::DOMErrorHandler& h,
          const ::xml_schema::NamespaceInfomap& m,
          const ::std::string& e,
          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Object (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
  Object (::XMLFormatTarget& t,
          const ::xmldsig::ObjectType& s,
          const ::xml_schema::NamespaceInfomap& m,
          const ::std::string& e,
          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Object (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
  Object (::XMLFormatTarget& t,
          const ::xmldsig::ObjectType& s,
          ::xml_schema::ErrorHandler& h,
          const ::xml_schema::NamespaceInfomap& m,
          const ::std::string& e,
          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Object (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Object (::XMLFormatTarget& t,
          const ::xmldsig::ObjectType& s,
          ::DOMErrorHandler& h,
          const ::xml_schema::NamespaceInfomap& m,
          const ::std::string& e,
          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Object (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Object (::DOMDocument& d,
          const ::xmldsig::ObjectType& s,
          ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "Object" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "Object",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  Object (const ::xmldsig::ObjectType& s,
          const ::xml_schema::NamespaceInfomap& m,
          ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "Object",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::Object (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const ObjectType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // Id
    //
    if (i.Id ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Id",
          e));

      a << *i.Id ();
    }

    // MimeType
    //
    if (i.MimeType ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "MimeType",
          e));

      a << *i.MimeType ();
    }

    // Encoding
    //
    if (i.Encoding ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Encoding",
          e));

      a << *i.Encoding ();
    }
  }

  void
  Manifest (::std::ostream& o,
            const ::xmldsig::ManifestType& s,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Manifest (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
  Manifest (::std::ostream& o,
            const ::xmldsig::ManifestType& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::Manifest (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
  Manifest (::std::ostream& o,
            const ::xmldsig::ManifestType& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Manifest (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
  Manifest (::XMLFormatTarget& t,
            const ::xmldsig::ManifestType& s,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Manifest (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
  Manifest (::XMLFormatTarget& t,
            const ::xmldsig::ManifestType& s,
            ::xml_schema::ErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Manifest (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Manifest (::XMLFormatTarget& t,
            const ::xmldsig::ManifestType& s,
            ::DOMErrorHandler& h,
            const ::xml_schema::NamespaceInfomap& m,
            const ::std::string& e,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::Manifest (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  Manifest (::DOMDocument& d,
            const ::xmldsig::ManifestType& s,
            ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "Manifest" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "Manifest",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  Manifest (const ::xmldsig::ManifestType& s,
            const ::xml_schema::NamespaceInfomap& m,
            ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "Manifest",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::Manifest (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const ManifestType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // Reference
    //
    for (ManifestType::ReferenceConstIterator
         b (i.Reference ().begin ()), n (i.Reference ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Reference",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // Id
    //
    if (i.Id ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Id",
          e));

      a << *i.Id ();
    }
  }

  void
  SignatureProperties (::std::ostream& o,
                       const ::xmldsig::SignaturePropertiesType& s,
                       const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignatureProperties (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
  SignatureProperties (::std::ostream& o,
                       const ::xmldsig::SignaturePropertiesType& s,
                       ::xml_schema::ErrorHandler& h,
                       const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignatureProperties (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
  SignatureProperties (::std::ostream& o,
                       const ::xmldsig::SignaturePropertiesType& s,
                       ::DOMErrorHandler& h,
                       const ::xml_schema::NamespaceInfomap& m,
                       const ::std::string& e,
                       ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureProperties (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
  SignatureProperties (::XMLFormatTarget& t,
                       const ::xmldsig::SignaturePropertiesType& s,
                       const ::xml_schema::NamespaceInfomap& m,
                       const ::std::string& e,
                       ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureProperties (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
  SignatureProperties (::XMLFormatTarget& t,
                       const ::xmldsig::SignaturePropertiesType& s,
                       ::xml_schema::ErrorHandler& h,
                       const ::xml_schema::NamespaceInfomap& m,
                       const ::std::string& e,
                       ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureProperties (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignatureProperties (::XMLFormatTarget& t,
                       const ::xmldsig::SignaturePropertiesType& s,
                       ::DOMErrorHandler& h,
                       const ::xml_schema::NamespaceInfomap& m,
                       const ::std::string& e,
                       ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureProperties (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignatureProperties (::DOMDocument& d,
                       const ::xmldsig::SignaturePropertiesType& s,
                       ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "SignatureProperties" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "SignatureProperties",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  SignatureProperties (const ::xmldsig::SignaturePropertiesType& s,
                       const ::xml_schema::NamespaceInfomap& m,
                       ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "SignatureProperties",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::SignatureProperties (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const SignaturePropertiesType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // SignatureProperty
    //
    for (SignaturePropertiesType::SignaturePropertyConstIterator
         b (i.SignatureProperty ().begin ()), n (i.SignatureProperty ().end ());
         b != n; ++b)
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "SignatureProperty",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *b;
    }

    // Id
    //
    if (i.Id ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Id",
          e));

      a << *i.Id ();
    }
  }

  void
  SignatureProperty (::std::ostream& o,
                     const ::xmldsig::SignaturePropertyType& s,
                     const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignatureProperty (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
  SignatureProperty (::std::ostream& o,
                     const ::xmldsig::SignaturePropertyType& s,
                     ::xml_schema::ErrorHandler& h,
                     const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::SignatureProperty (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
  SignatureProperty (::std::ostream& o,
                     const ::xmldsig::SignaturePropertyType& s,
                     ::DOMErrorHandler& h,
                     const ::xml_schema::NamespaceInfomap& m,
                     const ::std::string& e,
                     ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureProperty (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
  SignatureProperty (::XMLFormatTarget& t,
                     const ::xmldsig::SignaturePropertyType& s,
                     const ::xml_schema::NamespaceInfomap& m,
                     const ::std::string& e,
                     ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureProperty (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
  SignatureProperty (::XMLFormatTarget& t,
                     const ::xmldsig::SignaturePropertyType& s,
                     ::xml_schema::ErrorHandler& h,
                     const ::xml_schema::NamespaceInfomap& m,
                     const ::std::string& e,
                     ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureProperty (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignatureProperty (::XMLFormatTarget& t,
                     const ::xmldsig::SignaturePropertyType& s,
                     ::DOMErrorHandler& h,
                     const ::xml_schema::NamespaceInfomap& m,
                     const ::std::string& e,
                     ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::SignatureProperty (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  SignatureProperty (::DOMDocument& d,
                     const ::xmldsig::SignaturePropertyType& s,
                     ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "SignatureProperty" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "SignatureProperty",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  SignatureProperty (const ::xmldsig::SignaturePropertyType& s,
                     const ::xml_schema::NamespaceInfomap& m,
                     ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "SignatureProperty",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::SignatureProperty (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const SignaturePropertyType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // Target
    //
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Target",
          e));

      a << i.Target ();
    }

    // Id
    //
    if (i.Id ())
    {
      ::DOMAttr& a (
        ::xsd::cxx::xml::dom::create_attribute (
          "Id",
          e));

      a << *i.Id ();
    }
  }

  void
  operator<< (::DOMElement& e, const HMACOutputLengthType& i)
  {
    e << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::Integer, char, ::xml_schema::SimpleType >& > (i);
  }

  void
  operator<< (::DOMAttr& a, const HMACOutputLengthType& i)
  {
    a << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::Integer, char, ::xml_schema::SimpleType >& > (i);
  }

  void
  operator<< (::xml_schema::ListStream& l,
              const HMACOutputLengthType& i)
  {
    l << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::Integer, char, ::xml_schema::SimpleType >& > (i);
  }

  void
  DSAKeyValue (::std::ostream& o,
               const ::xmldsig::DSAKeyValueType& s,
               const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::DSAKeyValue (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
  DSAKeyValue (::std::ostream& o,
               const ::xmldsig::DSAKeyValueType& s,
               ::xml_schema::ErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::DSAKeyValue (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
  DSAKeyValue (::std::ostream& o,
               const ::xmldsig::DSAKeyValueType& s,
               ::DOMErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DSAKeyValue (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
  DSAKeyValue (::XMLFormatTarget& t,
               const ::xmldsig::DSAKeyValueType& s,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DSAKeyValue (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
  DSAKeyValue (::XMLFormatTarget& t,
               const ::xmldsig::DSAKeyValueType& s,
               ::xml_schema::ErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DSAKeyValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  DSAKeyValue (::XMLFormatTarget& t,
               const ::xmldsig::DSAKeyValueType& s,
               ::DOMErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::DSAKeyValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  DSAKeyValue (::DOMDocument& d,
               const ::xmldsig::DSAKeyValueType& s,
               ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "DSAKeyValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "DSAKeyValue",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  DSAKeyValue (const ::xmldsig::DSAKeyValueType& s,
               const ::xml_schema::NamespaceInfomap& m,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "DSAKeyValue",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::DSAKeyValue (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const DSAKeyValueType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // P
    //
    if (i.P ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "P",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.P ();
    }

    // Q
    //
    if (i.Q ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Q",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.Q ();
    }

    // G
    //
    if (i.G ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "G",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.G ();
    }

    // Y
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Y",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.Y ();
    }

    // J
    //
    if (i.J ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "J",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.J ();
    }

    // Seed
    //
    if (i.Seed ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Seed",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << *i.Seed ();
    }

    // PgenCounter
    //
    if (i.PgenCounter ())
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "PgenCounter",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

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

  void
  RSAKeyValue (::std::ostream& o,
               const ::xmldsig::RSAKeyValueType& s,
               const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::RSAKeyValue (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
  RSAKeyValue (::std::ostream& o,
               const ::xmldsig::RSAKeyValueType& s,
               ::xml_schema::ErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& 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< ::DOMDocument > d (
      ::xmldsig::RSAKeyValue (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
  RSAKeyValue (::std::ostream& o,
               const ::xmldsig::RSAKeyValueType& s,
               ::DOMErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::RSAKeyValue (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
  RSAKeyValue (::XMLFormatTarget& t,
               const ::xmldsig::RSAKeyValueType& s,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::RSAKeyValue (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
  RSAKeyValue (::XMLFormatTarget& t,
               const ::xmldsig::RSAKeyValueType& s,
               ::xml_schema::ErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::RSAKeyValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  RSAKeyValue (::XMLFormatTarget& t,
               const ::xmldsig::RSAKeyValueType& s,
               ::DOMErrorHandler& h,
               const ::xml_schema::NamespaceInfomap& m,
               const ::std::string& e,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xmldsig::RSAKeyValue (s, m, f));
    if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
    {
      throw ::xsd::cxx::tree::serialization< char > ();
    }
  }

  void
  RSAKeyValue (::DOMDocument& d,
               const ::xmldsig::RSAKeyValueType& s,
               ::xml_schema::Flags)
  {
    ::DOMElement& e (*d.getDocumentElement ());
    const ::xsd::cxx::xml::qualified_name< char > n (
      ::xsd::cxx::xml::dom::name< char > (e));

    if (n.name () == "RSAKeyValue" &&
        n.namespace_ () == "http://www.w3.org/2000/09/xmldsig#")
    {
      e << s;
    }
    else
    {
      throw ::xsd::cxx::tree::unexpected_element < char > (
        n.name (),
        n.namespace_ (),
        "RSAKeyValue",
        "http://www.w3.org/2000/09/xmldsig#");
    }
  }

  ::xml_schema::dom::auto_ptr< ::DOMDocument >
  RSAKeyValue (const ::xmldsig::RSAKeyValueType& s,
               const ::xml_schema::NamespaceInfomap& m,
               ::xml_schema::Flags f)
  {
    ::xml_schema::dom::auto_ptr< ::DOMDocument > d (
      ::xsd::cxx::xml::dom::serialize< char > (
        "RSAKeyValue",
        "http://www.w3.org/2000/09/xmldsig#",
        m, f));

    ::xmldsig::RSAKeyValue (*d, s, f);
    return d;
  }

  void
  operator<< (::DOMElement& e, const RSAKeyValueType& i)
  {
    e << static_cast< const ::xml_schema::Type& > (i);

    // Modulus
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Modulus",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.Modulus ();
    }

    // Exponent
    //
    {
      ::DOMElement& s (
        ::xsd::cxx::xml::dom::create_element (
          "Exponent",
          "http://www.w3.org/2000/09/xmldsig#",
          e));

      s << i.Exponent ();
    }
  }
}

#include <xsd/cxx/post.hxx>

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