msd_xml_xsd.cc

//--------------------------------
// msd_xml_xsd.cc
//
// Project: PDBe API Framework, EBI 
// Module: implementation of SOAP xml schema definition Classes for PDBe API Framework 
//
// SOAP User Layer
// Last updated: 25 February 2004 10:17
// (C) Siamak Sobhany
//--------------------------------

#include "msd_xml_xsd.h"
using namespace std;
//
//  XSD schema class hierarchy
//

xsd__anyType::xsd__anyType()
{ soap = NULL;                  // This will be set by gSOAP environment later (upon deserialization or calling soap_new_X()
}


xsd__anyType::~xsd__anyType()
{ soap_unlink(soap, this);      // Let gSOAP not deallocate this object again if this object was explicitly removed
}
xsd__anyType*& xsd__anyType::operator[](int i)
{ static xsd__anyType *p = this;        // trick: we don't expect the operator to be applied, but we need a method
  return p;
}
void xsd__anyType::fprint(ofstream& s) const
{
//printf("%s", __item);
s << "<anyType>"; // __item;
}
void xsd__anyType::print(std::ostream& s) const
{
//printf("%s", __item);
s << "<anyType>"; // __item;
}
void xsd__anyType::setst(msdbStream& s){

s << __item;
msd_val = msdConst(__item);
}
void xsd__anyType::getst(msdbStream& s){

s >> __item;
msd_val = msdConst(__item);
}
void xsd__anyType::set(char* s){
//this->__item=s;
}


xsd__anySimpleType::xsd__anySimpleType()
{ }

xsd__anySimpleType::~xsd__anySimpleType()
{ }
void xsd__anySimpleType::fprint(ofstream& s) const
{
//printf("%s", __item);
s << "<anySimpleType>"; // __item;
}
void xsd__anySimpleType::print(std::ostream& s) const
{
//printf("%s", __item);
s << "<anySimpleType>"; // __item;
}
void xsd__anySimpleType::setst(msdbStream& s)
{
s << __item;
}
void xsd__anySimpleType::getst(msdbStream& s)
{
s >> __item; 
msd_val = msdConst(__item);
}
//}
//void xsd__anySimpleType::set(double d){
//}
//void xsd__anySimpleType::set(bool b){
//}
//void xsd__anySimpleType::set(float f){
//}
//void xsd__anySimpleType::set(int i){
//}

xsd__anyURI::xsd__anyURI()
{ }
//xsd__anyURI::xsd__anyURI(xsd__anyURI& src)
//{src.__item = __item;
// src.msd_sym = msd_sym;
// src.msd_val = msd_val;  
//}
xsd__anyURI::~xsd__anyURI()
{ }
xsd__anyURI::xsd__anyURI(char *s)
{ __item = s;
 
}
void xsd__anyURI::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__anyURI::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__anyURI::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__anyURI::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
//void xsd__anyURI::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
// __item = s;
// }

xsd__boolean::xsd__boolean()
{ }
//xsd__boolean::xsd__boolean(xsd__boolean& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__boolean::~xsd__boolean()
{ }
xsd__boolean::xsd__boolean(bool b)
{ __item = b;
  }
void xsd__boolean::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__boolean::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__boolean::setst(msdbStream& s)
{ 
 if (__item == true)
 s << 1;
 else
 s << 0;
}
void xsd__boolean::getst(msdbStream& s)
{int lv; 
 s >> lv;
 if (lv == 0)
  __item =false;
 else
 __item =true;
msd_val = msdConst(lv);
}
void xsd__boolean::set(bool& b){
__item = b;
 }

xsd__date::xsd__date()
{ }
//xsd__date::xsd__date(xsd__date& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__date::~xsd__date()
{ }
xsd__date::xsd__date(char *s)
{ __item = s;
 }
void xsd__date::fprint(ofstream& s) const
{ 

//s << this->__item;
s <<__item;
}
void xsd__date::print(std::ostream& s) const
{ 

//s << this->__item;
s <<__item;
}
void xsd__date::setst(msdbStream& s)
{ 
 otl_datetime otl_item;
 // str2otl_datetime(__item, otl_item); // not implemented yet!
 s <<otl_item;
}
void xsd__date::getst(msdbStream& s)
{
otl_datetime otl_item;
s >> otl_item;
__item=(char*)soap_malloc(soap, 11);
sprintf(__item,"%d-%d-%d",otl_item.year,otl_item.month,otl_item.day);
msd_val = msdConst(__item);
}
//void xsd__date::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
//__item = s;
// }

xsd__dateTime::xsd__dateTime()
{ }
//xsd__dateTime::xsd__dateTime(xsd__dateTime& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__dateTime::~xsd__dateTime()
{ }
xsd__dateTime::xsd__dateTime(time_t t)
{ __item = t;
}
void xsd__dateTime::fprint(ofstream& s) const
{
//s << this->__item;
s << __item;
}
void xsd__dateTime::print(std::ostream& s) const
{
//s << this->__item;
s << __item;
}
void xsd__dateTime::setst(msdbStream& s)
{otl_datetime tv;
 tv.second=__item;
s <<tv;
}
void xsd__dateTime::getst(msdbStream& s)
{otl_datetime tv;
s >> tv;
__item=tv.second;
msd_val = msdConst(int (__item));
}
void xsd__dateTime::set(time_t& t){
        __item = t;
        
        //this->msd_val = msdConst(t);
 }

xsd__double::xsd__double()
{ }
//xsd__double::xsd__double(xsd__double& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__double::~xsd__double()
{ }
xsd__double::xsd__double(double d)
{ __item = d;
 }
