sl3pm.h

MICO2.3.13 corba 环境平台

    void the_type( ::SL3PM::PrincipalType _p );
    ::SL3PM::PrincipalType the_type() const;

    void the_name( const ::SL3PM::PrincipalName& _p );
    const ::SL3PM::PrincipalName& the_name() const;
    ::SL3PM::PrincipalName& the_name();

    void with_privileges( const ::SL3PM::ScopedPrivilegesList& _p );
    const ::SL3PM::ScopedPrivilegesList& with_privileges() const;
    ::SL3PM::ScopedPrivilegesList& with_privileges();


  private:
    struct _M {
      ::SL3PM::PrincipalType the_type;
      ::SL3PM::PrincipalName the_name;
      ::SL3PM::ScopedPrivilegesList with_privileges;
    } _m;
};


// OBV class for valuetype SimplePrincipal
class SimplePrincipal :
  virtual public SL3PM::SimplePrincipal,
  virtual public OBV_SL3PM::Principal
{
  public:
    SimplePrincipal ();
    SimplePrincipal (::SL3PM::PrincipalType _the_type, const ::SL3PM::PrincipalName& _the_name, const ::SL3PM::ScopedPrivilegesList& _with_privileges, CORBA::Boolean _authenticated, const ::SL3PM::PrincipalNameList& _alternate_names);
    virtual ~SimplePrincipal();

  public:
    void authenticated( CORBA::Boolean _p );
    CORBA::Boolean authenticated() const;

    void alternate_names( const ::SL3PM::PrincipalNameList& _p );
    const ::SL3PM::PrincipalNameList& alternate_names() const;
    ::SL3PM::PrincipalNameList& alternate_names();


  private:
    struct _M {
      CORBA::Boolean authenticated;
      ::SL3PM::PrincipalNameList alternate_names;
    } _m;
};


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

  public:
    void speaking( ::SL3PM::Principal* _p );
    ::SL3PM::Principal* speaking() const;

    void speaks_for( ::SL3PM::Principal* _p );
    ::SL3PM::Principal* speaks_for() const;


  private:
    struct _M {
      ::SL3PM::Principal_var speaking;
      ::SL3PM::Principal_var speaks_for;
    } _m;
};


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

  public:
    void speaking( ::SL3PM::Principal* _p );
    ::SL3PM::Principal* speaking() const;

    void quotes_for( ::SL3PM::Principal* _p );
    ::SL3PM::Principal* quotes_for() const;


  private:
    struct _M {
      ::SL3PM::Principal_var speaking;
      ::SL3PM::Principal_var quotes_for;
    } _m;
};


// OBV class for valuetype Statement
class Statement : virtual public SL3PM::Statement
{
  protected:
    Statement ();
    Statement (::SL3PM::StatementLayer _the_layer, ::SL3PM::StatementType _the_type, const char* _encoding_type, const ::SL3PM::Encoding& _the_encoding);
    virtual ~Statement();

  public:
    void the_layer( ::SL3PM::StatementLayer _p );
    ::SL3PM::StatementLayer the_layer() const;

    void the_type( ::SL3PM::StatementType _p );
    ::SL3PM::StatementType the_type() const;

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

    void the_encoding( const ::SL3PM::Encoding& _p );
    const ::SL3PM::Encoding& the_encoding() const;
    ::SL3PM::Encoding& the_encoding();


  private:
    struct _M {
      ::SL3PM::StatementLayer the_layer;
      ::SL3PM::StatementType the_type;
      ::SL3PM::EncodingType_var encoding_type;
      ::SL3PM::Encoding the_encoding;
    } _m;
};


// OBV class for valuetype IdentityStatement
class IdentityStatement :
  virtual public SL3PM::IdentityStatement,
  virtual public OBV_SL3PM::Statement
{
  protected:
    IdentityStatement ();
    IdentityStatement (::SL3PM::StatementLayer _the_layer, ::SL3PM::StatementType _the_type, const char* _encoding_type, const ::SL3PM::Encoding& _the_encoding, const char* _interpretation_aid);
    virtual ~IdentityStatement();

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


  private:
    struct _M {
      CORBA::String_var interpretation_aid;
    } _m;
};


// OBV class for valuetype PrincipalIdentityStatement
class PrincipalIdentityStatement :
  virtual public SL3PM::PrincipalIdentityStatement,
  virtual public OBV_SL3PM::IdentityStatement
{
  protected:
    PrincipalIdentityStatement ();
    PrincipalIdentityStatement (::SL3PM::StatementLayer _the_layer, ::SL3PM::StatementType _the_type, const char* _encoding_type, const ::SL3PM::Encoding& _the_encoding, const char* _interpretation_aid, ::SL3PM::Principal* _the_principal);
    virtual ~PrincipalIdentityStatement();

  public:
    void the_principal( ::SL3PM::Principal* _p );
    ::SL3PM::Principal* the_principal() const;


  private:
    struct _M {
      ::SL3PM::Principal_var the_principal;
    } _m;
};


