/*
*  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 __HELLO2_H__
#define __HELLO2_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
{

class qqq;
typedef qqq *qqq_ptr;
typedef qqq_ptr qqqRef;
typedef ValueVar< qqq > qqq_var;
typedef ValueOut< qqq > qqq_out;


// Common definitions for valuetype qqq
class qqq :
  virtual public CORBA::ValueBase
{
  public:
    static qqq* _downcast (CORBA::ValueBase *);
    static qqq* _downcast (CORBA::AbstractBase *);

    virtual void nic() = 0;

    virtual void i1( CORBA::Long _p ) = 0;
    virtual CORBA::Long i1() const = 0;

    virtual void s1( char *_p ) = 0;
    virtual void s1( const char *_p ) = 0;
    virtual void s1( const CORBA::String_var &_p ) = 0;
    virtual const char *s1() const = 0;


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

  protected:
    qqq ();
    virtual ~qqq ();
    void _copy_members (const qqq&);

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


/*
* 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 );

    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;

    typedef SequenceTmpl< CORBA::Float,MICO_TID_DEF> float_seq;
    typedef TSeqVar< SequenceTmpl< CORBA::Float,MICO_TID_DEF> > float_seq_var;
    typedef TSeqOut< SequenceTmpl< CORBA::Float,MICO_TID_DEF> > float_seq_out;

    typedef SequenceTmpl< float_seq,MICO_TID_DEF> macierz;
    typedef TSeqVar< SequenceTmpl< float_seq,MICO_TID_DEF> > macierz_var;
    typedef TSeqOut< SequenceTmpl< float_seq,MICO_TID_DEF> > macierz_out;

    struct S;
    typedef TVarVar< S > S_var;
    typedef TVarOut< S > S_out;


    struct S {
      #ifdef HAVE_TYPEDEF_OVERLOAD
      typedef S_var _var_type;
      #endif
      #ifdef HAVE_EXPLICIT_STRUCT_OPS
      S();
      ~S();
      S( const S& s );
      S& operator=( const S& s );
      #endif //HAVE_EXPLICIT_STRUCT_OPS

      CORBA::Long i1;
      CORBA::String_var s1;
    };

    typedef S S_arr[ 3 ];
    typedef S S_arr_slice;
    typedef ArrayVarVar< S,S_arr_slice,S_arr,3 > S_arr_var;
    typedef ArrayVarOut < S,S_arr_slice,S_arr,3 > S_arr_out;
    enum _dummy_S_arr { _dummy_S_arr_0 };
    typedef ArrayVarForAny < S,S_arr_slice,S_arr,3,_dummy_S_arr> S_arr_forany;
    #undef MICO_ARRAY_ARG
    #define MICO_ARRAY_ARG S
    DECLARE_ARRAY_ALLOC(S_arr,MICO_ARRAY_ARG,S_arr_slice,3)
    DECLARE_ARRAY_DUP(S_arr,MICO_ARRAY_ARG,S_arr_slice,3)
    DECLARE_ARRAY_FREE(S_arr,MICO_ARRAY_ARG,S_arr_slice,3)
    DECLARE_ARRAY_COPY(S_arr,MICO_ARRAY_ARG,S_arr_slice,3)
    typedef SequenceTmpl< S,MICO_TID_DEF> S_seq;
    typedef TSeqVar< SequenceTmpl< S,MICO_TID_DEF> > S_seq_var;
    typedef TSeqOut< SequenceTmpl< S,MICO_TID_DEF> > S_seq_out;

    virtual char* sayHello() = 0;
    virtual char* sayHello2( const char* we ) = 0;
    virtual CORBA::Long podajLiczbe() = 0;
    virtual long_seq* met1( const long_seq& s1 ) = 0;
    virtual macierz* zwrocMacierz( CORBA::Long w, CORBA::Long k ) = 0;
    virtual S_arr_slice* met2( const S_arr v1 ) = 0;
    virtual S_seq* met3( const S_seq& v1 ) = 0;
    virtual qqq* met4( qqq* v1 ) = 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();
    char* sayHello();
    char* sayHello2( const char* we );
    CORBA::Long podajLiczbe();
    long_seq* met1( const long_seq& s1 );
    macierz* zwrocMacierz( CORBA::Long w, CORBA::Long k );
    S_arr_slice* met2( const S_arr v1 );
    S_seq* met3( const S_seq& v1 );
    qqq* met4( qqq* v1 );

  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 ();
    char* sayHello();
    char* sayHello2( const char* we );
    CORBA::Long podajLiczbe();
    long_seq* met1( const long_seq& s1 );
    macierz* zwrocMacierz( CORBA::Long w, CORBA::Long k );
    S_arr_slice* met2( const S_arr v1 );
    S_seq* met3( const S_seq& v1 );
    qqq* met4( qqq* v1 );

  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 char* sayHello() = 0;
    virtual char* sayHello2( const char* we ) = 0;
    virtual CORBA::Long podajLiczbe() = 0;
    virtual ::HelloApp::Hello::long_seq* met1( const ::HelloApp::Hello::long_seq& s1 ) = 0;
    virtual ::HelloApp::Hello::macierz* zwrocMacierz( CORBA::Long w, CORBA::Long k ) = 0;
    virtual ::HelloApp::Hello::S_arr_slice* met2( const ::HelloApp::Hello::S_arr v1 ) = 0;
    virtual ::HelloApp::Hello::S_seq* met3( const ::HelloApp::Hello::S_seq& v1 ) = 0;
    virtual ::HelloApp::qqq* met4( ::HelloApp::qqq* v1 ) = 0;

  protected:
    Hello () {};

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

}


#endif // MICO_CONF_NO_POA



namespace OBV_HelloApp
{


// OBV class for valuetype qqq
class qqq : virtual public HelloApp::qqq
{
  protected:
    qqq ();
    qqq (CORBA::Long _i1, const char* _s1);
    virtual ~qqq();

  public:
    void i1( CORBA::Long _p );
    CORBA::Long i1() const;

    void s1( char *_p );
    void s1( const char *_p );
    void s1( const CORBA::String_var &_p );
    const char *s1() const;


  private:
    struct _M {
      CORBA::Long i1;
      CORBA::String_var s1;
    } _m;
};

}


extern CORBA::StaticTypeInfo *_marshaller_HelloApp_qqq;

extern CORBA::StaticTypeInfo *_marshaller_HelloApp_Hello_S;

extern CORBA::StaticTypeInfo *_marshaller_HelloApp_Hello;

extern CORBA::StaticTypeInfo *_marshaller__seq__seq_float;

extern CORBA::StaticTypeInfo *_marshaller__a3_HelloApp_Hello_S;

extern CORBA::StaticTypeInfo *_marshaller__seq_HelloApp_Hello_S;

#endif