void xsd__double::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__double::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__double::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__double::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
void xsd__double::set(double& d){
        __item = d;
}

xsd__duration::xsd__duration()
{ }
//xsd__duration::xsd__duration(xsd__duration& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__duration::~xsd__duration()
{ }
xsd__duration::xsd__duration(char *s)
{ __item = s;
}
void xsd__duration::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__duration::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__duration::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__duration::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
//void xsd__duration::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
//__item = s;
// }

xsd__float::xsd__float()
{ }
//xsd__float::xsd__float(xsd__float& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__float::~xsd__float()
{ }
xsd__float::xsd__float(float f)
{ __item = f;
}
void xsd__float::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__float::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__float::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__float::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
void xsd__float::set(float& f){
        __item = f;
        //this->msd_val=C(f);
 }

xsd__time::xsd__time()
{ }
//xsd__time::xsd__time(xsd__time& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__time::~xsd__time()
{ }
xsd__time::xsd__time(char *s)
{ __item = s;
}
void xsd__time::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__time::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__time::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__time::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}

//void xsd__time::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
//__item = s;
// }

xsd__string::xsd__string()
{ }
//xsd__string::xsd__string(xsd__string& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__string::~xsd__string()
{//if (__item)
 //soap_dealloc(soap, __item); 
 }

xsd__string::xsd__string(int size)
{//if (__item)
 //soap_dealloc(soap, __item);
        __item=(char*)soap_malloc(soap, size);
        
  
}

xsd__string::xsd__string(char *s)
{ //if (__item)
  //soap_dealloc(soap, __item);
        __item=(char*)soap_malloc(soap, strlen(s)+1);
   sprintf(__item,"%s",s);
  //__item = s;
 }
void xsd__string::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__string::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__string::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__string::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
 void xsd__string::set(char* s){
        //if (__item)
 //free(__item);
 __item=(char*)soap_malloc(soap, strlen(s)+1);
 sprintf(__item,"%s",s);
//__item = s;

 }











xsd__normalizedString::xsd__normalizedString()
{ }
//xsd__normalizedString::xsd__normalizedString(xsd__normalizedString& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__normalizedString::~xsd__normalizedString()
{ }
xsd__normalizedString::xsd__normalizedString(char *s)
{ __item = s; }
void xsd__normalizedString::fprint(ofstream& s) const
{ 
s << __item;
}
void xsd__normalizedString::print(std::ostream& s) const
{ 
s << __item;
}
void xsd__normalizedString::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__normalizedString::getst(msdbStream& s)
{ 
s >>__item;
msd_val = msdConst(__item);
}
//void xsd__normalizedString::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
//__item = s;
// }

xsd__token::xsd__token()
{ }
//xsd__token::xsd__token(xsd__token& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__token::~xsd__token()
{ }
xsd__token::xsd__token(char *s)
{ __item = s; 
  }
void xsd__token::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__token::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__token::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__token::getst(msdbStream& s)
{ 
s >>__item;
msd_val = msdConst(__item);
}
//void xsd__token::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
//__item = s;
// }

xsd__decimal::xsd__decimal()
{ }
//xsd__decimal::xsd__decimal(xsd__decimal& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__decimal::~xsd__decimal()
{ }
xsd__decimal::xsd__decimal(char *s)
{ __item = s; 
}
void xsd__decimal::fprint(ofstream& s) const
{  
//printf("%s", __item);
s << __item;
}
void xsd__decimal::print(std::ostream& s) const
{  
//printf("%s", __item);
s << __item;
}
void xsd__decimal::setst(msdbStream& s)
{  
s << __item;
}
void xsd__decimal::getst(msdbStream& s)
{  
s >> __item;
msd_val = msdConst(__item);
}
//void xsd__decimal::set(char* s){
//      __item = s;
// }

xsd__integer::xsd__integer()
{ }
//xsd__integer::xsd__integer(xsd__integer& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__integer::~xsd__integer()
{ }
xsd__integer::xsd__integer(char *s)
{ __item = s; 
 }
void xsd__integer::fprint(ofstream& s) const
{  
//s << this->__item;
s << __item;
}
void xsd__integer::print(std::ostream& s) const
{  
//s << this->__item;
s << __item;
}
void xsd__integer::setst(msdbStream& s)
{  
s << __item;
}
void xsd__integer::getst(msdbStream& s)
{  
s >> __item;
msd_val = msdConst(__item);
}
//void xsd__integer::set(char* s){
//      __item = s;
// }

xsd__nonPositiveInteger::xsd__nonPositiveInteger()
{ }
//xsd__nonPositiveInteger::xsd__nonPositiveInteger(xsd__nonPositiveInteger& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__nonPositiveInteger::~xsd__nonPositiveInteger()
{ }
xsd__nonPositiveInteger::xsd__nonPositiveInteger(char *s)
{ __item = s;
 }
void xsd__nonPositiveInteger::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__nonPositiveInteger::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__nonPositiveInteger::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__nonPositiveInteger::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
//void xsd__nonPositiveInteger::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
//__item = s;
// }

xsd__negativeInteger::xsd__negativeInteger()
{ }
//xsd__negativeInteger::xsd__negativeInteger(xsd__negativeInteger& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__negativeInteger::~xsd__negativeInteger()
{ }
xsd__negativeInteger::xsd__negativeInteger(char *s)
{ __item = s;
 }
