managekey_c.hh

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

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

#ifndef __1209735282468__ManageKey_idl___client
#define __1209735282468__ManageKey_idl___client
#include "vpre.h"

# include "corba.h"

#ifndef ManageKey_var_
#define ManageKey_var_

class  ManageKey;

typedef ManageKey* ManageKey_ptr;
typedef ManageKey_ptr ManageKeyRef;
// forward declare stream opeartions 
 VISistream& operator>>(VISistream&, ManageKey_ptr&);
 VISostream& operator<<(VISostream&, const ManageKey_ptr);
class  ManageKey_out;

class  ManageKey_var : public ::CORBA::_var {
friend class ManageKey_out;
 private:
  ManageKey_ptr _ptr;

 public:
  ManageKey_var();
  ManageKey_var(ManageKey_ptr);
  ManageKey_var(const ManageKey_var &);
  virtual ~ManageKey_var();

  static ManageKey_ptr _duplicate(ManageKey_ptr);
  static void _release(ManageKey_ptr);

  ManageKey_var& operator=(const ManageKey_var& _var);
  ManageKey_var& operator=(ManageKey_ptr);

  operator ManageKey*() const { return _ptr; }
  ManageKey* operator->() const { return _ptr; }

  ManageKey_ptr in() const { return _ptr; }
  ManageKey_ptr& inout() { return _ptr; }
  ManageKey_ptr& out();
  ManageKey_ptr _retn();

  friend VISostream& operator<<(VISostream&, const ManageKey_var&);
  friend VISistream& operator>>(VISistream&, ManageKey_var&);

  friend Istream& operator>>(Istream&, ManageKey_var&);
  friend Ostream& operator<<(Ostream&, const ManageKey_var&);
};
class  ManageKey_out {
  private:
    ManageKey_ptr& _ptr;
    static ManageKey* _nil() { return (ManageKey*)NULL; }

    void operator=(const ManageKey_out&);
    void operator=(const ManageKey_var&);
  public:
    ManageKey_out(const ManageKey_out& _o) : _ptr(_o._ptr) {}
    ManageKey_out(ManageKey_ptr& _p) : _ptr(_p) {
      _ptr = _nil();
    }
    ManageKey_out(ManageKey_var& _v) : _ptr(_v._ptr) {
      _v = _nil();
    }
    ManageKey_out& operator=(ManageKey* _p) {
      _ptr = _p;
      return *this;
    }
    operator ManageKey_ptr&() { return _ptr; }
    ManageKey_ptr& ptr() { return _ptr; }
    ManageKey* operator->() { return _ptr; }
};

#endif // ManageKey_var_

// idl interface: ManageKey
class  ManageKey : public virtual CORBA_Object {
 private:
  static const ::CORBA::TypeInfo _class_info;
  void operator=(const ManageKey&) {}

  protected:
  ManageKey();
  ManageKey(const ManageKey& ref);

 public:
  typedef ManageKey_ptr _ptr_type;
  typedef ManageKey_var _var_type;

  virtual ~ManageKey();
  static  const ::CORBA::TypeInfo *_desc();
  virtual const ::CORBA::TypeInfo *_type_info() const;
  virtual void *_safe_narrow(const ::CORBA::TypeInfo& ) const;
  static ::CORBA::Object*_factory();
  ManageKey_ptr _this();
  static ManageKey_ptr _duplicate(ManageKey_ptr _obj) {
    if (_obj) _obj->_ref();
    return _obj;
  }
  static ManageKey_ptr _nil() { return (ManageKey_ptr)NULL; }
  static ManageKey_ptr _narrow(::CORBA::Object* _obj);
  static ManageKey_ptr _clone(ManageKey_ptr _obj) {
    ::CORBA::Object_var _obj_var(CORBA_Object::_clone(_obj));
    #if defined(_HPCC_BUG)
      return _narrow(_obj_var.operator ::CORBA::Object_ptr());
    #else
      return _narrow(_obj_var);
    #endif  // _HPCC_BUG
  }

#if (defined WIN32 && _MSC_VER > 1300)
  static ManageKey_ptr _bind(const char *_object_name = NULL,
                             const char *_host_name = NULL,
                             const ::CORBA::BindOptions* _opt = NULL,
                             ::CORBA::ORB_ptr _orb = NULL);

  static ManageKey_ptr _bind(const char *_poa_name,
                             const ::CORBA::OctetSequence& _id,
                             const char *_host_name = NULL,
                             const ::CORBA::BindOptions* _opt = NULL,
                             ::CORBA::ORB_ptr _orb = NULL);
#else
  static ManageKey_ptr _bind(const char *_object_name = (const char*)NULL,
                             const char *_host_name = (const char*)NULL,
                             const ::CORBA::BindOptions* _opt = (::CORBA::BindOptions*)NULL,
                             ::CORBA::ORB_ptr _orb = (::CORBA::ORB_ptr)NULL);

  static ManageKey_ptr _bind(const char *_poa_name,
                             const ::CORBA::OctetSequence& _id,
                             const char *_host_name = (const char*)NULL,
                             const ::CORBA::BindOptions* _opt = (::CORBA::BindOptions*)NULL,
                             ::CORBA::ORB_ptr _orb = (::CORBA::ORB_ptr)NULL);
#endif

  virtual ::CORBA::LongLong Connect(const char* _UserName);
  virtual ::CORBA::LongLong SetKey(const char* _KeyValue);
  virtual char* GetKey();
  virtual ::CORBA::LongLong Disconnect();

  friend VISostream& operator<<(VISostream& _strm, const ManageKey_ptr _obj);
  friend VISistream& operator>>(VISistream& _strm, ManageKey_ptr& _obj);
  friend Ostream& operator<<(Ostream& _strm, const ManageKey_ptr _obj);
  friend Istream& operator>>(Istream& _strm, ManageKey_ptr& _obj);
};

class ManageKey_ops;
typedef ManageKey_ops* ManageKey_ops_ptr;

class  ManageKey_ops  {
 public:
  ManageKey_ops() {}
  virtual ~ManageKey_ops () {}

  virtual ::CORBA::LongLong Connect(const char* _UserName) = 0;
  virtual ::CORBA::LongLong SetKey(const char* _KeyValue) = 0;
  virtual char* GetKey() = 0;
  virtual ::CORBA::LongLong Disconnect() = 0;

  static const VISOps_Info *_desc();
  static ManageKey_ops_ptr _nil() { return (ManageKey_ops_ptr)NULL; }
  static ManageKey_ops_ptr _downcast(PortableServer::ServantBase* _servant);
protected:
  static const VISOps_Info _ops_info;
};

// declare marshal operations
VISistream& operator>>(VISistream&, ManageKey_ptr&);
VISostream& operator<<(VISostream&, const ManageKey_ptr);
VISostream& operator<<(VISostream&, const ManageKey_var&);
VISistream& operator>>(VISistream&, ManageKey_var&);
Istream& operator>>(Istream&, ManageKey_var&);
Ostream& operator<<(Ostream&, const ManageKey_var&);
VISostream& operator<<(VISostream& _strm, const ManageKey_ptr _obj);
VISistream& operator>>(VISistream& _strm, ManageKey_ptr& _obj);
Ostream& operator<<(Ostream& _strm, const ManageKey_ptr _obj);
Istream& operator>>(Istream& _strm, ManageKey_ptr& _obj);
// end of marshal operations decl.


#include "vpost.h"
#endif // __1209735282468__ManageKey_idl___client