sl3aqargs_p.h

MICO2.3.13 corba 环境平台

const char* const ProcessorArgumentType = "UserPasswordProcessor";

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

class ProcessorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~ProcessorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ProcessorArgument_ptr _ptr_type;
    typedef ProcessorArgument_var _var_type;
    #endif

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

    static ProcessorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::UserPassword::PasswordProcessor_ptr processor() = 0;

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


const char* const QuotingPrincipalArgumentType = "QuotingPrincipal";

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

class QuotingPrincipalArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~QuotingPrincipalArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef QuotingPrincipalArgument_ptr _ptr_type;
    typedef QuotingPrincipalArgument_var _var_type;
    #endif

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

    static QuotingPrincipalArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3PM::QuotingPrincipal* principal() = 0;

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


const char* const ATLASArgumentType = "ATLAS";

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

class ATLASArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~ATLASArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ATLASArgument_ptr _ptr_type;
    typedef ATLASArgument_var _var_type;
    #endif

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

    static ATLASArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::ATLAS::ATLASCacheId* cache_id() = 0;
    virtual ::ATLAS::AuthTokenDispenser_ptr token_dispenser() = 0;
    virtual ::SL3Authorization::TokenProcessor_ptr token_processor() = 0;

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


typedef IfaceSequenceTmpl< ::SL3Authorization::TokenProcessor_var,::SL3Authorization::TokenProcessor_ptr> TokenProcessorSeq;
typedef TSeqVar< IfaceSequenceTmpl< ::SL3Authorization::TokenProcessor_var,::SL3Authorization::TokenProcessor_ptr> > TokenProcessorSeq_var;
typedef TSeqOut< IfaceSequenceTmpl< ::SL3Authorization::TokenProcessor_var,::SL3Authorization::TokenProcessor_ptr> > TokenProcessorSeq_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_TokenProcessorSeq;

const char* const TokenProcessorSeqArgumentType = "TokenProcessorSeq";

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

class TokenProcessorSeqArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~TokenProcessorSeqArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TokenProcessorSeqArgument_ptr _ptr_type;
    typedef TokenProcessorSeqArgument_var _var_type;
    #endif

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

    static TokenProcessorSeqArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3AQArgs::TokenProcessorSeq* tpseq() = 0;

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


const char* const IPCInitiatorArgumentType = "IPCInitiator";

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

class IPCInitiatorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~IPCInitiatorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef IPCInitiatorArgument_ptr _ptr_type;
    typedef IPCInitiatorArgument_var _var_type;
    #endif

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

    static IPCInitiatorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

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


const char* const IPCAcceptorArgumentType = "IPCAcceptor";

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

class IPCAcceptorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~IPCAcceptorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef IPCAcceptorArgument_ptr _ptr_type;
    typedef IPCAcceptorArgument_var _var_type;
    #endif

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

    static IPCAcceptorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

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


const char* const ObserverSeqArgumentType = "ObserverSeq";

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

class ObserverSeqArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~ObserverSeqArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ObserverSeqArgument_ptr _ptr_type;
    typedef ObserverSeqArgument_var _var_type;
    #endif

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

    static ObserverSeqArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3OM::ObserverSeq* observers() = 0;

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


const char* const IdentityProcessorArgumentType = "TLSX509IdentityProcessor";

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

class IdentityProcessorArgument : 
  virtual public ::SL3AQArgs::Argument
{
  public:
    virtual ~IdentityProcessorArgument();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef IdentityProcessorArgument_ptr _ptr_type;
    typedef IdentityProcessorArgument_var _var_type;
    #endif

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

    static IdentityProcessorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3TLS::TLSX509IdentityProcessor_ptr processor() = 0;

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


}


#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3AQArgs_TCPIPInitiatorOptions;

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3AQArgs_TCPIPAcceptorOptions;

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3AQArgs_OpenSSLConfig;

#endif