void xsd__negativeInteger::fprint(ofstream& s) const
{
//s << this->__item;
s << __item;
}
void xsd__negativeInteger::print(std::ostream& s) const
{
//s << this->__item;
s << __item;
}
void xsd__negativeInteger::setst(msdbStream& s)
{
s << __item;
}
void xsd__negativeInteger::getst(msdbStream& s)
{
s >> __item;
msd_val = msdConst(__item);
}
//void xsd__negativeInteger::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
//__item = s;
// }

xsd__nonNegativeInteger::xsd__nonNegativeInteger()
{ }
//xsd__nonNegativeInteger::xsd__nonNegativeInteger(xsd__nonNegativeInteger& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__nonNegativeInteger::~xsd__nonNegativeInteger()
{ }
xsd__nonNegativeInteger::xsd__nonNegativeInteger(char *s)
{ __item = s;
}
void xsd__nonNegativeInteger::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__nonNegativeInteger::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__nonNegativeInteger::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__nonNegativeInteger::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
//void xsd__nonNegativeInteger::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
//__item = s;
// }

xsd__positiveInteger::xsd__positiveInteger()
{ }
//xsd__positiveInteger::xsd__positiveInteger(xsd__positiveInteger& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__positiveInteger::~xsd__positiveInteger()
{ }
xsd__positiveInteger::xsd__positiveInteger(char *s)
{ __item = s;
}
void xsd__positiveInteger::fprint(ofstream& s) const
{ 
//s << this->__item;
s <<__item;
}
void xsd__positiveInteger::print(std::ostream& s) const
{ 
//s << this->__item;
s <<__item;
}
void xsd__positiveInteger::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__positiveInteger::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
//void xsd__positiveInteger::set(char* s){
//      if (__item)
// free(__item);
// __item=(char*)malloc(strlen(s)+1);
// sprintf(__item,"%s",s);
//__item = s;
// }

xsd__long::xsd__long()
{ }
//xsd__long::xsd__long(xsd__long& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__long::~xsd__long()
{ }
xsd__long::xsd__long(LONG64 ll)
{ __item = ll;
 }
void xsd__long::fprint(ofstream& s) const
{ 
s <<__item;
}
void xsd__long::print(std::ostream& s) const
{ 
s <<__item;
}

void xsd__long::setst(msdbStream& s)
{ 
// s <<__item; // should be implementd
}
void xsd__long::getst(msdbStream& s)
{ 
// s >>__item;  // should be implementd
// msd_val = msdConst(__item);
}
void xsd__long::set(LONG64& ll){
        __item = ll;
        }

xsd__int::xsd__int()
{ }
//xsd__int::xsd__int(xsd__int& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__int::~xsd__int()
{ }
xsd__int::xsd__int(int i)
{ __item = i;
}
void xsd__int::fprint(ofstream& s) const
{ 
//s << this->__item;
s << __item;
}
void xsd__int::print(std::ostream& s) const
{ 
//s << this->__item;
s << __item;
}

void xsd__int::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__int::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
void xsd__int::set(int& i){
        __item = i;
        
 }

xsd__short::xsd__short()
{ }
//xsd__short::xsd__short(xsd__short& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__short::~xsd__short()
{ }
xsd__short::xsd__short(short h)
{ __item = h;
 }
void xsd__short::fprint(ofstream& s) const
{ 
s << __item;
}
void xsd__short::print(std::ostream& s) const
{ 
s << __item;
}

void xsd__short::setst(msdbStream& s)
{ 
s << __item;
}
void xsd__short::getst(msdbStream& s)
{ 
s >> __item;
msd_val = msdConst(__item);
}
void xsd__short::set(short& h){
        __item = h;
        
 }

xsd__byte::xsd__byte()
{ }
//xsd__byte::xsd__byte(xsd__byte& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__byte::~xsd__byte()
{ }
xsd__byte::xsd__byte(char c)
{ __item = c;
 }
void xsd__byte::fprint(ofstream& s) const
{
s << __item;
}
void xsd__byte::print(std::ostream& s) const
{
s << __item;
}

void xsd__byte::setst(msdbStream& s)
{
s << __item;
}
void xsd__byte::getst(msdbStream& s)
{
s >> __item;
msd_val = msdConst(__item);
}
void xsd__byte::set(char c){
        __item = c;
        
 }

xsd__unsignedLong::xsd__unsignedLong()
{ }
//xsd__unsignedLong::xsd__unsignedLong(xsd__unsignedLong& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__unsignedLong::~xsd__unsignedLong()
{ }
xsd__unsignedLong::xsd__unsignedLong(ULONG64 ull)
{ __item = ull;
 }
void xsd__unsignedLong::fprint(ofstream& s) const
{ 
s << __item;
}
void xsd__unsignedLong::print(std::ostream& s) const
{ 
s << __item;
}

void xsd__unsignedLong::setst(msdbStream& s)
{ 
//s << __item; // should be implementd
}
void xsd__unsignedLong::getst(msdbStream& s)
{ 
//s >> __item;  // should be implementd
// msd_val = msdConst(__item);
}
void xsd__unsignedLong::set(ULONG64& ull){
        __item = ull;
        
 }

xsd__unsignedInt::xsd__unsignedInt()
{ }
//xsd__unsignedInt::xsd__unsignedInt(xsd__unsignedInt& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__unsignedInt::~xsd__unsignedInt()
{ }
xsd__unsignedInt::xsd__unsignedInt(unsigned int ui)
{ __item = ui;
}
void xsd__unsignedInt::fprint(ofstream& s) const
{ 
s << __item;
}
void xsd__unsignedInt::print(std::ostream& s) const
{ 
s << __item;
}

