/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2006 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <CORBA.h>
#include <mico/throw.h>

#ifndef __HELLO_H__
#define __HELLO_H__






namespace HelloApp
{

class Hello;
typedef Hello *Hello_ptr;
typedef Hello_ptr HelloRef;
typedef ObjVar< Hello > Hello_var;
typedef ObjOut< Hello > Hello_out;

}






namespace HelloApp
{

typedef SequenceTmpl< CORBA::Long,MICO_TID_DEF> long_seq;
typedef TSeqVar< SequenceTmpl< CORBA::Long,MICO_TID_DEF> > long_seq_var;
typedef TSeqOut< SequenceTmpl< CORBA::Long,MICO_TID_DEF> > long_seq_out;


// Common definitions for valuebox long_seq_box
class long_seq_box : 
  virtual public ::CORBA::ValueBase,
  virtual public ::CORBA::DefaultValueRefCountBase
{
  public:
    typedef CORBA::Long _elem_type;
    typedef CORBA::Long _auto_elem_type;
    typedef ::HelloApp::long_seq _value_type;
    typedef TSeqVar<_value_type> _value_var;

  private:
    _value_var value;

  public:
    long_seq_box ();
    long_seq_box (const _value_type &);
    long_seq_box (const long_seq_box &);
    long_seq_box (::CORBA::ULong);
    long_seq_box (::CORBA::ULong, ::CORBA::ULong, _elem_type *, ::CORBA::Boolean = FALSE);

    long_seq_box & operator= (const _value_type &);

    const _value_type & _value () const;
    _value_type & _value ();
    void _value (const _value_type &);

    const _auto_elem_type & operator[] (::CORBA::ULong) const;
    _auto_elem_type & operator[] (::CORBA::ULong);
    ::CORBA::ULong maximum () const;
    ::CORBA::Boolean release () const;
    void replace (::CORBA::ULong, ::CORBA::ULong, _elem_type *, ::CORBA::Boolean = FALSE);
    void length (::CORBA::ULong);
    ::CORBA::ULong length () const;
    static _elem_type * allocbuf (::CORBA::ULong);
    static void freebuf (_elem_type *);

    const _value_type & _boxed_in () const;
    _value_type & _boxed_inout ();
    _value_type *& _boxed_out ();

    static long_seq_box* _downcast (::CORBA::ValueBase *);
    static long_seq_box* _downcast (::CORBA::AbstractBase *);

    ::CORBA::ValueDef_ptr get_value_def ();
    void * _narrow_helper (const char *);
    ::CORBA::ValueBase * _copy_value ();
    void _get_marshal_info (std::vector<std::string> &, ::CORBA::Boolean &);
    void _marshal_members (::CORBA::DataEncoder &);
    ::CORBA::Boolean _demarshal_members (::CORBA::DataDecoder &);

  protected:
    ~long_seq_box ();

  private:
    void operator= (const long_seq_box &);
};

typedef ValueVar< long_seq_box > long_seq_box_var;
typedef ValueOut< long_seq_box > long_seq_box_out;


/*
 * Base class and common definitions for interface Hello
 */

class Hello : 
  virtual public CORBA::Object
{
  public:
    virtual ~Hello();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef Hello_ptr _ptr_type;
    typedef Hello_var _var_type;
    #endif

    static Hello_ptr _narrow( CORBA::Object_ptr obj );
    static Hello_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static Hello_ptr _duplicate( Hello_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static Hello_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual long_seq* met1( const long_seq& s1 ) = 0;
    virtual CORBA::Any* zwrocCokolwiek( CORBA::Long tryb ) = 0;
    virtual void zapiszSeq( long_seq_box* s1 ) = 0;
    virtual long_seq_box* odczytajSeq() = 0;
    virtual void pomnozRazy( CORBA::Double wsp ) = 0;

  protected:
    Hello() {};
  private:
    Hello( const Hello& );
    void operator=( const Hello& );
};

// Stub for interface Hello
class Hello_stub:
  virtual public Hello
{
  public:
    virtual ~Hello_stub();
    long_seq* met1( const long_seq& s1 );
    CORBA::Any* zwrocCokolwiek( CORBA::Long tryb );
    void zapiszSeq( long_seq_box* s1 );
    long_seq_box* odczytajSeq();
    void pomnozRazy( CORBA::Double wsp );

  private:
    void operator=( const Hello_stub& );
};

#ifndef MICO_CONF_NO_POA

class Hello_stub_clp :
  virtual public Hello_stub,
  virtual public PortableServer::StubBase
{
  public:
    Hello_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~Hello_stub_clp ();
    long_seq* met1( const long_seq& s1 );
    CORBA::Any* zwrocCokolwiek( CORBA::Long tryb );
    void zapiszSeq( long_seq_box* s1 );
    long_seq_box* odczytajSeq();
    void pomnozRazy( CORBA::Double wsp );

  protected:
    Hello_stub_clp ();
  private:
    void operator=( const Hello_stub_clp & );
};

#endif // MICO_CONF_NO_POA

}


#ifndef MICO_CONF_NO_POA



namespace POA_HelloApp
{

class Hello : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~Hello ();
    HelloApp::Hello_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static Hello * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual ::HelloApp::long_seq* met1( const ::HelloApp::long_seq& s1 ) = 0;
    virtual CORBA::Any* zwrocCokolwiek( CORBA::Long tryb ) = 0;
    virtual void zapiszSeq( ::HelloApp::long_seq_box* s1 ) = 0;
    virtual ::HelloApp::long_seq_box* odczytajSeq() = 0;
    virtual void pomnozRazy( CORBA::Double wsp ) = 0;

  protected:
    Hello () {};

  private:
    Hello (const Hello &);
    void operator= (const Hello &);
};

}


#endif // MICO_CONF_NO_POA

extern CORBA::StaticTypeInfo *_marshaller_HelloApp_long_seq_box;

extern CORBA::StaticTypeInfo *_marshaller_HelloApp_Hello;

#endif