managekey_c.cpp

corba是一款商用内存检测工具

/*
 * Copyright 1992-2004 Borland Software Corporation.  All rights reserved.
 *
 * GENERATED CODE --- DO NOT EDIT
 * 
 */

#include "ManageKey_c.hh"
ManageKey_ptr ManageKey_var::_duplicate(ManageKey_ptr _p) {
  return ManageKey::_duplicate(_p);
}

void
ManageKey_var::_release(ManageKey_ptr _p) {
  ::CORBA::release((::CORBA::Object_ptr)_p);
}

ManageKey_var::ManageKey_var()
  : _ptr(ManageKey::_nil()) {}

ManageKey_var::ManageKey_var(ManageKey_ptr _p)
  : _ptr(_p) {}

ManageKey_var::ManageKey_var(const ManageKey_var& _var)
  : _ptr(ManageKey::_duplicate((ManageKey_ptr) _var)) {}

ManageKey_var::~ManageKey_var() {
  ::CORBA::release((::CORBA::Object_ptr)_ptr);
}

ManageKey_var&
ManageKey_var::operator=(const ManageKey_var& _var) {
    _release(_ptr);
    _ptr = _duplicate(_var._ptr);
    return *this;
}

ManageKey_var&
ManageKey_var::operator=(ManageKey_ptr _p) {
  ::CORBA::release((::CORBA::Object_ptr)_ptr);
  _ptr = _p;
  return *this;
}

ManageKey_ptr& ManageKey_var::out() {
  _release(_ptr);
  _ptr = (ManageKey_ptr)NULL;
  return _ptr;
}

ManageKey_ptr ManageKey_var::_retn() {
  ManageKey_ptr _tmp_ptr = _ptr;
  _ptr = (ManageKey_ptr)NULL;
  return _tmp_ptr;
}

VISistream& operator>>(VISistream& _strm, ManageKey_var& _var) {
  _strm >> _var._ptr;
  return _strm;
}

VISostream& operator<<(VISostream& _strm, const ManageKey_var& _var) {
  _strm << _var._ptr;
  return _strm;
}

Istream& operator>>(Istream& _strm, ManageKey_var& _var) {
  VISistream _istrm(_strm);
  _istrm >> _var._ptr;
  return _strm;
}

Ostream& operator<<(Ostream& _strm, const ManageKey_var& _var) {
  _strm << (::CORBA::Object_ptr)_var._ptr;
  return _strm;
}

// idl interface: ManageKey
ManageKey::ManageKey() {}
ManageKey::ManageKey(const ManageKey& ref) {}
ManageKey::~ManageKey() {}

// If dllimport is specified, you might probably want to
// disable these definitions
// disable the const definitions
const VISOps_Info ManageKey_ops::_ops_info("ManageKey_ops");
const VISOps_Info *ManageKey_ops::_desc() { return &_ops_info; }
ManageKey_ops_ptr ManageKey_ops::_downcast(PortableServer::ServantBase* _servant) {
  if (_servant == (PortableServer::ServantBase*)NULL)
    return ManageKey_ops::_nil();
  return (ManageKey_ops_ptr)_servant->_safe_downcast_ops(_ops_info);
}
const ::CORBA::TypeInfo
ManageKey::_class_info("ManageKey", "IDL:ManageKey:1.0", NULL,
                       ManageKey::_factory, NULL, 0, NULL, 0,
                       ::CORBA::Object::_desc(), 0L);

const ::CORBA::TypeInfo *ManageKey::_desc() { return &_class_info; }
const ::CORBA::TypeInfo *ManageKey::_type_info() const {
  return &_class_info;
}

VISistream& operator>>(VISistream& _strm, ManageKey_ptr& _obj) {
  ::CORBA::Object_var _var_obj(_obj);
  _var_obj = ::CORBA::Object::_read(_strm, ManageKey::_desc());
  _obj = ManageKey::_narrow(_var_obj);
  return _strm;
}

VISostream& operator<<(VISostream& _strm, const ManageKey_ptr _obj) {
  _strm << (::CORBA::Object_ptr)_obj;
  return _strm;
}
void* ManageKey::_safe_narrow(const ::CORBA::TypeInfo& _info) const {
  if (_info == _class_info)
    return (void *)this;
  return CORBA_Object::_safe_narrow(_info);
}

::CORBA::Object *ManageKey::_factory() {
  return new ManageKey;
}

ManageKey_ptr ManageKey::_this() {
  return ManageKey::_duplicate(this);
}

