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
|
// -*- C++ -*-
//=============================================================================
/**
* @file Array_VarOut_T.h
*
* $Id$
*
* @author Jeff Parsons
*/
//=============================================================================
#ifndef TAO_ARRAY_VAROUT_T_H
#define TAO_ARRAY_VAROUT_T_H
#include /**/ "ace/pre.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
namespace TAO
{
/**
* struct Array_Traits
*
* @brief Specialized for each array in generated code.
*
*/
template<typename T, typename T_slice, typename TAG>
struct Array_Traits
{
static T_slice * tao_alloc (void);
static void tao_free (T_slice * _tao_slice);
static T_slice * tao_dup (const T_slice * _tao_slice);
static void tao_copy (T_slice * _tao_to,
const T_slice * _tao_from);
};
}
/**
* @class TAO_Array_Var_Base_T
*
* @brief Parametrized implementation of _var base class for arrays.
*
*/
template<typename T, typename T_slice, typename TAG>
class TAO_Array_Var_Base_T
{
public:
TAO_Array_Var_Base_T (void);
TAO_Array_Var_Base_T (T_slice *);
TAO_Array_Var_Base_T (const TAO_Array_Var_Base_T<T,T_slice,TAG> &);
~TAO_Array_Var_Base_T (void);
T_slice & operator[] (CORBA::ULong index);
T_slice const & operator[] (CORBA::ULong index) const;
operator T_slice * const & () const;
typedef const T_slice * _in_type;
typedef T_slice * _inout_type;
typedef T_slice *& _out_type;
typedef T_slice * _retn_type;
// in, inout, out, _retn
_in_type in (void) const;
_inout_type inout (void);
_out_type out (void);
_retn_type _retn (void);
// TAO extension.
_retn_type ptr (void) const;
protected:
T_slice * ptr_;
};
/**
* @class TAO_FixedArray_Var_T
*
* @brief Parametrized implementation of _var class for arrays with
* elements of fixed size.
*
*/
template<typename T, typename T_slice, typename TAG>
class TAO_FixedArray_Var_T: public TAO_Array_Var_Base_T<T,T_slice,TAG>
{
public:
TAO_FixedArray_Var_T (void);
TAO_FixedArray_Var_T (T_slice *);
TAO_FixedArray_Var_T (const TAO_FixedArray_Var_T<T,T_slice,TAG> &);
TAO_FixedArray_Var_T<T,T_slice,TAG> &operator= (T_slice *);
TAO_FixedArray_Var_T<T,T_slice,TAG> &operator= (
const TAO_FixedArray_Var_T<T,T_slice,TAG> &
);
};
/**
* @class TAO_VarArray_Var_T
*
* @brief Parametrized implementation of _var class for arrays with
* elements of variable size.
*
*/
template<typename T, typename T_slice, typename TAG>
class TAO_VarArray_Var_T : public TAO_Array_Var_Base_T<T,T_slice,TAG>
{
public:
TAO_VarArray_Var_T (void);
TAO_VarArray_Var_T (T_slice *);
TAO_VarArray_Var_T (const TAO_VarArray_Var_T<T,T_slice,TAG> &);
TAO_VarArray_Var_T<T,T_slice,TAG> &operator= (T_slice *);
TAO_VarArray_Var_T<T,T_slice,TAG> &operator= (
const TAO_VarArray_Var_T<T,T_slice,TAG> &
);
operator T_slice *& ();
};
/**
* @class TAO_Array_Out_T
*
* @brief Parametrized implementation of _out class for arrays.
*
*/
template<typename T, typename T_var, typename T_slice, typename TAG>
class TAO_Array_Out_T
{
public:
TAO_Array_Out_T (T_slice *&);
TAO_Array_Out_T (T_var &);
TAO_Array_Out_T (const TAO_Array_Out_T<T,T_var,T_slice,TAG> &);
TAO_Array_Out_T<T,T_var,T_slice,TAG> &operator= (
const TAO_Array_Out_T<T,T_var,T_slice,TAG> &
);
TAO_Array_Out_T<T,T_var,T_slice,TAG> &operator= (T_slice *);
operator T_slice *& ();
T_slice *& ptr (void);
T_slice & operator[] (CORBA::ULong index);
const T_slice & operator[] (CORBA::ULong index) const;
private:
typedef TAO_Array_Out_T<T,T_var,T_slice,TAG> THIS_OUT_TYPE;
T_slice *& ptr_;
// Assignment from T_var not allowed.
void operator= (const T_var &);
};
/**
* @class TAO_Array_Forany_T
*
* @brief Parametrized implementation of _forany class for arrays.
*
*/
template<typename T, typename T_slice, typename TAG>
class TAO_Array_Forany_T
{
public:
TAO_Array_Forany_T (void);
TAO_Array_Forany_T (T_slice *,
CORBA::Boolean nocopy = 0);
TAO_Array_Forany_T (const TAO_Array_Forany_T<T,T_slice,TAG> &);
~TAO_Array_Forany_T (void);
static void _tao_any_destructor (void *);
TAO_Array_Forany_T & operator= (T_slice *);
TAO_Array_Forany_T & operator= (
const TAO_Array_Forany_T<T,T_slice,TAG> &
);
T_slice & operator[] (CORBA::ULong index);
const T_slice & operator[] (CORBA::ULong index) const;
operator T_slice * const & () const;
operator T_slice *& ();
// in, inout, out, _retn
const T_slice * in (void) const;
T_slice * inout (void);
T_slice * &out (void);
T_slice * _retn (void);
T_slice * ptr (void) const;
CORBA::Boolean nocopy (void) const;
static T_slice * tao_alloc (void);
private:
T_slice * ptr_;
const CORBA::Boolean nocopy_;
};
#if defined (__ACE_INLINE__)
#include "tao/Array_VarOut_T.inl"
#endif /* __ACE_INLINE__ */
#if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
#include "tao/Array_VarOut_T.cpp"
#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
#pragma implementation ("Array_VarOut_T.cpp")
#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
#include /**/ "ace/post.h"
#endif /* TAO_ARRAY_VAROUT_T_H */
|