void xsd__unsignedInt::setst(msdbStream& s)
{ 
// s << __item; // should be implementd
}
void xsd__unsignedInt::getst(msdbStream& s)
{ 
// s >> __item;
// msd_val = msdConst(__item); // should be implementd
}
void xsd__unsignedInt::set(unsigned int& ui){
        __item = ui;
         }

xsd__unsignedShort::xsd__unsignedShort()
{ }
//xsd__unsignedShort::xsd__unsignedShort(xsd__unsignedShort& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__unsignedShort::~xsd__unsignedShort()
{ }
xsd__unsignedShort::xsd__unsignedShort(unsigned short uh)
{ __item = uh;
}
void xsd__unsignedShort::fprint(ofstream& s) const
{
s << __item;
}
void xsd__unsignedShort::print(std::ostream& s) const
{
s << __item;
}

void xsd__unsignedShort::setst(msdbStream& s)
{
//s << __item; // should be implementd
}
void xsd__unsignedShort::getst(msdbStream& s)
{
//s >> __item; // should be implementd
// msd_val = msdConst(__item);
}

void xsd__unsignedShort::set(unsigned short& uh){
        __item = uh;
 }

xsd__unsignedByte::xsd__unsignedByte()
{ }
//xsd__unsignedByte::xsd__unsignedByte(xsd__unsignedByte& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__unsignedByte::~xsd__unsignedByte()
{ }
xsd__unsignedByte::xsd__unsignedByte(unsigned char uc)
{ __item = uc;
 }
void xsd__unsignedByte::fprint(ofstream& s) const
{
s << __item;
}
void xsd__unsignedByte::print(std::ostream& s) const
{
s << __item;
}

void xsd__unsignedByte::setst(msdbStream& s)
{
// s << __item; // should be implementd
}
void xsd__unsignedByte::getst(msdbStream& s)
{
// s >> __item; // should be implementd
// msd_val = msdConst(__item);
}
void xsd__unsignedByte::set(unsigned char uc){
        __item = uc;
         }



xsd__base64Binary::xsd__base64Binary()
{ }
//xsd__base64Binary::xsd__base64Binary(xsd__base64Binary& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__base64Binary::~xsd__base64Binary()
{ }
xsd__base64Binary::xsd__base64Binary(char *s)
{ __size = strlen(s)+1;
  __ptr = (unsigned char*)s;
}
void xsd__base64Binary::fprint(ofstream& s) const
{ 
s << __size;

}
void xsd__base64Binary::print(std::ostream& s) const
{ 
s << __size;

}

void xsd__base64Binary::setst(msdbStream& s)
{ 
s << __size;

}
void xsd__base64Binary::getst(msdbStream& s)
{ 
s >> __size;
msd_val = msdConst(__size);

}
void xsd__base64Binary::set(char* s){
  __size = strlen(s)+1;
  __ptr = (unsigned char*)s;
 }
xsd__hexBinary::xsd__hexBinary()
{ }
//xsd__hexBinary::xsd__hexBinary(xsd__hexBinary& src)
//{__item = src.__item;
//msd_sym = src.msd_sym;
//msd_val = src.msd_val; 
//}
xsd__hexBinary::~xsd__hexBinary()
{ }
xsd__hexBinary::xsd__hexBinary(char *s)
{ __size = strlen(s)+1;
  __ptr = (unsigned char*)s;
}
void xsd__hexBinary::fprint(ofstream& s) const
{ 
//printf("%d", __size);
s << __size;

}
void xsd__hexBinary::print(std::ostream& s) const
{ 
//printf("%d", __size);
s << __size;

}

void xsd__hexBinary::setst(msdbStream& s)
{ 

s << __size;

}
void xsd__hexBinary::getst(msdbStream& s)
{ 

s >> __size;
msd_val = msdConst(__size);

}
void xsd__hexBinary::set(char* s){
  __size = strlen(s)+1;
  __ptr = (unsigned char*)s;
 }

array::array()
{ }
//array::array(array& src)
//{
// __size = src.__size;
// __ptr = src.__ptr;
//}
array::~array()
{ }
array::array(int n)
{ __size = n;
  __ptr = (xsd__anyType**)soap_malloc(soap, n*sizeof(xsd__anyType*));
}
xsd__anyType*& array::operator[](int i)
{ return __ptr[i];
}
void array::fprint(ofstream& s) const
{
  for (int i = 0; i < __size; i++){
    __ptr[i]->fprint(s);
   //printf(", ");
   s << ", ";

   }
   
}
void array::print(std::ostream& s) const
{
  for (int i = 0; i < __size; i++){
    __ptr[i]->print(s);
   //printf(", ");
   s << ", ";

   }
   
}

void array::setst(msdbStream& s)
{
  for (int i = 0; i < __size; i++){
    __ptr[i]->setst(s);
     }
   
}
void array::getst(msdbStream& s)
{
  for (int i = 0; i < __size; i++){
    __ptr[i]->getst(s);
     }
   
}


t__root::t__root()
{ soap = NULL;}

t__root::~t__root()
{soap_unlink(soap, this);
        //if (name)
    //free(name);
        if (name)
        {soap_dealloc(soap,(void*)name);
        }
}

void t__root::renew()
{ lease = time(NULL) + LEASETERM;       // can adopt a leasing policy per class
}

t__connect::t__connect()
{
}
t__connect::~t__connect()
{if (dbserver)
        {soap_dealloc(soap,(void*)dbserver);
        }
        if (username)
        {soap_dealloc(soap,(void*)username);
        }
        if (password)
        {soap_dealloc(soap,(void*)password);
        }
        
}

