sl3aqargs_p.h

MICO2.3.13 corba 环境平台

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

#ifndef __SL3AQARGS_P_H__
#define __SL3AQARGS_P_H__


#ifdef _WIN32
#ifdef BUILD_MICO_DLL
#define MICO_EXPORT /**/
#else // BUILD_MICO_DLL
#define MICO_EXPORT __declspec(dllimport)
#endif // BUILD_MICO_DLL
#else // _WIN32
#define MICO_EXPORT /**/
#endif // _WIN32




namespace SL3AQArgs
{

class ArgsHolder;
typedef ArgsHolder *ArgsHolder_ptr;
typedef ArgsHolder_ptr ArgsHolderRef;
typedef ObjVar< ArgsHolder > ArgsHolder_var;
typedef ObjOut< ArgsHolder > ArgsHolder_out;

class CSIv1Support;
typedef CSIv1Support *CSIv1Support_ptr;
typedef CSIv1Support_ptr CSIv1SupportRef;
typedef ObjVar< CSIv1Support > CSIv1Support_var;
typedef ObjOut< CSIv1Support > CSIv1Support_out;

class CSIv2Support;
typedef CSIv2Support *CSIv2Support_ptr;
typedef CSIv2Support_ptr CSIv2SupportRef;
typedef ObjVar< CSIv2Support > CSIv2Support_var;
typedef ObjOut< CSIv2Support > CSIv2Support_out;

class TCPIPInitiatorArgument;
typedef TCPIPInitiatorArgument *TCPIPInitiatorArgument_ptr;
typedef TCPIPInitiatorArgument_ptr TCPIPInitiatorArgumentRef;
typedef ObjVar< TCPIPInitiatorArgument > TCPIPInitiatorArgument_var;
typedef ObjOut< TCPIPInitiatorArgument > TCPIPInitiatorArgument_out;

class TCPIPAcceptorArgument;
typedef TCPIPAcceptorArgument *TCPIPAcceptorArgument_ptr;
typedef TCPIPAcceptorArgument_ptr TCPIPAcceptorArgumentRef;
typedef ObjVar< TCPIPAcceptorArgument > TCPIPAcceptorArgument_var;
typedef ObjOut< TCPIPAcceptorArgument > TCPIPAcceptorArgument_out;

class TLSX509IdentityVerifierInitiatorArgument;
typedef TLSX509IdentityVerifierInitiatorArgument *TLSX509IdentityVerifierInitiatorArgument_ptr;
typedef TLSX509IdentityVerifierInitiatorArgument_ptr TLSX509IdentityVerifierInitiatorArgumentRef;
typedef ObjVar< TLSX509IdentityVerifierInitiatorArgument > TLSX509IdentityVerifierInitiatorArgument_var;
typedef ObjOut< TLSX509IdentityVerifierInitiatorArgument > TLSX509IdentityVerifierInitiatorArgument_out;

class TLSX509IdentityVerifierAcceptorArgument;
typedef TLSX509IdentityVerifierAcceptorArgument *TLSX509IdentityVerifierAcceptorArgument_ptr;
typedef TLSX509IdentityVerifierAcceptorArgument_ptr TLSX509IdentityVerifierAcceptorArgumentRef;
typedef ObjVar< TLSX509IdentityVerifierAcceptorArgument > TLSX509IdentityVerifierAcceptorArgument_var;
typedef ObjOut< TLSX509IdentityVerifierAcceptorArgument > TLSX509IdentityVerifierAcceptorArgument_out;

class OpenSSLInitiatorArgument;
typedef OpenSSLInitiatorArgument *OpenSSLInitiatorArgument_ptr;
typedef OpenSSLInitiatorArgument_ptr OpenSSLInitiatorArgumentRef;
typedef ObjVar< OpenSSLInitiatorArgument > OpenSSLInitiatorArgument_var;
typedef ObjOut< OpenSSLInitiatorArgument > OpenSSLInitiatorArgument_out;

class OpenSSLAcceptorArgument;
typedef OpenSSLAcceptorArgument *OpenSSLAcceptorArgument_ptr;
typedef OpenSSLAcceptorArgument_ptr OpenSSLAcceptorArgumentRef;
typedef ObjVar< OpenSSLAcceptorArgument > OpenSSLAcceptorArgument_var;
typedef ObjOut< OpenSSLAcceptorArgument > OpenSSLAcceptorArgument_out;

class TransportCredentialsArgument;
typedef TransportCredentialsArgument *TransportCredentialsArgument_ptr;
typedef TransportCredentialsArgument_ptr TransportCredentialsArgumentRef;
typedef ObjVar< TransportCredentialsArgument > TransportCredentialsArgument_var;
typedef ObjOut< TransportCredentialsArgument > TransportCredentialsArgument_out;

class DeciderArgument;
typedef DeciderArgument *DeciderArgument_ptr;
typedef DeciderArgument_ptr DeciderArgumentRef;
typedef ObjVar< DeciderArgument > DeciderArgument_var;
typedef ObjOut< DeciderArgument > DeciderArgument_out;

class GeneratorArgument;
typedef GeneratorArgument *GeneratorArgument_ptr;
typedef GeneratorArgument_ptr GeneratorArgumentRef;
typedef ObjVar< GeneratorArgument > GeneratorArgument_var;
typedef ObjOut< GeneratorArgument > GeneratorArgument_out;

class ProcessorArgument;
typedef ProcessorArgument *ProcessorArgument_ptr;
typedef ProcessorArgument_ptr ProcessorArgumentRef;
typedef ObjVar< ProcessorArgument > ProcessorArgument_var;
typedef ObjOut< ProcessorArgument > ProcessorArgument_out;

class QuotingPrincipalArgument;
typedef QuotingPrincipalArgument *QuotingPrincipalArgument_ptr;
typedef QuotingPrincipalArgument_ptr QuotingPrincipalArgumentRef;
typedef ObjVar< QuotingPrincipalArgument > QuotingPrincipalArgument_var;
typedef ObjOut< QuotingPrincipalArgument > QuotingPrincipalArgument_out;

class ATLASArgument;
typedef ATLASArgument *ATLASArgument_ptr;
typedef ATLASArgument_ptr ATLASArgumentRef;
typedef ObjVar< ATLASArgument > ATLASArgument_var;
typedef ObjOut< ATLASArgument > ATLASArgument_out;

class TokenProcessorSeqArgument;
typedef TokenProcessorSeqArgument *TokenProcessorSeqArgument_ptr;
typedef TokenProcessorSeqArgument_ptr TokenProcessorSeqArgumentRef;
typedef ObjVar< TokenProcessorSeqArgument > TokenProcessorSeqArgument_var;
typedef ObjOut< TokenProcessorSeqArgument > TokenProcessorSeqArgument_out;

class IPCInitiatorArgument;
typedef IPCInitiatorArgument *IPCInitiatorArgument_ptr;
typedef IPCInitiatorArgument_ptr IPCInitiatorArgumentRef;
typedef ObjVar< IPCInitiatorArgument > IPCInitiatorArgument_var;
typedef ObjOut< IPCInitiatorArgument > IPCInitiatorArgument_out;

class IPCAcceptorArgument;
typedef IPCAcceptorArgument *IPCAcceptorArgument_ptr;
typedef IPCAcceptorArgument_ptr IPCAcceptorArgumentRef;
typedef ObjVar< IPCAcceptorArgument > IPCAcceptorArgument_var;
typedef ObjOut< IPCAcceptorArgument > IPCAcceptorArgument_out;

class ObserverSeqArgument;
typedef ObserverSeqArgument *ObserverSeqArgument_ptr;
typedef ObserverSeqArgument_ptr ObserverSeqArgumentRef;
typedef ObjVar< ObserverSeqArgument > ObserverSeqArgument_var;
typedef ObjOut< ObserverSeqArgument > ObserverSeqArgument_out;

class IdentityProcessorArgument;
typedef IdentityProcessorArgument *IdentityProcessorArgument_ptr;
typedef IdentityProcessorArgument_ptr IdentityProcessorArgumentRef;
typedef ObjVar< IdentityProcessorArgument > IdentityProcessorArgument_var;
typedef ObjOut< IdentityProcessorArgument > IdentityProcessorArgument_out;

}






