// **********************************************************************
//
// Generated by the ORBacus IDL-to-C++ Translator
//
// Copyright (c) 1999
// Object Oriented Concepts, Inc.
// Billerica, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

// Version: 3.2
// License: non-commercial

#include <OB/CORBA.h>
#include <OB/TemplateI.h>
#include <Types.h>

#ifndef OB_INTEGER_VERSION
#   error No ORBacus version defined!
#endif

#ifndef OB_NO_VERSION_CHECK
#   if (OB_INTEGER_VERSION != 3020000L)
#       error ORBacus version mismatch!
#   endif
#endif

//
// IDL:ooc.com/IdlDeclarator:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< IdlDeclarator >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< IdlDeclarator >)
#endif
#endif

IdlDeclarator::IdlDeclarator(const IdlDeclarator& _ob_a)
    : identifier(_ob_a.identifier),
      sizes(_ob_a.sizes)
{
}

IdlDeclarator&
IdlDeclarator::operator=(const IdlDeclarator& _ob_a)
{
    if(this != &_ob_a)
    {
        identifier = _ob_a.identifier;
        sizes = _ob_a.sizes;
    }
    return *this;
}

void
OBMarshal(const IdlDeclarator& val, CORBA_Octet*& oct)
{
    OBMarshal(val.identifier.in(), oct);
    OBMarshal(val.sizes, oct);
}

void
OBMarshalCount(const IdlDeclarator& val, CORBA_ULong& count)
{
    OBMarshalCount(val.identifier.in(), count);
    OBMarshalCount(val.sizes, count);
}

void
OBUnmarshal(IdlDeclarator& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.identifier.inout(), coct, swap);
    OBUnmarshal(val.sizes, coct, swap);
}

//
// IDL:ooc.com/IdlComment:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< IdlComment >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< IdlComment >)
#endif
#endif

IdlComment::IdlComment(const IdlComment& _ob_a)
    : id(_ob_a.id),
      comment(_ob_a.comment)
{
}

IdlComment&
IdlComment::operator=(const IdlComment& _ob_a)
{
    if(this != &_ob_a)
    {
        id = _ob_a.id;
        comment = _ob_a.comment;
    }
    return *this;
}

void
OBMarshal(const IdlComment& val, CORBA_Octet*& oct)
{
    OBMarshal(val.id.in(), oct);
    OBMarshal(val.comment.in(), oct);
}

void
OBMarshalCount(const IdlComment& val, CORBA_ULong& count)
{
    OBMarshalCount(val.id.in(), count);
    OBMarshalCount(val.comment.in(), count);
}

void
OBUnmarshal(IdlComment& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.id.inout(), coct, swap);
    OBUnmarshal(val.comment.inout(), coct, swap);
}

//
// IDL:ooc.com/IdlUnionMemberInfo:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< IdlUnionMemberInfo >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< IdlUnionMemberInfo >)
#endif
#endif

#ifdef OB_CLEAR_MEM
IdlUnionMemberInfo::IdlUnionMemberInfo()
{
    memset(&isDefault, 0, sizeof(isDefault));
}
#endif

IdlUnionMemberInfo::IdlUnionMemberInfo(const IdlUnionMemberInfo& _ob_a)
    : name(_ob_a.name),
      type(_ob_a.type),
      pLabels(_ob_a.pLabels),
      nLabels(_ob_a.nLabels),
      isDefault(_ob_a.isDefault)
{
}

IdlUnionMemberInfo&
IdlUnionMemberInfo::operator=(const IdlUnionMemberInfo& _ob_a)
{
    if(this != &_ob_a)
    {
        name = _ob_a.name;
        type = _ob_a.type;
        pLabels = _ob_a.pLabels;
        nLabels = _ob_a.nLabels;
        isDefault = _ob_a.isDefault;
    }
    return *this;
}

void
OBMarshal(const IdlUnionMemberInfo& val, CORBA_Octet*& oct)
{
    OBMarshal(val.name.in(), oct);
    OBMarshal(val.type.in(), oct);
    OBMarshal(val.pLabels, oct);
    OBMarshal(val.nLabels, oct);
    OBMarshal(val.isDefault, oct);
}

void
OBMarshalCount(const IdlUnionMemberInfo& val, CORBA_ULong& count)
{
    OBMarshalCount(val.name.in(), count);
    OBMarshalCount(val.type.in(), count);
    OBMarshalCount(val.pLabels, count);
    OBMarshalCount(val.nLabels, count);
    OBMarshalCount(val.isDefault, count);
}

void
OBUnmarshal(IdlUnionMemberInfo& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.name.inout(), coct, swap);
    OBUnmarshal(val.type.inout(), coct, swap);
    OBUnmarshal(val.pLabels, coct, swap);
    OBUnmarshal(val.nLabels, coct, swap);
    OBUnmarshal(val.isDefault, coct, swap);
}

//
// IDL:ooc.com/IdlPrefixPackage:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< IdlPrefixPackage >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarVar< IdlPrefixPackage >)
#endif
#endif

IdlPrefixPackage::IdlPrefixPackage(const IdlPrefixPackage& _ob_a)
    : prefix(_ob_a.prefix),
      package(_ob_a.package)
{
}

IdlPrefixPackage&
IdlPrefixPackage::operator=(const IdlPrefixPackage& _ob_a)
{
    if(this != &_ob_a)
    {
        prefix = _ob_a.prefix;
        package = _ob_a.package;
    }
    return *this;
}

void
OBMarshal(const IdlPrefixPackage& val, CORBA_Octet*& oct)
{
    OBMarshal(val.prefix.in(), oct);
    OBMarshal(val.package.in(), oct);
}