t__query::t__query()
{exf = 0;
}
t__query::~t__query()
{if (conn_name)
        {soap_dealloc(soap,(void*)conn_name);
        }
        if (result_name)
        {soap_dealloc(soap,(void*)result_name);
        }
        if (loginstr)
        {soap_dealloc(soap,(void*)loginstr);
        } 
        if (query_stm)
        {soap_dealloc(soap,(void*)query_stm);
        } 
}


t__resultset::t__resultset()
{size = 0; 
 contents = makeHashTable();
}
t__resultset::~t__resultset()
{   clrhash(contents); 
    gc(contents);
        if (conn_name)
        {soap_dealloc(soap,(void*)conn_name);
        }
        if (query_name)
        {soap_dealloc(soap,(void*)query_name);
        }
}

int t__resultset::getSize()
{return size;}

// Add an entity to the Data Base.
void t__resultset::addEntity(let entity) {
  if (!gethash(entity, contents)) {
    puthash(entity, contents, 0);
    size++;}}

// Set the value of an attribute for given entity.
void t__resultset::setValue(let entity, let attribute, let value) {
  let attributes = gethash(entity, contents);
  let old = assoc(attribute, attributes);
  if (old) rplacd(old, value);
  else {
    push(cons(attribute, value), attributes);
    puthash(entity, contents, attributes);}}

// Return the value of an attribute for given entity.
let t__resultset::getValue(let entity, let attribute) {
  return cdr(assoc(attribute, gethash(entity, contents)));}

// Delete an entity to the Data Base.
void t__resultset::delEntity(let entity) {
  if (!gethash(entity, contents)) {
    remhash(entity, contents);
    size--;}}

//~~~~~~~~ns__Object::ns__Object()
//~~~~~~~~{ name = "Object";
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__Object::ns__Object(const char *name)
//~~~~~~~~{ this->name = (char*)name;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__Object::~ns__Object()
//~~~~~~~~{
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~void ns__Object::print()
//~~~~~~~~{ cout << "Object: " << name << endl;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~
//~~~~~~~~
//~~~~~~~~
//~~~~~~~~ns__Shape::ns__Shape()
//~~~~~~~~{ name = "Shape";
//~~~~~~~~  sides = 0;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__Shape::ns__Shape(const char *name, int sides)
//~~~~~~~~{ this->name = (char*)name;
//~~~~~~~~  this->sides = sides;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__Shape::~ns__Shape()
//~~~~~~~~{
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~void ns__Shape::print()
//~~~~~~~~{ cout << "Shape: " << name << " sides=" << sides << endl;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__Square::ns__Square()
//~~~~~~~~{ name = "Square";
//~~~~~~~~  ns__Shape::sides = 4;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__Square::ns__Square(const char *name, int size)
//~~~~~~~~{ this->name = (char*)name;
//~~~~~~~~  this->size = size;
//~~~~~~~~  ns__Shape::sides = 4;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__Square::~ns__Square()
//~~~~~~~~{
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~void ns__Square::print()
//~~~~~~~~{ cout << "Square: " << name << " size=" << size << endl;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__List::ns__List()
//~~~~~~~~{ __ptr = 0;
//~~~~~~~~  __size = 0;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__List::ns__List(int size)
//~~~~~~~~{ __ptr = (ns__Object**)malloc(size*sizeof(ns__Object*));
//~~~~~~~~  __size = size;
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__List::~ns__List()
//~~~~~~~~{
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~ns__Object*& ns__List::operator[](int i)
//~~~~~~~~{ return __ptr[i];
//~~~~~~~~}
//~~~~~~~~
//~~~~~~~~void ns__List::print()
//~~~~~~~~{ cout << "List: [" << endl;
//~~~~~~~~  for (int i = 0; i < __size; i++)
//~~~~~~~~    __ptr[i]->print();
//~~~~~~~~  cout << "]" << endl;
//~~~~~~~~}
t__rvec::t__rvec()
{ t__rvec(NULL);
}

t__rvec::t__rvec(struct soap *env)
{ soap = env;
  __ptr = 0;
  __size = 0;
  __offset = 0;
}

t__rvec::t__rvec(struct soap *env, int size)
{ soap = env;
  __size = size;
  __offset = 1;
  __ptr = (xsd__double*)soap_malloc(soap, size*sizeof(xsd__double));
  for (int i = 0; i < size; i++)
    __ptr[i] = 0.0;
}

t__rvec::~t__rvec()
{       // no deallocation: let gSOAP handle all dynamic allocation and deallocation
}
int t__rvec::start()
{ return __offset;
}

int t__rvec::end()
{ return __size+__offset-1;
}

int t__rvec::size()
{ return __size;
}

void t__rvec::resize(int size)
{ resize(1, size);
}

void t__rvec::resize(int start, int end)
{ xsd__double *p;
  int n, size = end-start+1;
  if (__offset == start && __size == size)
    return; // nothing to do
  p = (xsd__double*)soap_malloc(soap, size*sizeof(xsd__double));
  for (int i = 0; i < size; i++)
    p[i] = 0.0;
  if (__ptr)
  { if (start < __offset)
    { n = (size-__offset+start <= __size ? size-__offset+start : __size);
      for (int i = 0; i < n; i++)
        p[__offset-start+i] = __ptr[i];
    }
    else
    { n = (__size-start+__offset <= size ? __size-start+__offset : size);
      for (int i = 0; i < n; i++)
        p[i] = __ptr[start-__offset+i];
    }
    soap_dealloc(soap, __ptr);
  }
  __ptr = p;
  __size = size;
  __offset = start;
}

xsd__double& t__rvec::operator[](int i)
{ return __ptr[i-__offset];
}

