summaryrefslogtreecommitdiff
path: root/TAO/tao/DynamicAny/DynamicAny.pidl
blob: 44efe91babb55303ea48982093d4e16c6697cc6a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
/**
 * @file DynamicAny.pidl
 *
 * $Id$
 *
 * @brief Pre-compiled IDL source for the DynamicAny module.
 *
 * This file is used to generate the code in DynamicAnyC.{h,i,cpp}, it
 * was obtained from the OMG website as part of the full CORBA IDL,
 * the document reference number is: formal/00-04-01, or use the
 * following URL:
 * http://www.omg.org/technology/documents/formal/corba_omg_idl_text_file.htm
 *
 * We couldn't find a copyright notice in the document, but it is safe
 * to assume that it is Copyright (C) 2000, OMG.
 *
 * We performed some modifications to the file, mainly to use local
 * interfaces (part of what is coming in CORBA 3.0)
 *
 * The command used to generate code from this file is:
 *
 * tao_idl \
 *  -o orig -Gp -Gd -Ge 1 -Sa -St \
 *          -Wb,export_macro=TAO_DynamicAny_Export \
 *          -Wb,export_include=dynamicany_export.h \
 *          -Wb,pre_include="ace/pre.h" \
 *          -Wb,post_include="ace/post.h" \
 *          DynamicAny.pidl
 *
 * after the file is generated a patch must be applied.  The patch
 * fixes some problems with interceptors and local interfaces and
 * disables parts of the code under certain configurations.
 *
 * Apply patches using:
 *
 *   patch < diffs/DynamicAny.diff
 *
 * Note: The diffs are generated using:
 *
 *   for i in DynamicAnyC.{h,i,cpp}; do
 *     diff -wbu orig/$i $i > diffs/DynamicAny.diff
 *   done
 *
 */

#ifndef _DYNAMIC_ANY_IDL_
#define _DYNAMIC_ANY_IDL_

#include <orb.idl>

#pragma prefix "omg.org"

module DynamicAny {

    local interface DynAny {
        exception InvalidValue {};
        exception TypeMismatch {};

        CORBA::TypeCode type();

        void assign(        in DynAny   dyn_any)    raises(TypeMismatch);
        void from_any(      in any      value)      raises(TypeMismatch, InvalidValue);
        any to_any();

        boolean equal(      in DynAny   dyn_any);

        void destroy();
        DynAny copy();
        void insert_boolean(in boolean  value)      raises(TypeMismatch, InvalidValue);
        void insert_octet(  in octet    value)      raises(TypeMismatch, InvalidValue);
        void insert_char(   in char     value)      raises(TypeMismatch, InvalidValue);
        void insert_short(  in short    value)      raises(TypeMismatch, InvalidValue);
        void insert_ushort( in unsigned short
                                        value)      raises(TypeMismatch, InvalidValue);
        void insert_long(   in long     value)      raises(TypeMismatch, InvalidValue);
        void insert_ulong(  in unsigned long
                                        value)      raises(TypeMismatch, InvalidValue);
        void insert_float(  in float    value)      raises(TypeMismatch, InvalidValue);
        void insert_double( in double   value)      raises(TypeMismatch, InvalidValue);
        void insert_string( in string   value)      raises(TypeMismatch, InvalidValue);
        void insert_reference(in Object value)      raises(TypeMismatch, InvalidValue);
        void insert_typecode(in CORBA::TypeCode
                                        value)      raises(TypeMismatch, InvalidValue);
        void insert_longlong(in long long value)    raises(TypeMismatch, InvalidValue);
        void insert_ulonglong(in unsigned long long
                                        value)      raises(TypeMismatch, InvalidValue);
        void insert_longdouble(in long double
                                        value)      raises(TypeMismatch, InvalidValue);
        void insert_wchar(  in wchar    value)      raises(TypeMismatch, InvalidValue);
        void insert_wstring(in wstring  value)      raises(TypeMismatch, InvalidValue);
        void insert_any(    in any      value)      raises(TypeMismatch, InvalidValue);
        void insert_dyn_any(in DynAny   value)      raises(TypeMismatch, InvalidValue);
        void insert_val(    in ValueBase value)     raises(TypeMismatch, InvalidValue);

        boolean         get_boolean()               raises(TypeMismatch, InvalidValue);
        octet           get_octet()                 raises(TypeMismatch, InvalidValue);
        char            get_char()                  raises(TypeMismatch, InvalidValue);
        short           get_short()                 raises(TypeMismatch, InvalidValue);
        unsigned short  get_ushort()                raises(TypeMismatch, InvalidValue);
        long            get_long()                  raises(TypeMismatch, InvalidValue);
        unsigned long   get_ulong()                 raises(TypeMismatch, InvalidValue);
        float           get_float()                 raises(TypeMismatch, InvalidValue);
        double          get_double()                raises(TypeMismatch, InvalidValue);
        string          get_string()                raises(TypeMismatch, InvalidValue);
        Object          get_reference()             raises(TypeMismatch, InvalidValue);
        CORBA::TypeCode get_typecode()              raises(TypeMismatch, InvalidValue);
        long long       get_longlong()              raises(TypeMismatch, InvalidValue);
        unsigned long long get_ulonglong()          raises(TypeMismatch, InvalidValue);
        long double     get_longdouble()            raises(TypeMismatch, InvalidValue);
        wchar           get_wchar()                 raises(TypeMismatch, InvalidValue);
        wstring         get_wstring()               raises(TypeMismatch, InvalidValue);
        any             get_any()                   raises(TypeMismatch, InvalidValue);
        DynAny          get_dyn_any()               raises(TypeMismatch, InvalidValue);
        ValueBase       get_val()                   raises(TypeMismatch, InvalidValue);

        boolean         seek(in long index);
        void            rewind();
        boolean         next();
        unsigned long   component_count();
        DynAny          current_component()         raises(TypeMismatch);
    };

