sl3pm.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 __SL3PM_H__
#define __SL3PM_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 SL3PM
{

typedef char* NameType;
typedef CORBA::String_var NameType_var;
typedef CORBA::String_out NameType_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_NameType;

typedef CORBA::WChar* NameComponent;
typedef CORBA::WString_var NameComponent_var;
typedef CORBA::WString_out NameComponent_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_NameComponent;

typedef WStringSequenceTmpl<CORBA::WString_var> NamePath;
typedef TSeqVar< WStringSequenceTmpl<CORBA::WString_var> > NamePath_var;
typedef TSeqOut< WStringSequenceTmpl<CORBA::WString_var> > NamePath_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_NamePath;

typedef NamePath NameValue;
typedef TSeqVar< NamePath > NameValue_var;
typedef TSeqOut< NamePath > NameValue_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_NameValue;

struct PrincipalName;
typedef TVarVar< PrincipalName > PrincipalName_var;
typedef TVarOut< PrincipalName > PrincipalName_out;


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

  NameType_var the_type;
  NameValue the_name;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_PrincipalName;

typedef SequenceTmpl< PrincipalName,MICO_TID_DEF> PrincipalNameList;
typedef TSeqVar< SequenceTmpl< PrincipalName,MICO_TID_DEF> > PrincipalNameList_var;
typedef TSeqOut< SequenceTmpl< PrincipalName,MICO_TID_DEF> > PrincipalNameList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_PrincipalNameList;

typedef char* PrinAttributeType;
typedef CORBA::String_var PrinAttributeType_var;
typedef CORBA::String_out PrinAttributeType_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_PrinAttributeType;

typedef CORBA::WChar* PrinAttributeValue;
typedef CORBA::WString_var PrinAttributeValue_var;
typedef CORBA::WString_out PrinAttributeValue_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_PrinAttributeValue;

struct PrinAttribute;
typedef TVarVar< PrinAttribute > PrinAttribute_var;
typedef TVarOut< PrinAttribute > PrinAttribute_out;


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

  PrinAttributeType_var the_type;
  PrinAttributeValue_var the_value;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_PrinAttribute;

typedef SequenceTmpl< PrinAttribute,MICO_TID_DEF> PrinAttributeList;
typedef TSeqVar< SequenceTmpl< PrinAttribute,MICO_TID_DEF> > PrinAttributeList_var;
typedef TSeqOut< SequenceTmpl< PrinAttribute,MICO_TID_DEF> > PrinAttributeList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_PrinAttributeList;

struct ResourceName;
typedef TVarVar< ResourceName > ResourceName_var;
typedef TVarOut< ResourceName > ResourceName_out;


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

  typedef StringSequenceTmpl<CORBA::String_var> _components_seq;
  _components_seq components;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_ResourceName;

typedef SequenceTmpl< ResourceName,MICO_TID_DEF> ResourceNameList;
typedef TSeqVar< SequenceTmpl< ResourceName,MICO_TID_DEF> > ResourceNameList_var;
typedef TSeqOut< SequenceTmpl< ResourceName,MICO_TID_DEF> > ResourceNameList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_ResourceNameList;

const char* const NT_KerberosName = "oid:1.2.840.113554.1.2.2.1";
const char* const NT_X509DirectoryNamePath = "SL3:X509DirectoryPathName";
const char* const NT_Anonymous = "SL3:anonymous";
const char* const NT_StringName = "oid:2.23.130.1.2.1";
struct ScopedPrivileges;
typedef TVarVar< ScopedPrivileges > ScopedPrivileges_var;
typedef TVarOut< ScopedPrivileges > ScopedPrivileges_out;


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

  PrincipalName privilege_authority;
  PrinAttributeList privileges;
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_ScopedPrivileges;

typedef SequenceTmpl< ScopedPrivileges,MICO_TID_DEF> ScopedPrivilegesList;
typedef TSeqVar< SequenceTmpl< ScopedPrivileges,MICO_TID_DEF> > ScopedPrivilegesList_var;
typedef TSeqOut< SequenceTmpl< ScopedPrivileges,MICO_TID_DEF> > ScopedPrivilegesList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_ScopedPrivilegesList;

typedef CORBA::ULong PrincipalType;
typedef PrincipalType& PrincipalType_out;
extern MICO_EXPORT CORBA::TypeCodeConst _tc_PrincipalType;

const PrincipalType PT_Simple = 0;
const PrincipalType PT_Quoting = 1;
const PrincipalType PT_Proxy = 2;
class Principal;
typedef Principal *Principal_ptr;
typedef Principal_ptr PrincipalRef;
typedef ValueVar< Principal > Principal_var;
typedef ValueOut< Principal > Principal_out;


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

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

    virtual void the_name( const ::SL3PM::PrincipalName& _p ) = 0;
    virtual const ::SL3PM::PrincipalName& the_name() const = 0;
    virtual ::SL3PM::PrincipalName& the_name() = 0;

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

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

extern MICO_EXPORT CORBA::TypeCodeConst _tc_Principal;

typedef SequenceTmpl< Principal_var,MICO_TID_DEF> PrincipalList;
typedef TSeqVar< SequenceTmpl< Principal_var,MICO_TID_DEF> > PrincipalList_var;
typedef TSeqOut< SequenceTmpl< Principal_var,MICO_TID_DEF> > PrincipalList_out;

extern MICO_EXPORT CORBA::TypeCodeConst _tc_PrincipalList;

class SimplePrincipal;
typedef SimplePrincipal *SimplePrincipal_ptr;
typedef SimplePrincipal_ptr SimplePrincipalRef;
typedef ValueVar< SimplePrincipal > SimplePrincipal_var;
typedef ValueOut< SimplePrincipal > SimplePrincipal_out;


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

    virtual void authenticated( CORBA::Boolean _p ) = 0;
    virtual CORBA::Boolean authenticated() const = 0;

    virtual void alternate_names( const ::SL3PM::PrincipalNameList& _p ) = 0;
    virtual const ::SL3PM::PrincipalNameList& alternate_names() const = 0;
    virtual ::SL3PM::PrincipalNameList& alternate_names() = 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:
    SimplePrincipal ();
    virtual ~SimplePrincipal ();
    void _copy_members (const SimplePrincipal&);

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

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

    virtual SimplePrincipal * create (const PrincipalName& the_name, const ScopedPrivilegesList& with_privileges, const PrincipalNameList& alternate_names) = 0;

  protected:
    SimplePrincipal_init ();
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_SimplePrincipal;

class ProxyPrincipal;
typedef ProxyPrincipal *ProxyPrincipal_ptr;
typedef ProxyPrincipal_ptr ProxyPrincipalRef;
typedef ValueVar< ProxyPrincipal > ProxyPrincipal_var;
typedef ValueOut< ProxyPrincipal > ProxyPrincipal_out;


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

    virtual void speaking( ::SL3PM::Principal* _p ) = 0;
    virtual ::SL3PM::Principal* speaking() const = 0;

    virtual void speaks_for( ::SL3PM::Principal* _p ) = 0;
    virtual ::SL3PM::Principal* speaks_for() 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 &);
    CORBA::Long _count_refs (CORBA::ValueBase::visited * = 0);
    void _release_members ();

  protected:
    ProxyPrincipal ();
    virtual ~ProxyPrincipal ();

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

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

    virtual ProxyPrincipal * create (Principal* speaking, Principal* speaks_for) = 0;

  protected:
    ProxyPrincipal_init ();
};

extern MICO_EXPORT CORBA::TypeCodeConst _tc_ProxyPrincipal;

class QuotingPrincipal;
typedef QuotingPrincipal *QuotingPrincipal_ptr;
typedef QuotingPrincipal_ptr QuotingPrincipalRef;
typedef ValueVar< QuotingPrincipal > QuotingPrincipal_var;
typedef ValueOut< QuotingPrincipal > QuotingPrincipal_out;


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

    virtual void speaking( ::SL3PM::Principal* _p ) = 0;
    virtual ::SL3PM::Principal* speaking() const = 0;

    virtual void quotes_for( ::SL3PM::Principal* _p ) = 0;
    virtual ::SL3PM::Principal* quotes_for() 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 &);
    CORBA::Long _count_refs (CORBA::ValueBase::visited * = 0);
    void _release_members ();

  protected:
    QuotingPrincipal ();
    virtual ~QuotingPrincipal ();