ManageKey_ptr ManageKey::_narrow(::CORBA::Object * _obj) {
  if (_obj == ManageKey::_nil())
    return ManageKey::_nil();
  else
    return ManageKey::_duplicate((ManageKey_ptr)_obj->_safe_narrow(_class_info));
}

Ostream& operator<<(Ostream& _strm, const ManageKey_ptr _obj) {
  _strm << (::CORBA::Object_ptr) _obj;
  return _strm;
}
Istream& operator>>(Istream& _strm, ManageKey_ptr& _obj) {
  VISistream _istrm(_strm);
  _istrm >> _obj;
  return _strm;
}

ManageKey *ManageKey::_bind(const char *_object_name, const char *_host_name,
                            const ::CORBA::BindOptions *_opt,
                            ::CORBA::ORB_ptr _orb)
{
  VISCLEAR_EXCEP
  ::CORBA::Object_var _obj = ::CORBA::Object::_bind_to_object(
          "IDL:ManageKey:1.0", _object_name, _host_name, _opt, _orb);
  return ManageKey::_narrow(_obj);
}

ManageKey *ManageKey::_bind(const char *_poa_name,
                            const ::CORBA::OctetSequence& _id,
                            const char *_host_name,
                            const ::CORBA::BindOptions *_opt,
                            ::CORBA::ORB_ptr _orb)
{
  VISCLEAR_EXCEP
  ::CORBA::Object_var _obj = ::CORBA::Object::_bind_to_object(
   "IDL:ManageKey:1.0", _poa_name, _id, _host_name, _opt, _orb);
  return ManageKey::_narrow(_obj);
}
::CORBA::LongLong ManageKey::Connect(const char* _arg_UserName ) {
  ::CORBA::LongLong _ret = (::CORBA::LongLong) 0;
  CORBA_MarshalInBuffer_var _ibuf;

  while (1) {
    VISCLEAR_EXCEP 

    if (_is_local()) {
      PortableServer::ServantBase_ptr _servant;
      VISTRY {
        _servant = _preinvoke("Connect");
      }
      VISCATCH(VISRemarshal, _vis_except) { continue; } 
      VISEND_CATCH

      ManageKey_ops*  _managekey = ManageKey_ops::_downcast(_servant);
      if (!_managekey) {
        if ((PortableServer::ServantBase*)_servant)
          _postinvoke(_servant, "Connect");
        VISTHROW(::CORBA::BAD_OPERATION());
        VISRETURN(return _ret;)
      }

      VISTRY {
        _ret = _managekey->Connect(_arg_UserName );
      }
      VISCATCH(::CORBA::Exception, e) {
        VISTRY {
          _postinvoke(_servant, "Connect", e);
        } VISCATCH(VISRemarshal, _vis_except) { continue; }
        VISAND_CATCH(::CORBA::Exception, e) {
          VISTHROW_LAST;
          VISRETURN(return _ret;)
        }
        VISEND_CATCH
      }
      VISAND_CATCHALL {
        ::CORBA::UNKNOWN e;
        _postinvoke(_servant, "Connect", e); 
        VISTHROW_LAST;
        VISRETURN(return _ret;)
      }
      VISEND_CATCH
      VISTRY {
        _postinvoke(_servant, "Connect");
      } VISCATCH(VISRemarshal, _vis_except) { continue; }
      VISAND_CATCH(::CORBA::Exception, e) {
        VISTHROW_LAST
        VISRETURN(return _ret;)
      }
      VISEND_CATCH
      return _ret;
    }

    ::CORBA::MarshalOutBuffer_var _obuf;
    VISTRY {
      _obuf = _request("Connect", 1);
    } VISCATCH(VISRemarshal, _vis_except) { continue; }
    VISAND_CATCH(::CORBA::Exception, e) {
      VISTHROW_LAST
      VISRETURN(return _ret;)
    }
    VISEND_CATCH

    VISIF_EXCEP(return _ret;)
    VISostream& _ostrm = *VISostream::_downcast(_obuf);
    _ostrm << _arg_UserName;

    VISTRY {
      _ibuf = _invoke(_obuf);
      VISIFNOT_EXCEP
      break;
      VISEND_IFNOT_EXCEP
    } VISCATCH(VISRemarshal, _vis_except) { continue; } 
    VISAND_CATCH(::CORBA::NO_RESPONSE, _vis_nr) { 
#if defined(minor)
#undef minor
#endif
      if ( _vis_nr.minor() == (::CORBA::OMGVMCID | 99) )
        return _ret;
      VISTHROW_LAST
      VISRETURN(return _ret;)
    }
    VISEND_CATCH
    VISRETURN(return _ret;)
  }

  VISistream& _istrm = *VISistream::_downcast(_ibuf);
  _istrm >> _ret;

  return _ret;
}