xsd__double t__rvec::operator()(int i)
{ if (i >= __offset && i < __size+__offset)
    return __ptr[i-__offset];
  return 0.0;
}

//void t__rvec::print()
//{ int i;
//  for (i = 1; i <= __size; i++)
//    printf("%f ", (*this)(i));
//  printf("\n");
//}

//
//  t__ivec
//

t__ivec::t__ivec()
{ t__ivec(NULL);
}

t__ivec::t__ivec(struct soap *env)
{ soap = env;
  __ptr = 0;
  __size = 0;
}

t__ivec::t__ivec(struct soap *env, int size)
{ soap = env;
  __size = size;
  __offset = 1;
  __ptr = (xsd__int*)soap_malloc(soap, size*sizeof(xsd__int));
  for (int i = 0; i < size; i++)
    __ptr[i] = 0;
}

t__ivec::t__ivec(struct soap *env, int start, int end)
{ soap = env;
  __size = end-start+1;
  __offset = start;
  __ptr = (xsd__int*)soap_malloc(soap, __size*sizeof(xsd__int));
  for (int i = 0; i < __size; i++)
    __ptr[i] = 0;
}

t__ivec::~t__ivec()
{       // no deallocation: let gSOAP handle all dynamic allocation and deallocation
}
int t__ivec::start()
{ return __offset;
}

int t__ivec::end()
{ return __size+__offset-1;
}

int t__ivec::size()
{ return __size;
}

void t__ivec::resize(int size)
{ resize(1, size);
}

void t__ivec::resize(int start, int end)
{ xsd__int *p;
  int n, size = end-start+1;
  if (__offset == start && __size == size)
    return; // nothing to do
  p = (xsd__int*)soap_malloc(soap, size*sizeof(xsd__int));
  for (int i = 0; i < size; i++)
    p[i] = 0;
  if (__ptr)
  { if (start < __offset)
    { n = (size-__offset+start <= __size ? size-__offset+start : __size);
      for (int i = 0; i < n; i++)
        p[__offset-start+i] = __ptr[i];
    }
    else
    { n = (__size-start+__offset <= size ? __size-start+__offset : size);
      for (int i = 0; i < n; i++)
        p[i] = __ptr[start-__offset+i];
    }
    soap_dealloc(soap, __ptr);
  }
  __ptr = p;
  __size = size;
  __offset = start;
}






xsd__int& t__ivec::operator[](int i)
{ return __ptr[i-__offset];
}

xsd__int t__ivec::operator()(int i)
{ if (i >= __offset && i < __size+__offset)
    return __ptr[i-__offset];
  return 0;
}

//void t__ivec::print()
//{ int i;
//  for (i = 1; i <= __size; i++)
//    printf("%4d ", (*this)(i));
//  printf("\n");
//}

//
//  t__rmat
//

t__rmat::t__rmat()
{ t__rmat(NULL);
}

t__rmat::t__rmat(struct soap *env)
{ soap = env;
  __ptr = 0;
  __size = 0;
  __offset = 0;
}



t__rmat::t__rmat(struct soap *env, int rows, int cols)
{ soap = env;
  __size = rows;
  __offset = 1;
  __ptr = soap_new_t__rvec(soap, __size);
  for (int i = 0; i < __size; i++)
    __ptr[i].resize(cols);
}
t__rmat::t__rmat(struct soap *env, int rowstart, int rowend, int colstart, int colend)
{ soap = env;
  __size = rowend-rowstart+1;
  __offset = rowstart;
  __ptr = soap_new_t__rvec(soap, __size);
  for (int i = 0; i <= __size-__offset; i++)
    __ptr[i].resize(colstart, colend);
}



t__rmat::~t__rmat()
{       // no deallocation: let gSOAP handle all dynamic allocation and deallocation
}
int t__rmat::start()
{ return __offset;
}

int t__rmat::end()
{ return __size+__offset-1;
}

int t__rmat::size()
{ return __size;
}

void t__rmat::resize(int rows, int cols)
{ resize(1, rows, 1, cols);
}

void t__rmat::resize(int rowstart, int rowend, int colstart, int colend)
{ int i;
  t__rvec *p;
  int n, size = rowend-rowstart+1;
  if (__offset != rowstart || __size != rowend-rowstart+1)
  { if (__ptr)
    { p = soap_new_t__rvec(soap, size);
      if (rowstart < __offset)
      { for (i = 0; i < __offset-rowstart; i++)
          p[i].resize(colstart, colend);
        n = (size-__offset+rowstart <= __size ? size-__offset+rowstart : __size);
        for (i = 0; i < n; i++)
        { __ptr[i].resize(colstart, colend);
          p[__offset-rowstart+i] = __ptr[i];
        }
        for (; i < size-__offset+rowstart; i++)
          p[i].resize(colstart, colend);
      }
      else
      { n = (__size-rowstart+__offset <= size ? __size-rowstart+__offset : size);
        for (i = 0; i < n; i++)
        { __ptr[i].resize(colstart, colend);
          p[i] = __ptr[rowstart-__offset+i];
        }
        for (; i < size; i++)
          p[i].resize(colstart, colend);
      }
      __ptr = p;
      __size = size;
      __offset = rowstart;
    }
    else
    { __size = size;
      __offset = rowstart;
      __ptr = soap_new_t__rvec(soap, size);
      for (i = 0; i < size; i++)
        __ptr[i].resize(colstart, colend);
    }
  }
  else
    for (i = 0; i < size; i++)
      __ptr[i].resize(colstart, colend);
}




t__rvec& t__rmat::operator[](int i)
{ return __ptr[i-__offset];
}

