/*
 * Copyright 2001 Borland Software Corporation, Inc.
 *
 * GENERATED CODE --- DO NOT EDIT
 * 
 */

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

#ifndef _corba_h_
# include "corba.h"
#endif   // _corba_h_

class  testi {
  public:
  #ifndef testi_iCarCounter_var_
  #define testi_iCarCounter_var_

  class  iCarCounter;

  typedef iCarCounter* iCarCounter_ptr;
  typedef iCarCounter_ptr iCarCounterRef;
  friend VISistream& operator>>(VISistream&, iCarCounter_ptr&);
  friend VISostream& operator<<(VISostream&, const iCarCounter_ptr);
  class  iCarCounter_out;

  class  iCarCounter_var : public CORBA::_var {
  friend class iCarCounter_out;
   private:
    iCarCounter_ptr _ptr;

   public:
    iCarCounter_var();
    iCarCounter_var(iCarCounter_ptr);
    iCarCounter_var(const iCarCounter_var &);
    virtual ~iCarCounter_var();

    static iCarCounter_ptr _duplicate(iCarCounter_ptr);
    static void _release(iCarCounter_ptr);

    iCarCounter_var& operator=(const iCarCounter_var& _var);
    iCarCounter_var& operator=(iCarCounter_ptr);

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

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

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

    friend Istream& operator>>(Istream&, iCarCounter_var&);
    friend Ostream& operator<<(Ostream&, const iCarCounter_var&);
  };
  class  iCarCounter_out {
   private:
    iCarCounter_ptr& _ptr;
    static iCarCounter* _nil() { return (iCarCounter*)NULL; }

    void operator=(const iCarCounter_out&);
    void operator=(const iCarCounter_var&);
     public:
    iCarCounter_out(const iCarCounter_out& _o) : _ptr(_o._ptr) {}
    iCarCounter_out(iCarCounter_ptr& _p) : _ptr(_p) {
      _ptr = _nil();
    }
    iCarCounter_out(iCarCounter_var& _v) : _ptr(_v._ptr) {
      _v = _nil();
    }
    iCarCounter_out& operator=(iCarCounter* _p) {
      _ptr = _p;
      return *this;
    }
    operator iCarCounter_ptr&() { return _ptr; }
    iCarCounter_ptr& ptr() { return _ptr; }
    iCarCounter* operator->() { return _ptr; }
  };

  #endif // testi_iCarCounter_var_

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

    protected:
    iCarCounter() {}
    iCarCounter(const iCarCounter&) {}

   public:
    virtual ~iCarCounter() {}
    static  const CORBA::TypeInfo *_desc();
    virtual const CORBA::TypeInfo *_type_info() const;
    virtual void *_safe_narrow(const CORBA::TypeInfo& ) const;
    static CORBA::Object*_factory();
    iCarCounter_ptr _this();
    static iCarCounter_ptr _duplicate(iCarCounter_ptr _obj) {
      if (_obj) _obj->_ref();
      return _obj;
    }
    static iCarCounter_ptr _nil() { return (iCarCounter_ptr)NULL; }
    static iCarCounter_ptr _narrow(CORBA::Object* _obj);
    static iCarCounter_ptr _clone(iCarCounter_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
    }
    static iCarCounter_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 iCarCounter_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);

    virtual void Inc();
    virtual CORBA::Long Count();
    virtual void Clear();

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

  class iCarCounter_ops;
  typedef iCarCounter_ops* iCarCounter_ops_ptr;

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

    virtual void Inc() = 0;
    virtual CORBA::Long Count() = 0;
    virtual void Clear() = 0;

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

};

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