::CORBA::LongLong ManageKey::SetKey(const char* _arg_KeyValue ) {
  ::CORBA::LongLong _ret = (::CORBA::LongLong) 0;
  CORBA_MarshalInBuffer_var _ibuf;

  while (1) {
    VISCLEAR_EXCEP 

    if (_is_local()) {
      PortableServer::ServantBase_ptr _servant;
      VISTRY {
        _servant = _preinvoke("SetKey");
      }
      VISCATCH(VISRemarshal, _vis_except) { continue; } 
      VISEND_CATCH

      ManageKey_ops*  _managekey = ManageKey_ops::_downcast(_servant);
      if (!_managekey) {
        if ((PortableServer::ServantBase*)_servant)
          _postinvoke(_servant, "SetKey");
        VISTHROW(::CORBA::BAD_OPERATION());
        VISRETURN(return _ret;)
      }

      VISTRY {
        _ret = _managekey->SetKey(_arg_KeyValue );
      }
      VISCATCH(::CORBA::Exception, e) {
        VISTRY {
          _postinvoke(_servant, "SetKey", e);
        } VISCATCH(VISRemarshal, _vis_except) { continue; }
        VISAND_CATCH(::CORBA::Exception, e) {
          VISTHROW_LAST;
          VISRETURN(return _ret;)
        }
        VISEND_CATCH
      }
      VISAND_CATCHALL {
        ::CORBA::UNKNOWN e;
        _postinvoke(_servant, "SetKey", e); 
        VISTHROW_LAST;
        VISRETURN(return _ret;)
      }
      VISEND_CATCH
      VISTRY {
        _postinvoke(_servant, "SetKey");
      } VISCATCH(VISRemarshal, _vis_except) { continue; }
      VISAND_CATCH(::CORBA::Exception, e) {
        VISTHROW_LAST
        VISRETURN(return _ret;)
      }
      VISEND_CATCH
      return _ret;
    }

    ::CORBA::MarshalOutBuffer_var _obuf;
    VISTRY {
      _obuf = _request("SetKey", 1);
    } VISCATCH(VISRemarshal, _vis_except) { continue; }
    VISAND_CATCH(::CORBA::Exception, e) {
      VISTHROW_LAST
      VISRETURN(return _ret;)
    }
    VISEND_CATCH

    VISIF_EXCEP(return _ret;)
    VISostream& _ostrm = *VISostream::_downcast(_obuf);
    _ostrm << _arg_KeyValue;

    VISTRY {
      _ibuf = _invoke(_obuf);
      VISIFNOT_EXCEP
      break;
      VISEND_IFNOT_EXCEP
    } VISCATCH(VISRemarshal, _vis_except) { continue; } 
    VISAND_CATCH(::CORBA::NO_RESPONSE, _vis_nr) { 
#if defined(minor)
#undef minor
#endif
      if ( _vis_nr.minor() == (::CORBA::OMGVMCID | 99) )
        return _ret;
      VISTHROW_LAST
      VISRETURN(return _ret;)
    }
    VISEND_CATCH
    VISRETURN(return _ret;)
  }

  VISistream& _istrm = *VISistream::_downcast(_ibuf);
  _istrm >> _ret;

  return _ret;
}