    local interface DynFixed : DynAny {
        string          get_value();
        boolean         set_value(in string val)    raises(TypeMismatch, InvalidValue);
    };

    local interface DynEnum : DynAny {
        string          get_as_string();
        void            set_as_string(in string value)
                                                    raises(InvalidValue);
        unsigned long   get_as_ulong();
        void            set_as_ulong( in unsigned long value)
                                                    raises(InvalidValue);
    };
    typedef string FieldName;
    struct NameValuePair {
        FieldName   id;
        any         value;
    };

    typedef sequence<NameValuePair> NameValuePairSeq;
    struct NameDynAnyPair {
        FieldName   id;
        DynAny      value;
    };

    typedef sequence<NameDynAnyPair> NameDynAnyPairSeq;
    local interface DynStruct : DynAny {
        FieldName           current_member_name()   raises(TypeMismatch, InvalidValue);
        CORBA::TCKind       current_member_kind()   raises(TypeMismatch, InvalidValue);
        NameValuePairSeq    get_members();
        void                set_members(in NameValuePairSeq value)
                                                    raises(TypeMismatch, InvalidValue);
        NameDynAnyPairSeq   get_members_as_dyn_any();
        void                set_members_as_dyn_any(in NameDynAnyPairSeq value)
                                                    raises(TypeMismatch, InvalidValue);
    };

    local interface DynUnion : DynAny {
        DynAny              get_discriminator();
        void                set_discriminator(in DynAny d)
                                                    raises(TypeMismatch);
        void                set_to_default_member() raises(TypeMismatch);
        void                set_to_no_active_member() raises(TypeMismatch);
        boolean             has_no_active_member();
        CORBA::TCKind       discriminator_kind();
        DynAny              member()                raises(InvalidValue);
        FieldName           member_name()           raises(InvalidValue);
        CORBA::TCKind       member_kind()           raises(InvalidValue);
    };

    typedef sequence<any>    AnySeq;
    typedef sequence<DynAny> DynAnySeq;
    local interface DynSequence : DynAny {
        unsigned long       get_length();
        void                set_length(in unsigned long len)
                                                    raises(InvalidValue);
        AnySeq              get_elements();
        void                set_elements(in AnySeq value)
                                                    raises(TypeMismatch, InvalidValue);
        DynAnySeq           get_elements_as_dyn_any();
        void                set_elements_as_dyn_any(in DynAnySeq value)
                                                    raises(TypeMismatch, InvalidValue);
    };

    local interface DynArray : DynAny {
        AnySeq              get_elements();
        void                set_elements(in AnySeq value)
                                                    raises(TypeMismatch, InvalidValue);
        DynAnySeq           get_elements_as_dyn_any();
        void                set_elements_as_dyn_any(in DynAnySeq value)
                                                    raises(TypeMismatch, InvalidValue);
    };

    local interface DynValue : DynAny {
        FieldName           current_member_name()   raises(TypeMismatch, InvalidValue);
        CORBA::TCKind       current_member_kind()   raises(TypeMismatch, InvalidValue);
        NameValuePairSeq    get_members();
        void                set_members(in NameValuePairSeq value)
                                                    raises(TypeMismatch, InvalidValue);
        NameDynAnyPairSeq   get_members_as_dyn_any();
        void                set_members_as_dyn_any(in NameDynAnyPairSeq value)
                                                    raises(TypeMismatch, InvalidValue);
    };

    local interface DynAnyFactory {
        exception           InconsistentTypeCode {};
        DynAny              create_dyn_any(in any value)
                                                    raises(InconsistentTypeCode);
        DynAny              create_dyn_any_from_type_code(in CORBA::TypeCode type)
                                                    raises(InconsistentTypeCode);
    };

}; // module DynamicAny

#endif // _DYNAMIC_ANY_IDL_