← Back to branch summary

~ifolder-dev/simias/trunk-packaging

« back to all changes in this revision

Viewing changes to tools/gsoap/gsoap-linux-2.7/samples/varparam/.svn/text-base/varparam.h.svn-base

  • Committer: Jorge O. Castro
  • Date: 2007-12-03 06:56:46 UTC
  • Revision ID: jorge@ubuntu.com-20071203065646-mupcnjcwgm5mnhyt
* Remove a bunch of .svn directories we no longer need.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/gsoap/gsoap-linux-2.7/samples/varparam/.svn/text-base/varparam.h.svn-base
1
 
/*      varparam.h
2
 
 
3
 
        Example use of variable parameter lists with the full XML
4
 
        schema type hierarchy implemented as a C++ class hierarchy.
5
 
 
6
 
        Copyright (C) 2000-2002 Robert A. van Engelen. All Rights Reserved.
7
 
*/
8
 
 
9
 
//gsoap ns service name:        varparam
10
 
//gsoap ns service style:       rpc
11
 
//gsoap ns service encoding:    encoded
12
 
//gsoap ns service namespace:   urn:varparam
13
 
//gsoap ns service location:    http://websrv.cs.fsu.edu/~engelen/varparam.cgi
14
 
 
15
 
#include <iostream>
16
 
extern class std::ostream;      // transient (external) type
17
 
 
18
 
class xsd__anyType
19
 
{ char *__item;         // default is string, also to hold mixed-content when receiving typeless XML
20
 
  struct soap *soap;    // points to current gSOAP environment that created this object
21
 
  xsd__anyType();
22
 
  virtual ~xsd__anyType();
23
 
  virtual xsd__anyType*& operator[](int i);
24
 
  virtual void print(std::ostream &s) const;
25
 
};
26
 
 
27
 
class xsd__anySimpleType: xsd__anyType
28
 
{ xsd__anySimpleType();
29
 
  virtual ~xsd__anySimpleType();
30
 
  virtual void print(std::ostream &s) const;
31
 
};
32
 
 
33
 
class xsd__anyURI: xsd__anySimpleType
34
 
{ xsd__anyURI();
35
 
  virtual ~xsd__anyURI();
36
 
  xsd__anyURI(char *s);
37
 
  virtual void print(std::ostream &s) const;
38
 
}; 
39
 
 
40
 
class xsd__boolean: xsd__anySimpleType
41
 
{ bool __item;
42
 
  xsd__boolean();
43
 
  virtual ~xsd__boolean();
44
 
  xsd__boolean(bool b);
45
 
  virtual void print(std::ostream &s) const;
46
 
}; 
47
 
 
48
 
class xsd__date: xsd__anySimpleType     // requires "CCYY-MM-DD" string values
49
 
{ xsd__date();
50
 
  virtual ~xsd__date();
51
 
  xsd__date(char *s);
52
 
  virtual void print(std::ostream &s) const;
53
 
};
54
 
 
55
 
class xsd__dateTime: xsd__anySimpleType
56
 
{ time_t __item;                // remove time_t __item to use char*__item with "CCYY-MM-DDThh:mm:ssi" for dates outside the range 1902-2037
57
 
  xsd__dateTime();
58
 
  virtual ~xsd__dateTime();
59
 
  xsd__dateTime(time_t t);
60
 
  virtual void print(std::ostream &s) const;
61
 
};
62
 
 
63
 
class xsd__double: xsd__anySimpleType
64
 
{ double __item;
65
 
  xsd__double();
66
 
  virtual ~xsd__double();
67
 
  xsd__double(double d);
68
 
  virtual void print(std::ostream &s) const;
69
 
}; 
70
 
 
71
 
class xsd__duration: xsd__anySimpleType // requires "PnYnMnDTnHnMnS" string values
72
 
{ xsd__duration();
73
 
  virtual ~xsd__duration();
74
 
  xsd__duration(char *s);
75
 
  virtual void print(std::ostream &s) const;
76
 
};
77
 
 
78
 
class xsd__float: xsd__anySimpleType
79
 
{ float __item;
80
 
  xsd__float();
81
 
  virtual ~xsd__float();
82
 
  xsd__float(float f);
83
 
  virtual void print(std::ostream &s) const;
84
 
}; 
85
 
 
86
 
class xsd__time: xsd__anySimpleType     // requires "hh:mm:ss" string values
87
 
{ xsd__time();
88
 
  virtual ~xsd__time();
89
 
  xsd__time(char *s);
90
 
  virtual void print(std::ostream &s) const;
91
 
};
92
 
 
93
 
class xsd__string: xsd__anySimpleType
94
 
{ xsd__string();
95
 
  xsd__string(char *s);
96
 
  virtual ~xsd__string();
97
 
  virtual void print(std::ostream &s) const;
98
 
}; 
99
 
 
100
 
class xsd__normalizedString: xsd__string        // requires strings without CR, LF, TAB
101
 
{ xsd__normalizedString();
102
 
  xsd__normalizedString(char *s);
103
 
  virtual ~xsd__normalizedString();
104
 
  virtual void print(std::ostream &s) const;
105
 
}; 
106
 
 
107
 
class xsd__token: xsd__normalizedString         // requires strings without CR, LF, TAB, no leading/trailing spaces, and no sequences of more than one space
108
 
{ xsd__token();
109
 
  xsd__token(char *s);
110
 
  virtual ~xsd__token();
111
 
  virtual void print(std::ostream &s) const;
112
 
}; 
113
 
 
114
 
class xsd__decimal: xsd__anySimpleType  // requires decimal as string values, can use double, but possible loss of precision
115
 
