Interstage Application Server リファレンスマニュアル（API編）

2.22.1 CosNotificationインタフェース

型の定義

　当モジュールで使用するデータ型の形式を示します。

class CosNotification
{
    typedef CORBA::Char    *Istring;
    typedef Istring        PropertyName;
    typedef CORBA::Any     PropertyValue;
    typedef CORBA::Any_var PropertyValue_var;

    struct Property {
        CORBA::String_var    name;
        PropertyValue_var    value;
    };
    typedef Property *Property_ptr;
    class Property_var {
    public:
        Property_var();
        Property_var( Property* );
        Property_var( const Property & );
        Property_var( const Property_var & );
        ~Property_var();
    };

    class PropertySeq {
    public:
        PropertySeq();
        PropertySeq( CORBA::ULong );
        PropertySeq( CORBA::ULong max,
                     CORBA::ULong length,
                     Property_var *data,
                     CORBA::Boolean release = CORBA_FALSE );
        PropertySeq( const PropertySeq &s );
        ~PropertySeq();
    };
    typedef PropertySeq *PropertySeq_ptr;
    class PropertySeq_var {
    public:
        PropertySeq_var();
        PropertySeq_var( PropertySeq_ptr );
        PropertySeq_var( const PropertySeq_var & );
        ~PropertySeq_var();
    };

    typedef PropertySeq OptionalHeaderFields;
    typedef PropertySeq_ptr OptionalHeaderFields_ptr;
    typedef PropertySeq_var OptionalHeaderFields_var;

    typedef PropertySeq FilterableEventBody;
    typedef PropertySeq_ptr FilterableEventBody_ptr;
    typedef PropertySeq_var FilterableEventBody_var;

    typedef PropertySeq QoSProperties;
    typedef PropertySeq_ptr QoSProperties_ptr;
    typedef PropertySeq_var QoSProperties_var;

    typedef PropertySeq AdminProperties;
    typedef PropertySeq_ptr AdminProperties_ptr;
    typedef PropertySeq_var AdminProperties_var;

    struct EventType {
        CORBA::String_var    domain_name;
        CORBA::String_var    type_name;
    };
    typedef EventType *EventType_ptr;
    class EventType_var {
    public:
        EventType_var();
        EventType_var( EventType* );
        EventType_var( const EventType & );
        EventType_var( const EventType_var & );
        ~EventType_var();
    };

    class EventTypeSeq {
    public:
        EventTypeSeq();
        EventTypeSeq( CORBA::ULong );
        EventTypeSeq( CORBA::ULong max,
                      CORBA::ULong length,
                      EventType_var *data,

                      CORBA::Boolean release = CORBA_FALSE );
        EventTypeSeq( const EventTypeSeq &s );
        ~EventTypeSeq();
    };
    typedef EventTypeSeq *EventTypeSeq_ptr;
    class EventTypeSeq_var {
    public:
        EventTypeSeq_var();
        EventTypeSeq_var( EventTypeSeq_ptr );
        EventTypeSeq_var( const EventTypeSeq_var & );
        ~EventTypeSeq_var();
    };

    struct PropertyRange {
        PropertyValue_var    low_val;
        PropertyValue_var    high_val;
    };
    typedef PropertyRange *PropertyRange_ptr;
    class PropertyRange_var {
    public:
        PropertyRange_var();
        PropertyRange_var( PropertyRange* );
        PropertyRange_var( const PropertyRange & );
        PropertyRange_var( const PropertyRange_var & );
        ~PropertyRange_var();
    };

    struct NamedPropertyRange {
        CORBA::String_var    name;
        PropertyRange_var    range;
    };
    typedef NamedPropertyRange *NamedPropertyRange_ptr;

    class NamedPropertyRangeSeq {
    public:
        NamedPropertyRangeSeq();
        NamedPropertyRangeSeq( CORBA::ULong );
        NamedPropertyRangeSeq( CORBA::ULong max,
                               CORBA::ULong length,
                               NamedPropertyRange_var *data,
                               CORBA::Boolean release = CORBA_FALSE );
        NamedPropertyRangeSeq( const NamedPropertyRangeSeq &s );
        ~NamedPropertyRangeSeq();
    };
    typedef NamedPropertyRangeSeq *NamedPropertyRangeSeq_ptr;
    class NamedPropertyRangeSeq_var {
    public:
        NamedPropertyRangeSeq_var();
        NamedPropertyRangeSeq_var( NamedPropertyRangeSeq_ptr );
        NamedPropertyRangeSeq_var( const NamedPropertyRangeSeq_var & );
        ~NamedPropertyRangeSeq_var();
    };

    enum QoSError_code {
        UNSUPPORTED_PROPERTY,
        UNAVAILABLE_PROPERTY,
        UNSUPPORTED_VALUE,
        UNAVAILABLE_VALUE,
        BAD_PROPERTY,
        BAD_TYPE,
        BAD_VALUE
    };

    struct PropertyError {
        QoSError_code        code;
        CORBA::String_var    name;
        PropertyRange_var    available_range;
    };
    typedef PropertyError *PropertyError_ptr;
    class PropertyError_var {
    public:
        PropertyError_var();
        PropertyError_var( PropertyError* );
        PropertyError_var( const PropertyError & );
        PropertyError_var( const PropertyError_var & );
        ~PropertyError_var();
    };

    class PropertyErrorSeq {
    public:
        PropertyErrorSeq();
        PropertyErrorSeq( CORBA::ULong );
        PropertyErrorSeq( CORBA::ULong max,
                          CORBA::ULong length,
                          PropertyError_var *data,
                          CORBA::Boolean release = CORBA_FALSE );
        PropertyErrorSeq( const PropertyErrorSeq &s );
        ~PropertyErrorSeq();
    };
    typedef PropertyErrorSeq *PropertyErrorSeq_ptr;
    class PropertyErrorSeq_var {
    public:
        PropertyErrorSeq_var();
        PropertyErrorSeq_var( PropertyErrorSeq_ptr );
        PropertyErrorSeq_var( const PropertyErrorSeq_var & );
        ~PropertyErrorSeq_var();
    };

    struct FixedEventHeader {
        EventType_var        event_type;
        CORBA::String_var    event_name;
    };
    typedef FixedEventHeader *FixedEventHeader_ptr;
    class FixedEventHeader_var {
    public:
        FixedEventHeader_var();
        FixedEventHeader_var( FixedEventHeader* );
        FixedEventHeader_var( const FixedEventHeader & );
        FixedEventHeader_var( const FixedEventHeader_var & );
        ~FixedEventHeader_var();
    };

    struct EventHeader {
        FixedEventHeader_var        fixed_header;
        OptionalHeaderFields_var    variable_header;
    };
    typedef EventHeader *EventHeader_ptr;
    class EventHeader_var {
    public:
        EventHeader_var();
        EventHeader_var( EventHeader* );
        EventHeader_var( const EventHeader & );
        EventHeader_var( const EventHeader_var & );
        ~EventHeader_var();
    };

    struct StructuredEvent {
        EventHeader_var            header;
        FilterableEventBody_var    filterable_data;
        CORBA::Any_var             remainder_of_body;
    };
    typedef StructuredEvent *StructuredEvent_ptr;
    class StructuredEvent_var {
    public:
        StructuredEvent_var();
        StructuredEvent_var( StructuredEvent* );
        StructuredEvent_var( const StructuredEvent & );
        StructuredEvent_var( const StructuredEvent_var & );
        ~StructuredEvent_var();
    };

};