xsd__double t__rmat::operator()(int i, int j)
{ int s;
  if (i >= __offset && i < __size+__offset)
  { s = __ptr[i-__offset].__offset;
    if (j >= s && j < __ptr[i-__offset].__size+s)
      return __ptr[i-__offset].__ptr[j-s];
  }
  return 0.0;
}

//void t__rmat::print()
//{ int i, j;
//  for (i = start(); i <= __size; i++)
//  { for (j = 1; j < (*this)[i].start(); j++)
//      printf("-------- ");
//    for (; j <= (*this)[i].__size; j++)
//      printf("%f ", (*this)(i, j));
//    printf("\n");
//  }
//}
//
//  t__imat
//

t__imat::t__imat()
{ t__rmat(NULL);
}

t__imat::t__imat(struct soap *env)
{ soap = env;
  __ptr = 0;
  __size = 0;
  __offset = 0;
}



t__imat::t__imat(struct soap *env, int rows, int cols)
{ soap = env;
  __size = rows;
  __offset = 1;
  __ptr = soap_new_t__ivec(soap, __size);
  for (int i = 0; i < __size; i++)
    __ptr[i].resize(cols);
}
t__imat::t__imat(struct soap *env, int rowstart, int rowend, int colstart, int colend)
{ soap = env;
  __size = rowend-rowstart+1;
  __offset = rowstart;
  __ptr = soap_new_t__ivec(soap, __size);
  for (int i = 0; i <= __size-__offset; i++)
    __ptr[i].resize(colstart, colend);
}


t__imat::~t__imat()
{       // no deallocation: let gSOAP handle all dynamic allocation and deallocation
}
int t__imat::start()
{ return __offset;
}

int t__imat::end()
{ return __size+__offset-1;
}

int t__imat::size()
{ return __size;
}

void t__imat::resize(int rows, int cols)
{ resize(1, rows, 1, cols);
}

void t__imat::resize(int rowstart, int rowend, int colstart, int colend)
{ int i;
  t__ivec *p;
  int n, size = rowend-rowstart+1;
  if (__offset != rowstart || __size != rowend-rowstart+1)
  { if (__ptr)
    { p = soap_new_t__ivec(soap, size);
      if (rowstart < __offset)
      { for (i = 0; i < __offset-rowstart; i++)
          p[i].resize(colstart, colend);
        n = (size-__offset+rowstart <= __size ? size-__offset+rowstart : __size);
        for (i = 0; i < n; i++)
        { __ptr[i].resize(colstart, colend);
          p[__offset-rowstart+i] = __ptr[i];
        }
        for (; i < size-__offset+rowstart; i++)
          p[i].resize(colstart, colend);
      }
      else
      { n = (__size-rowstart+__offset <= size ? __size-rowstart+__offset : size);
        for (i = 0; i < n; i++)
        { __ptr[i].resize(colstart, colend);
          p[i] = __ptr[rowstart-__offset+i];
        }
        for (; i < size; i++)
          p[i].resize(colstart, colend);
      }
      __ptr = p;
      __size = size;
      __offset = rowstart;
    }
    else
    { __size = size;
      __offset = rowstart;
      __ptr = soap_new_t__ivec(soap, size);
      for (i = 0; i < size; i++)
        __ptr[i].resize(colstart, colend);
    }
  }
  else
    for (i = 0; i < size; i++)
      __ptr[i].resize(colstart, colend);
}





t__ivec& t__imat::operator[](int i)
{ return __ptr[i-__offset];
}

xsd__int t__imat::operator()(int i, int j)
{ int s;
  if (i >= __offset && i < __size+__offset)
  { s = __ptr[i-__offset].__offset;
    if (j >= s && j < __ptr[i-__offset].__size+s)
      return __ptr[i-__offset].__ptr[j-s];
  }
  return 0;
}

//void t__imat::print()
//{ int i, j;
//  for (i = start(); i <= __size; i++)
//  { for (j = 1; j < (*this)[i].start(); j++)
//      printf("-------- ");
//    for (; j <= (*this)[i].__size; j++)
//      printf("%f ", (*this)(i, j));
//    printf("\n");
//  }
//}
















// ===================== class ns__CHetCompound  
    ns__CHetCompound::ns__CHetCompound ()
        {}
        ns__CHetCompound::ns__CHetCompound ( xsd__string HetName )
        {}
   
    ns__CHetCompound::~ns__CHetCompound()
    {}
    
  

//  ====================  CHetCompounds  =======================

// ===================== class ns__CHetCompounds: public ns__CHetCompound 
    ns__CHetCompounds::ns__CHetCompounds ()
        {}
    ns__CHetCompounds::~ns__CHetCompounds()
        {}
        ns__CHetCompound*& ns__CHetCompounds::operator[](int i){
                return __ptr[i];
        }
 



// ==================== class ns__CHelix   

    ns__CHelix::ns__CHelix ()
        {}
    ns__CHelix::ns__CHelix ( xsd__string S )
        {}
    ns__CHelix::~ns__CHelix()
        {}




//  ====================  CStrand  ============================

// ==================== class ns__CStrand   
    ns__CStrand::ns__CStrand ()
        {}
   
    ns__CStrand::~ns__CStrand()
        {}



//====================== array of CStrands ============================
// ========== class ns__CStrands:  public ns__CStrand 
    ns__CStrands::ns__CStrands ()
        {}
    ns__CStrands::~ns__CStrands()
        {}
        ns__CStrand*& ns__CStrands::operator[](int i)
        {return __ptr[i];
        }

//  ====================  CSheet  ============================
// =============== class ns__CSheet  
    ns__CSheet::ns__CSheet ()
        {}
    
    ns__CSheet::~ns__CSheet()
        {}