{ xsd__decimal();
116
 
  virtual ~xsd__decimal();
117
 
  xsd__decimal(char *s);
118
 
  virtual void print(std::ostream &s) const;
119
 
};
120
 
 
121
 
class xsd__integer: xsd__decimal        // requires integer as string values, can use loong long, but possible loss of data
122
 
{ xsd__integer();
123
 
  virtual ~xsd__integer();
124
 
  xsd__integer(char *s);
125
 
  virtual void print(std::ostream &s) const;
126
 
};
127
 
 
128
 
class xsd__nonPositiveInteger: xsd__integer     // requires non-positive integer as string values
129
 
{ xsd__nonPositiveInteger();
130
 
  virtual ~xsd__nonPositiveInteger();
131
 
  xsd__nonPositiveInteger(char *s);
132
 
  virtual void print(std::ostream &s) const;
133
 
}; 
134
 
 
135
 
class xsd__negativeInteger: xsd__nonPositiveInteger     // requires negative integer as string values
136
 
{ xsd__negativeInteger();
137
 
  virtual ~xsd__negativeInteger();
138
 
  xsd__negativeInteger(char *s);
139
 
  virtual void print(std::ostream &s) const;
140
 
}; 
141
 
 
142
 
class xsd__nonNegativeInteger: xsd__integer     // requires non-negative integer as string values
143
 
{ xsd__nonNegativeInteger();
144
 
  virtual ~xsd__nonNegativeInteger();
145
 
  xsd__nonNegativeInteger(char *s);
146
 
  virtual void print(std::ostream &s) const;
147
 
}; 
148
 
 
149
 
class xsd__positiveInteger: xsd__nonNegativeInteger     // requires positive integer as string values
150
 
{ xsd__positiveInteger();
151
 
  virtual ~xsd__positiveInteger();
152
 
  xsd__positiveInteger(char *s);
153
 
  virtual void print(std::ostream &s) const;
154
 
}; 
155
 
 
156
 
class xsd__long: xsd__integer
157
 
{ LONG64 __item;
158
 
  xsd__long();
159
 
  virtual ~xsd__long();
160
 
  xsd__long(LONG64 ll);
161
 
  virtual void print(std::ostream &s) const;
162
 
}; 
163
 
 
164
 
class xsd__int: xsd__long
165
 
{ int __item;
166
 
  xsd__int();
167
 
  virtual ~xsd__int();
168
 
  xsd__int(int i);
169
 
  virtual void print(std::ostream &s) const;
170
 
}; 
171
 
 
172
 
class xsd__short: xsd__int
173
 
{ short __item;
174
 
  xsd__short();
175
 
  virtual ~xsd__short();
176
 
  xsd__short(short h);
177
 
  virtual void print(std::ostream &s) const;
178
 
}; 
179
 
 
180
 
class xsd__byte: xsd__short
181
 
{ char __item;
182
 
  xsd__byte();
183
 
  virtual ~xsd__byte();
184
 
  xsd__byte(char c);
185
 
  virtual void print(std::ostream &s) const;
186
 
}; 
187
 
 
188
 
class xsd__unsignedLong: xsd__nonNegativeInteger
189
 
{ ULONG64 __item;
190
 
  xsd__unsignedLong();
191
 
  virtual ~xsd__unsignedLong();
192
 
  xsd__unsignedLong(ULONG64 ull);
193
 
  virtual void print(std::ostream &s) const;
194
 
}; 
195
 
 
196
 
class xsd__unsignedInt: xsd__unsignedLong
197
 
{ unsigned int __item;
198
 
  xsd__unsignedInt();
199
 
  virtual ~xsd__unsignedInt();
200
 
  xsd__unsignedInt(unsigned int ui);
201
 
  virtual void print(std::ostream &s) const;
202
 
}; 
203
 
 
204
 
class xsd__unsignedShort: xsd__unsignedInt
205
 
{ unsigned short __item;
206
 
  xsd__unsignedShort();
207
 
  virtual ~xsd__unsignedShort();
208
 
  xsd__unsignedShort(unsigned short uh);
209
 
  virtual void print(std::ostream &s) const;
210
 
}; 
211
 
 
212
 
class xsd__unsignedByte: xsd__unsignedShort
213
 
{ unsigned char __item;
214
 
  xsd__unsignedByte();
215
 
  virtual ~xsd__unsignedByte();
216
 
  xsd__unsignedByte(unsigned char uc);
217
 
  virtual void print(std::ostream &s) const;
218
 
}; 
219
 
 
220
 
class xsd__base64Binary: xsd__anySimpleType
221
 
{ unsigned char *__ptr;
222
 
  int __size;
223
 
  xsd__base64Binary();
224
 
  virtual ~xsd__base64Binary();
225
 
  xsd__base64Binary(char *s);
226
 
  virtual void print(std::ostream &s) const;
227
 
};
228
 
 
229
 
class xsd__hexBinary: xsd__anySimpleType
230
 
{ unsigned char *__ptr;
231
 
  int __size;
232
 
  xsd__hexBinary();
233
 
  virtual ~xsd__hexBinary();
234
 
  xsd__hexBinary(char *s);
235
 
  virtual void print(std::ostream &s) const;
236
 
};
237
 
 
238
 
class array: xsd__anyType
239
 
{ xsd__anyType **__ptr;
240
 
  int __size;
241
 
  array();
242
 
  virtual ~array();
243
 
  array(int n);
244
 
  virtual xsd__anyType*& operator[](int i);
245
 
  virtual void print(std::ostream &s) const;
246
 
};
247
 
 
248
 
int ns__varStringParamTest(int __size, char **param, int &return_);
249
 
 
250
 
int ns__varPolyParamTest(int __size, xsd__anyType **param, struct ns__varPolyParamTestResponse { int __size; xsd__anyType **param; } &out);