void
OBMarshalCount(const IdlPrefixPackage& val, CORBA_ULong& count)
{
    OBMarshalCount(val.prefix.in(), count);
    OBMarshalCount(val.package.in(), count);
}

void
OBUnmarshal(IdlPrefixPackage& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.prefix.inout(), coct, swap);
    OBUnmarshal(val.package.inout(), coct, swap);
}

//
// OBStrSeq
//
#ifdef OB_use_OBStrSeq_from_Types_h

#endif

//
// OBVarSeq< OBStrSeq >
//
#ifdef OB_use_OBVarSeq_OBStrSeq_from_Types_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< OBStrSeq >;
template class OBSeqVar< OBVarSeq< OBStrSeq > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< OBStrSeq >)
#pragma define(OBSeqVar< OBVarSeq< OBStrSeq > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< OBStrSeq >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< OBStrSeq >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< OBStrSeq >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

#endif

//
// OBVarSeq< CORBA_Any >
//
#ifdef OB_use_OBVarSeq_CORBA__Any_from_Types_h

#endif

//
// OBFixSeq< CORBA_ULong >
//
#ifdef OB_use_OBFixSeq_CORBA__ULong_from_Types_h

#endif

//
// OBVarSeq< IdlDeclarator >
//
#ifdef OB_use_OBVarSeq_IdlDeclarator_from_Types_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< IdlDeclarator >;
template class OBSeqVar< OBVarSeq< IdlDeclarator > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< IdlDeclarator >)
#pragma define(OBSeqVar< OBVarSeq< IdlDeclarator > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< IdlDeclarator >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< IdlDeclarator >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< IdlDeclarator >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

#endif

//
// OBVarSeq< IdlComment >
//
#ifdef OB_use_OBVarSeq_IdlComment_from_Types_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< IdlComment >;
template class OBSeqVar< OBVarSeq< IdlComment > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< IdlComment >)
#pragma define(OBSeqVar< OBVarSeq< IdlComment > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< IdlComment >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< IdlComment >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< IdlComment >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

#endif

//
// OBVarSeq< IdlUnionMemberInfo >
//
#ifdef OB_use_OBVarSeq_IdlUnionMemberInfo_from_Types_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< IdlUnionMemberInfo >;
template class OBSeqVar< OBVarSeq< IdlUnionMemberInfo > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< IdlUnionMemberInfo >)
#pragma define(OBSeqVar< OBVarSeq< IdlUnionMemberInfo > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< IdlUnionMemberInfo >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< IdlUnionMemberInfo >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< IdlUnionMemberInfo >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

#endif

//
// OBVarSeq< IdlPrefixPackage >
//
#ifdef OB_use_OBVarSeq_IdlPrefixPackage_from_Types_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< IdlPrefixPackage >;
template class OBSeqVar< OBVarSeq< IdlPrefixPackage > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBVarSeq< IdlPrefixPackage >)
#pragma define(OBSeqVar< OBVarSeq< IdlPrefixPackage > >)
#endif
#endif

void
OBMarshal(const OBVarSeq< IdlPrefixPackage >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< IdlPrefixPackage >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< IdlPrefixPackage >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

#endif

//
// OBObjSeq< CORBA_Container >
//
#ifdef OB_use_OBObjSeq_CORBA__Container_from_Types_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjSeq< CORBA_Container >;
template class OBSeqVar< OBObjSeq< CORBA_Container > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjSeq< CORBA_Container >)
#pragma define(OBSeqVar< OBObjSeq< CORBA_Container > >)
#endif
#endif

void
OBMarshal(const OBObjSeq< CORBA_Container >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBObjSeq< CORBA_Container >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBObjSeq< CORBA_Container >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i].inout(), coct, swap);
}

#endif

//
// OBObjSeq< CORBA_StringDef >
//
#ifdef OB_use_OBObjSeq_CORBA__StringDef_from_Types_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjSeq< CORBA_StringDef >;
template class OBSeqVar< OBObjSeq< CORBA_StringDef > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjSeq< CORBA_StringDef >)
#pragma define(OBSeqVar< OBObjSeq< CORBA_StringDef > >)
#endif
#endif

void
OBMarshal(const OBObjSeq< CORBA_StringDef >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBObjSeq< CORBA_StringDef >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBObjSeq< CORBA_StringDef >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i].inout(), coct, swap);
}

#endif

//
// OBObjSeq< CORBA_SequenceDef >
//
#ifdef OB_use_OBObjSeq_CORBA__SequenceDef_from_Types_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjSeq< CORBA_SequenceDef >;
template class OBSeqVar< OBObjSeq< CORBA_SequenceDef > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjSeq< CORBA_SequenceDef >)
#pragma define(OBSeqVar< OBObjSeq< CORBA_SequenceDef > >)
#endif
#endif

void
OBMarshal(const OBObjSeq< CORBA_SequenceDef >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBObjSeq< CORBA_SequenceDef >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBObjSeq< CORBA_SequenceDef >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i].inout(), coct, swap);
}

#endif

//
// OBObjSeq< CORBA_ArrayDef >
//
#ifdef OB_use_OBObjSeq_CORBA__ArrayDef_from_Types_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjSeq< CORBA_ArrayDef >;
template class OBSeqVar< OBObjSeq< CORBA_ArrayDef > >;
#else
#ifdef HAVE_PRAGMA_DEFINE
#pragma define(OBObjSeq< CORBA_ArrayDef >)
#pragma define(OBSeqVar< OBObjSeq< CORBA_ArrayDef > >)
#endif
#endif

void
OBMarshal(const OBObjSeq< CORBA_ArrayDef >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBObjSeq< CORBA_ArrayDef >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBObjSeq< CORBA_ArrayDef >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i].inout(), coct, swap);
}

#endif