char* ManageKey::GetKey() {
  char* _ret = (char*) 0;
  CORBA_MarshalInBuffer_var _ibuf;

  while (1) {
    VISCLEAR_EXCEP 

    if (_is_local()) {
      PortableServer::ServantBase_ptr _servant;
      VISTRY {
        _servant = _preinvoke("GetKey");
      }
      VISCATCH(VISRemarshal, _vis_except) { continue; } 
      VISEND_CATCH

      ManageKey_ops*  _managekey = ManageKey_ops::_downcast(_servant);
      if (!_managekey) {
        if ((PortableServer::ServantBase*)_servant)
          _postinvoke(_servant, "GetKey");
        VISTHROW(::CORBA::BAD_OPERATION());
        VISRETURN(return _ret;)
      }

      VISTRY {
        _ret = _managekey->GetKey();
      }
      VISCATCH(::CORBA::Exception, e) {
        VISTRY {
          _postinvoke(_servant, "GetKey", e);
        } VISCATCH(VISRemarshal, _vis_except) { continue; }
        VISAND_CATCH(::CORBA::Exception, e) {
          VISTHROW_LAST;
          VISRETURN(return _ret;)
        }
        VISEND_CATCH
      }
      VISAND_CATCHALL {
        ::CORBA::UNKNOWN e;
        _postinvoke(_servant, "GetKey", e); 
        VISTHROW_LAST;
        VISRETURN(return _ret;)
      }
      VISEND_CATCH
      VISTRY {
        _postinvoke(_servant, "GetKey");
      } VISCATCH(VISRemarshal, _vis_except) { continue; }
      VISAND_CATCH(::CORBA::Exception, e) {
        VISTHROW_LAST
        VISRETURN(return _ret;)
      }
      VISEND_CATCH
      return _ret;
    }

    ::CORBA::MarshalOutBuffer_var _obuf;
    VISTRY {
      _obuf = _request("GetKey", 1);
    } VISCATCH(VISRemarshal, _vis_except) { continue; }
    VISAND_CATCH(::CORBA::Exception, e) {
      VISTHROW_LAST
      VISRETURN(return _ret;)
    }
    VISEND_CATCH

    VISIF_EXCEP(return _ret;)

    VISTRY {
      _ibuf = _invoke(_obuf);
      VISIFNOT_EXCEP
      break;
      VISEND_IFNOT_EXCEP
    } VISCATCH(VISRemarshal, _vis_except) { continue; } 
    VISAND_CATCH(::CORBA::NO_RESPONSE, _vis_nr) { 
#if defined(minor)
#undef minor
#endif
      if ( _vis_nr.minor() == (::CORBA::OMGVMCID | 99) )
        return _ret;
      VISTHROW_LAST
      VISRETURN(return _ret;)
    }
    VISEND_CATCH
    VISRETURN(return _ret;)
  }

  VISistream& _istrm = *VISistream::_downcast(_ibuf);
  _istrm >> _ret;
  return _ret;
}

::CORBA::LongLong ManageKey::Disconnect() {
  ::CORBA::LongLong _ret = (::CORBA::LongLong) 0;
  CORBA_MarshalInBuffer_var _ibuf;

  while (1) {
    VISCLEAR_EXCEP 

    if (_is_local()) {
      PortableServer::ServantBase_ptr _servant;
      VISTRY {
        _servant = _preinvoke("Disconnect");
      }
      VISCATCH(VISRemarshal, _vis_except) { continue; } 
      VISEND_CATCH

      ManageKey_ops*  _managekey = ManageKey_ops::_downcast(_servant);
      if (!_managekey) {
        if ((PortableServer::ServantBase*)_servant)
          _postinvoke(_servant, "Disconnect");
        VISTHROW(::CORBA::BAD_OPERATION());
        VISRETURN(return _ret;)
      }

      VISTRY {
        _ret = _managekey->Disconnect();
      }
      VISCATCH(::CORBA::Exception, e) {
        VISTRY {
          _postinvoke(_servant, "Disconnect", e);
        } VISCATCH(VISRemarshal, _vis_except) { continue; }
        VISAND_CATCH(::CORBA::Exception, e) {
          VISTHROW_LAST;
          VISRETURN(return _ret;)
        }
        VISEND_CATCH
      }
      VISAND_CATCHALL {
        ::CORBA::UNKNOWN e;
        _postinvoke(_servant, "Disconnect", e); 
        VISTHROW_LAST;
        VISRETURN(return _ret;)
      }
      VISEND_CATCH
      VISTRY {
        _postinvoke(_servant, "Disconnect");
      } VISCATCH(VISRemarshal, _vis_except) { continue; }
      VISAND_CATCH(::CORBA::Exception, e) {
        VISTHROW_LAST
        VISRETURN(return _ret;)
      }
      VISEND_CATCH
      return _ret;
    }

    ::CORBA::MarshalOutBuffer_var _obuf;
    VISTRY {
      _obuf = _request("Disconnect", 1);
    } VISCATCH(VISRemarshal, _vis_except) { continue; }
    VISAND_CATCH(::CORBA::Exception, e) {
      VISTHROW_LAST
      VISRETURN(return _ret;)
    }
    VISEND_CATCH

    VISIF_EXCEP(return _ret;)

    VISTRY {
      _ibuf = _invoke(_obuf);
      VISIFNOT_EXCEP
      break;
      VISEND_IFNOT_EXCEP
    } VISCATCH(VISRemarshal, _vis_except) { continue; } 
    VISAND_CATCH(::CORBA::NO_RESPONSE, _vis_nr) { 
#if defined(minor)
#undef minor
#endif
      if ( _vis_nr.minor() == (::CORBA::OMGVMCID | 99) )
        return _ret;
      VISTHROW_LAST
      VISRETURN(return _ret;)
    }
    VISEND_CATCH
    VISRETURN(return _ret;)
  }

  VISistream& _istrm = *VISistream::_downcast(_ibuf);
  _istrm >> _ret;
  return _ret;
}