namespace SL3AQArgs
{

const char* const ArgsHolderType = "ArgsHolder";

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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef ArgsHolder_ptr _ptr_type;
    typedef ArgsHolder_var _var_type;
    #endif

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

    static ArgsHolder_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3CM::CredentialsUsage usage() = 0;
    virtual ::SL3AQArgs::ArgumentSeq* args() = 0;

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


const char* const CSIv1SupportType = "CSIv1Support";

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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CSIv1Support_ptr _ptr_type;
    typedef CSIv1Support_var _var_type;
    #endif

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

    static CSIv1Support_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::Boolean support() = 0;

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


const char* const CSIv2SupportType = "CSIv2Support";

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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef CSIv2Support_ptr _ptr_type;
    typedef CSIv2Support_var _var_type;
    #endif

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

    static CSIv2Support_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::Boolean support() = 0;

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


struct TCPIPInitiatorOptions;
typedef TVarVar< TCPIPInitiatorOptions > TCPIPInitiatorOptions_var;
typedef TVarOut< TCPIPInitiatorOptions > TCPIPInitiatorOptions_out;


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

  CORBA::String_var bind;
  CORBA::Long low_port;
  CORBA::Long high_port;
  CORBA::Long timeout;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_TCPIPInitiatorOptions;

const char* const TCPIPInitiatorArgumentType = "TCPIPInitiatorArgument";

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

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

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef TCPIPInitiatorArgument_ptr _ptr_type;
    typedef TCPIPInitiatorArgument_var _var_type;
    #endif

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

    static TCPIPInitiatorArgument_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual ::SL3AQArgs::TCPIPInitiatorOptions* options() = 0;

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


struct TCPIPAcceptorOptions;
typedef TVarVar< TCPIPAcceptorOptions > TCPIPAcceptorOptions_var;
typedef TVarOut< TCPIPAcceptorOptions > TCPIPAcceptorOptions_out;


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

  ::CORBA::StringSeq hosts;
  CORBA::String_var bind;
  CORBA::Long low_port;