//  ====================  array of CSheets  ============================
// ======================= class ns__CSheets: public ns__CSheet 
    ns__CSheets::ns__CSheets ()
        {}
   
    ns__CSheets::~ns__CSheets()
        {}
        ns__CSheet*& ns__CSheets::operator[](int i)
        {return __ptr[i];}


//  ====================  CTurn  ============================
// =========== class ns__CTurn  {

    ns__CTurn::ns__CTurn ()
        {}
    ns__CTurn::ns__CTurn ( xsd__string S )
        {}
    ns__CTurn::~ns__CTurn()
        {}
// =============== class ns__CChainContainer  
    ns__CChainContainer::ns__CChainContainer  ()
        {}
    ns__CChainContainer::~ns__CChainContainer ()
        {}
//  ==================  CSeqRes  ========================

// =============== class ns__CSeqRes  
    ns__CSeqRes::ns__CSeqRes ()
        {}
    
    ns__CSeqRes::~ns__CSeqRes()
        {}

// =============== class ns__CAtom   
    ns__CAtom::ns__CAtom ()
        {}
    
    ns__CAtom::~ns__CAtom()
        {}

//======================== Array of CAtoms ============================
 // =============== class ns__CAtoms:  public ns__CAtom  
    ns__CAtoms::ns__CAtoms ()
        {}
    
    ns__CAtoms::~ns__CAtoms()
        {}
    ns__CAtom*& ns__CAtoms::operator[](int i)
        {return __ptr[i];
        }
  



// ============== class ns__CResidue  
    ns__CResidue::ns__CResidue ()
        {}
    
    ns__CResidue::~ns__CResidue()
        {}

//==================== Array of CResidues =========================
// ============= class ns__CResidues:  public ns__CResidue
    ns__CResidues::ns__CResidues ()
        {}
    
    ns__CResidues::~ns__CResidues()
        {}
    ns__CResidue*& ns__CResidues::operator[](int i)
        {return __ptr[i];
        }
 
//  =================  CChain  =======================

// ============ class ns__CChain 
    ns__CChain::ns__CChain ()
        {}  // SetModel() MUST be used after this constructor!
   
    ns__CChain::~ns__CChain()
        {}

//======================== array of CChains =================================
// ================ class ns__CChains:  public ns__CChain 
    ns__CChains::ns__CChains ()
        {}
    
    ns__CChains::~ns__CChains()
        {}
    ns__CChain*& ns__CChains::operator[](int i)
        {return __ptr[i];}
 

//  ====================  CModel  ===============================
// ============== class ns__CModel 
    ns__CModel::ns__CModel ()
        {}  // SetMMDBFile() MUST be used after this constructor!
    ns__CModel::~ns__CModel()
        {}
    
//  ==================  CContainerChain  =====================
// ============= class ns__CContainerChain 

    ns__CContainerChain::ns__CContainerChain ()
        {}
    ns__CContainerChain::~ns__CContainerChain ()
        {}
  

//  ==================  CDBReference  ========================
// ============ class ns__CDBReference : public ns__CContainerChain 
    ns__CDBReference::ns__CDBReference ()
        {}
   
    ns__CDBReference::~ns__CDBReference()
        {}
 
//  ==================  CSeqAdv  ========================
// ============ class ns__CSeqAdv : public ns__CContainerChain 
    ns__CSeqAdv::ns__CSeqAdv ()
        {}
   
    ns__CSeqAdv::~ns__CSeqAdv()
        {}

//  ==================  CModRes  ========================
// ======== class ns__CModRes : public ns__CContainerChain
    ns__CModRes::ns__CModRes ()
        {}
    ns__CModRes::~ns__CModRes()
        {}

//  ==================  CHetRec  ===========================
// ============= class ns__CHetRec : public ns__CContainerChain 
    ns__CHetRec::ns__CHetRec ()
        {}
    ns__CHetRec::~ns__CHetRec()
        {}

// ================= class CAtomPath 
    ns__CAtomPath::ns__CAtomPath  ()
        {}
    ns__CAtomPath::~ns__CAtomPath ()
        {}

//================== class CListResidue
ns__CListResidue::ns__CListResidue(){}
ns__CListResidue::~ns__CListResidue(){}


//=======================
ns__CListChain::ns__CListChain(){}
ns__CListChain::~ns__CListChain(){}

//========================
 ns__CChainAssembly::ns__CChainAssembly(){}
 ns__CChainAssembly::~ns__CChainAssembly(){}


 //====================
 ns__CListChainAssembly::ns__CListChainAssembly(){}
 ns__CListChainAssembly::~ns__CListChainAssembly(){}



 //=============================
 ns__CModelAssembly::ns__CModelAssembly(){}
  // * Destructor
  // */
  ns__CModelAssembly::~ns__CModelAssembly(){}


  //===========================
 ns__CListModelAssembly::ns__CListModelAssembly(){}
 ns__CListModelAssembly::~ns__CListModelAssembly(){}


//============================
  ns__CAssembly::ns__CAssembly(){}
   
 // /**
 //  * Destructor
 //  */
  ns__CAssembly::~ns__CAssembly(){}


  //========================
  ns__CMContact::ns__CMContact (){}
  ns__CMContact::~ns__CMContact(){}

 //======================
 ns__CListAtom::ns__CListAtom(){}
 ns__CListAtom::~ns__CListAtom(){}

//==============================
 ns__CManager::ns__CManager(){}
  // * Destructor, performs cleanup
  // */
  ns__CManager::~ns__CManager(){}

---