sl3pm.h

MICO2.3.13 corba 环境平台

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

class QuotingPrincipal_init : public CORBA::ValueFactoryBase
{
  public:
    virtual ~QuotingPrincipal_init ();
    static QuotingPrincipal_init * _downcast (CORBA::ValueFactory);
    void * _narrow_helper (const char *);

    virtual QuotingPrincipal * create (Principal* speaking, Principal* quotes_for) = 0;

  protected:
    QuotingPrincipal_init ();
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_QuotingPrincipal;

typedef CORBA::ULong StatementType;
typedef StatementType& StatementType_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_StatementType;

const StatementType ST_IdentityStatement = 1;
const StatementType ST_EndorsementStatement = 2;
typedef SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> Encoding;
typedef TSeqVar< SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> > Encoding_var;
typedef TSeqOut< SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> > Encoding_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_Encoding;

typedef char* EncodingType;
typedef CORBA::String_var EncodingType_var;
typedef CORBA::String_out EncodingType_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_EncodingType;

const char* const ET_NoEncoding = "NoEncoding";
const char* const ET_Unknown = "Unknown";
struct BadEncoding : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  BadEncoding();
  ~BadEncoding();
  BadEncoding( const BadEncoding& s );
  BadEncoding& operator=( const BadEncoding& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  BadEncoding *operator->() { return this; }
  BadEncoding& operator*() { return *this; }
  operator BadEncoding*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static BadEncoding *_downcast( CORBA::Exception *ex );
  static const BadEncoding *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef BadEncoding BadEncoding_catch;
#else
typedef ExceptVar< BadEncoding > BadEncoding_var;
typedef TVarOut< BadEncoding > BadEncoding_out;
typedef BadEncoding_var BadEncoding_catch;
#endif // HAVE_STD_EH

extern MICO_EXPORT CORBA::TypeCodeConst _tc_BadEncoding;

struct BadEncodingType : public CORBA::UserException {
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  BadEncodingType();
  ~BadEncodingType();
  BadEncodingType( const BadEncodingType& s );
  BadEncodingType& operator=( const BadEncodingType& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS


  #ifdef HAVE_STD_EH
  BadEncodingType *operator->() { return this; }
  BadEncodingType& operator*() { return *this; }
  operator BadEncodingType*() { return this; }
  #endif // HAVE_STD_EH

  void _throwit() const;
  const char *_repoid() const;
  void _encode( CORBA::DataEncoder &en ) const;
  void _encode_any( CORBA::Any &a ) const;
  CORBA::Exception *_clone() const;
  static BadEncodingType *_downcast( CORBA::Exception *ex );
  static const BadEncodingType *_downcast( const CORBA::Exception *ex );
};

#ifdef HAVE_STD_EH
typedef BadEncodingType BadEncodingType_catch;
#else
typedef ExceptVar< BadEncodingType > BadEncodingType_var;
typedef TVarOut< BadEncodingType > BadEncodingType_out;
typedef BadEncodingType_var BadEncodingType_catch;
#endif // HAVE_STD_EH

extern MICO_EXPORT CORBA::TypeCodeConst _tc_BadEncodingType;

typedef CORBA::ULong StatementLayer;
typedef StatementLayer& StatementLayer_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_StatementLayer;

const StatementLayer SL_Unknown = 0;
const StatementLayer SL_Transport = 1;
const StatementLayer SL_CSIAuthorization = 2;
const StatementLayer SL_CSIClientAuth = 3;
const StatementLayer SL_CSIIdentity = 4;
const StatementLayer SL_UserDefined = 5;
class Statement;
typedef Statement *Statement_ptr;
typedef Statement_ptr StatementRef;
typedef ValueVar< Statement > Statement_var;
typedef ValueOut< Statement > Statement_out;


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

    virtual char* get_encoding_type() = 0;
    virtual ::SL3PM::Encoding* get_encoding( const char* encoding_type ) = 0;

    virtual void the_layer( ::SL3PM::StatementLayer _p ) = 0;
    virtual ::SL3PM::StatementLayer the_layer() const = 0;

    virtual void the_type( ::SL3PM::StatementType _p ) = 0;
    virtual ::SL3PM::StatementType the_type() const = 0;

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

    virtual void the_encoding( const ::SL3PM::Encoding& _p ) = 0;
    virtual const ::SL3PM::Encoding& the_encoding() const = 0;
    virtual ::SL3PM::Encoding& the_encoding() = 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:
    Statement ();
    virtual ~Statement ();
    void _copy_members (const Statement&);

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

class Statement_init : public CORBA::ValueFactoryBase
{
  public:
    virtual ~Statement_init ();
    static Statement_init * _downcast (CORBA::ValueFactory);
    void * _narrow_helper (const char *);

    virtual Statement * create (const char* encoding_type, const Encoding& the_encoding) = 0;

  protected:
    Statement_init ();
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_Statement;

typedef SequenceTmpl< Statement_var,MICO_TID_DEF> StatementList;
typedef TSeqVar< SequenceTmpl< Statement_var,MICO_TID_DEF> > StatementList_var;
typedef TSeqOut< SequenceTmpl< Statement_var,MICO_TID_DEF> > StatementList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_StatementList;

class IdentityStatement;
typedef IdentityStatement *IdentityStatement_ptr;
typedef IdentityStatement_ptr IdentityStatementRef;
typedef ValueVar< IdentityStatement > IdentityStatement_var;
typedef ValueOut< IdentityStatement > IdentityStatement_out;


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

    virtual void interpretation_aid( char *_p ) = 0;
    virtual void interpretation_aid( const char *_p ) = 0;
    virtual void interpretation_aid( const CORBA::String_var &_p ) = 0;
    virtual const char *interpretation_aid() 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:
    IdentityStatement ();
    virtual ~IdentityStatement ();
    void _copy_members (const IdentityStatement&);

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

extern MICO_EXPORT CORBA::TypeCodeConst _tc_IdentityStatement;

class PrincipalIdentityStatement;
typedef PrincipalIdentityStatement *PrincipalIdentityStatement_ptr;
typedef PrincipalIdentityStatement_ptr PrincipalIdentityStatementRef;
typedef ValueVar< PrincipalIdentityStatement > PrincipalIdentityStatement_var;
typedef ValueOut< PrincipalIdentityStatement > PrincipalIdentityStatement_out;


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

    virtual void the_principal( ::SL3PM::Principal* _p ) = 0;
    virtual ::SL3PM::Principal* the_principal() 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:
    PrincipalIdentityStatement ();
    virtual ~PrincipalIdentityStatement ();
    void _copy_members (const PrincipalIdentityStatement&);

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

extern MICO_EXPORT CORBA::TypeCodeConst _tc_PrincipalIdentityStatement;

class EndorsementStatement;
typedef EndorsementStatement *EndorsementStatement_ptr;
typedef EndorsementStatement_ptr EndorsementStatementRef;
typedef ValueVar< EndorsementStatement > EndorsementStatement_var;
typedef ValueOut< EndorsementStatement > EndorsementStatement_out;


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

    virtual void interpretation_aid( char *_p ) = 0;
    virtual void interpretation_aid( const char *_p ) = 0;
    virtual void interpretation_aid( const CORBA::String_var &_p ) = 0;
    virtual const char *interpretation_aid() 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:
    EndorsementStatement ();
    virtual ~EndorsementStatement ();
    void _copy_members (const EndorsementStatement&);

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

extern MICO_EXPORT CORBA::TypeCodeConst _tc_EndorsementStatement;

class X509IdentityStatement;
typedef X509IdentityStatement *X509IdentityStatement_ptr;
typedef X509IdentityStatement_ptr X509IdentityStatementRef;
typedef ValueVar< X509IdentityStatement > X509IdentityStatement_var;
typedef ValueOut< X509IdentityStatement > X509IdentityStatement_out;


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

  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:
    X509IdentityStatement ();
    virtual ~X509IdentityStatement ();
    void _copy_members (const X509IdentityStatement&);

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

class X509IdentityStatement_init : public CORBA::ValueFactoryBase
{
  public:
    virtual ~X509IdentityStatement_init ();
    static X509IdentityStatement_init * _downcast (CORBA::ValueFactory);
    void * _narrow_helper (const char *);

    virtual X509IdentityStatement * create (const char* encoding_type, const Encoding& the_encoding) = 0;

  protected:
    X509IdentityStatement_init ();
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_X509IdentityStatement;

typedef SequenceTmpl< X509IdentityStatement_var,MICO_TID_DEF> X509IdentityStatementList;
typedef TSeqVar< SequenceTmpl< X509IdentityStatement_var,MICO_TID_DEF> > X509IdentityStatementList_var;
typedef TSeqOut< SequenceTmpl< X509IdentityStatement_var,MICO_TID_DEF> > X509IdentityStatementList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_X509IdentityStatementList;

}


#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA



namespace OBV_SL3PM
{


// OBV class for valuetype Principal
class Principal : virtual public SL3PM::Principal
{
  public:
    Principal ();
    Principal (::SL3PM::PrincipalType _the_type, const ::SL3PM::PrincipalName& _the_name, const ::SL3PM::ScopedPrivilegesList& _with_privileges);
    virtual ~Principal();

  public: