csiv2.h

支持组件模型CCM的开源中间件-mico

  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static InvalidMechanism *_downcast( CORBA::Exception *ex );
  static const InvalidMechanism *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef InvalidMechanism InvalidMechanism_catch;
#else
typedef ExceptVar< InvalidMechanism > InvalidMechanism_var;
typedef TVarOut< InvalidMechanism > InvalidMechanism_out;
typedef InvalidMechanism_var InvalidMechanism_catch;
#endif // HAVE_STD_EH

extern MICO_EXPORT CORBA::TypeCodeConst _tc_InvalidMechanism;


/*
 * Base class and common definitions for local interface TSS
 */

class TSS : 
  virtual public ::CSIv2::CMSetup
{
  public:
    virtual ~TSS();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TSS_ptr _ptr_type;
    typedef TSS_var _var_type;
    #endif

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

    static TSS_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::CSIv2::SecurityManager_ptr security_manager() = 0;
    virtual void security_manager( ::CSIv2::SecurityManager_ptr value ) = 0;

    virtual ::IOP::ServiceContext* accept_context( ::PortableInterceptor::ServerRequestInfo_ptr info, CORBA::Boolean_out exc ) = 0;
    virtual ::CSI::CompleteEstablishContext* establish_context( const ::CSI::EstablishContext& ctx ) = 0;
    virtual void accept_transport_context() = 0;
    virtual void receive_request_service_contexts( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;
    virtual void receive_request( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;
    virtual void send_reply( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;
    virtual void send_exception( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;
    virtual void send_other( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;

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



/*
 * Base class and common definitions for local interface CSS
 */

class CSS : 
  virtual public ::CSIv2::CMSetup
{
  public:
    virtual ~CSS();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CSS_ptr _ptr_type;
    typedef CSS_var _var_type;
    #endif

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

    static CSS_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::CSIv2::SecurityManager_ptr security_manager() = 0;
    virtual void security_manager( ::CSIv2::SecurityManager_ptr value ) = 0;

    virtual void write_sas_context( ::PortableInterceptor::ClientRequestInfo_ptr info, const ::CSIIOP::CompoundSecMechList& list ) = 0;
    virtual void send_request( ::PortableInterceptor::ClientRequestInfo_ptr info ) = 0;
    virtual void receive_reply( ::PortableInterceptor::ClientRequestInfo_ptr info ) = 0;
    virtual void receive_exception( ::PortableInterceptor::ClientRequestInfo_ptr info ) = 0;
    virtual void receive_other( ::PortableInterceptor::ClientRequestInfo_ptr info ) = 0;

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


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

  CORBA::String_var user_name;
  CORBA::String_var identity_name;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_UserIdentity;


/*
 * Base class and common definitions for local interface ServerRequestInterceptor
 */

class ServerRequestInterceptor : 
  virtual public ::PortableInterceptor::ServerRequestInterceptor
{
  public:
    virtual ~ServerRequestInterceptor();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ServerRequestInterceptor_ptr _ptr_type;
    typedef ServerRequestInterceptor_var _var_type;
    #endif

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

    static ServerRequestInterceptor_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::CSIv2::TSS_ptr tss() = 0;

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



/*
 * Base class and common definitions for local interface ClientRequestInterceptor
 */

class ClientRequestInterceptor : 
  virtual public ::PortableInterceptor::ClientRequestInterceptor
{
  public:
    virtual ~ClientRequestInterceptor();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ClientRequestInterceptor_ptr _ptr_type;
    typedef ClientRequestInterceptor_var _var_type;
    #endif

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

    static ClientRequestInterceptor_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::CSIv2::CSS_ptr css() = 0;

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



/*
 * Base class and common definitions for local interface IORInterceptor
 */

class IORInterceptor : 
  virtual public ::PortableInterceptor::IORInterceptor
{
  public:
    virtual ~IORInterceptor();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef IORInterceptor_ptr _ptr_type;
    typedef IORInterceptor_var _var_type;
    #endif

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

    static IORInterceptor_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

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


}


#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA

void operator<<=( CORBA::Any &a, const ::CSIv2::GSSAuthError &e );
void operator<<=( CORBA::Any &a, ::CSIv2::GSSAuthError *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CSIv2::GSSAuthError &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CSIv2::GSSAuthError *&e );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_CSIv2_GSSAuthError;

void operator<<=( CORBA::Any &a, const ::CSIv2::TrustIdentityError &e );
void operator<<=( CORBA::Any &a, ::CSIv2::TrustIdentityError *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CSIv2::TrustIdentityError &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CSIv2::TrustIdentityError *&e );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_CSIv2_TrustIdentityError;

void operator<<=( CORBA::Any &a, const ::CSIv2::InvalidMechanism &e );
void operator<<=( CORBA::Any &a, ::CSIv2::InvalidMechanism *e );
CORBA::Boolean operator>>=( const CORBA::Any &a, ::CSIv2::InvalidMechanism &e );

CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CSIv2::InvalidMechanism *&e );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_CSIv2_InvalidMechanism;

void operator<<=( CORBA::Any &_a, const ::CSIv2::UserIdentity &_s );
void operator<<=( CORBA::Any &_a, ::CSIv2::UserIdentity *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CSIv2::UserIdentity &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CSIv2::UserIdentity *&_s );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_CSIv2_UserIdentity;

void operator<<=( CORBA::Any &_a, const SequenceTmpl< CSIv2::UserIdentity,MICO_TID_DEF> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl< CSIv2::UserIdentity,MICO_TID_DEF> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl< CSIv2::UserIdentity,MICO_TID_DEF> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl< CSIv2::UserIdentity,MICO_TID_DEF> *&_s );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller__seq_CSIv2_UserIdentity;

#endif