// OBV class for valuetype EndorsementStatement
class EndorsementStatement :
  virtual public SL3PM::EndorsementStatement,
  virtual public OBV_SL3PM::Statement
{
  protected:
    EndorsementStatement ();
    EndorsementStatement (::SL3PM::StatementLayer _the_layer, ::SL3PM::StatementType _the_type, const char* _encoding_type, const ::SL3PM::Encoding& _the_encoding, const char* _interpretation_aid);
    virtual ~EndorsementStatement();

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


  private:
    struct _M {
      CORBA::String_var interpretation_aid;
    } _m;
};


// OBV class for valuetype X509IdentityStatement
class X509IdentityStatement :
  virtual public SL3PM::X509IdentityStatement,
  virtual public OBV_SL3PM::PrincipalIdentityStatement
{
  protected:
    X509IdentityStatement ();
    X509IdentityStatement (::SL3PM::StatementLayer _the_layer, ::SL3PM::StatementType _the_type, const char* _encoding_type, const ::SL3PM::Encoding& _the_encoding, const char* _interpretation_aid, ::SL3PM::Principal* _the_principal);
    virtual ~X509IdentityStatement();


  private:
    struct _M {
    } _m;
};

}


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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_PrincipalName;

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_PrinAttribute;

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_ResourceName;

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_ScopedPrivileges;

void operator<<=( CORBA::Any &a, const SL3PM::Principal* val );
void operator<<=( CORBA::Any &a, SL3PM::Principal** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, SL3PM::Principal* & val_ptr );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_Principal;

void operator<<=( CORBA::Any &a, const SL3PM::SimplePrincipal* val );
void operator<<=( CORBA::Any &a, SL3PM::SimplePrincipal** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, SL3PM::SimplePrincipal* & val_ptr );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_SimplePrincipal;

void operator<<=( CORBA::Any &a, const SL3PM::ProxyPrincipal* val );
void operator<<=( CORBA::Any &a, SL3PM::ProxyPrincipal** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, SL3PM::ProxyPrincipal* & val_ptr );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_ProxyPrincipal;

void operator<<=( CORBA::Any &a, const SL3PM::QuotingPrincipal* val );
void operator<<=( CORBA::Any &a, SL3PM::QuotingPrincipal** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, SL3PM::QuotingPrincipal* & val_ptr );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_QuotingPrincipal;

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

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_BadEncoding;

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

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_BadEncodingType;

void operator<<=( CORBA::Any &a, const SL3PM::Statement* val );
void operator<<=( CORBA::Any &a, SL3PM::Statement** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, SL3PM::Statement* & val_ptr );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_Statement;

void operator<<=( CORBA::Any &a, const SL3PM::IdentityStatement* val );
void operator<<=( CORBA::Any &a, SL3PM::IdentityStatement** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, SL3PM::IdentityStatement* & val_ptr );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_IdentityStatement;

void operator<<=( CORBA::Any &a, const SL3PM::PrincipalIdentityStatement* val );
void operator<<=( CORBA::Any &a, SL3PM::PrincipalIdentityStatement** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, SL3PM::PrincipalIdentityStatement* & val_ptr );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_PrincipalIdentityStatement;

void operator<<=( CORBA::Any &a, const SL3PM::EndorsementStatement* val );
void operator<<=( CORBA::Any &a, SL3PM::EndorsementStatement** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, SL3PM::EndorsementStatement* & val_ptr );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_EndorsementStatement;

void operator<<=( CORBA::Any &a, const SL3PM::X509IdentityStatement* val );
void operator<<=( CORBA::Any &a, SL3PM::X509IdentityStatement** val_ptr );
CORBA::Boolean operator>>=( const CORBA::Any &a, SL3PM::X509IdentityStatement* & val_ptr );

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_SL3PM_X509IdentityStatement;

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

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller__seq_SL3PM_PrincipalName;

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller__seq_SL3PM_PrinAttribute;

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

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller__seq_SL3PM_ResourceName;

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller__seq_SL3PM_ScopedPrivileges;

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller__seq_SL3PM_Principal;

void operator<<=( CORBA::Any &_a, const SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> &_s );
void operator<<=( CORBA::Any &_a, SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> *_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> &_s );
CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl< CORBA::Octet,MICO_TID_OCTET> *&_s );

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller__seq_SL3PM_Statement;

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

extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller__seq_SL3PM_X509IdentityStatement;

#endif