1 // This file may be redistributed and modified only under the terms of
2 // the GNU Lesser General Public License (See COPYING for details).
3 // Copyright 2000-2001 Stefanus Du Toit and Aloril.
4 // Copyright 2001-2005 Alistair Riddoch.
5 // Automatically generated using gen_cpp.py.
6
7 #include <Atlas/Objects/RootOperation.h>
8
9 using Atlas::Message::Element;
10 using Atlas::Message::MapType;
11
12 namespace Atlas { namespace Objects { namespace Operation {
13
14 const std::string SERIALNO_ATTR = "serialno";
15 const std::string REFNO_ATTR = "refno";
16 const std::string FROM_ATTR = "from";
17 const std::string TO_ATTR = "to";
18 const std::string SECONDS_ATTR = "seconds";
19 const std::string FUTURE_SECONDS_ATTR = "future_seconds";
20 const std::string ARGS_ATTR = "args";
21
getAttrClass(const std::string & name) const22 int RootOperationData::getAttrClass(const std::string& name) const
23 {
24 if (attr_flags_RootOperationData->find(name) != attr_flags_RootOperationData->end()) {
25 return ROOT_OPERATION_NO;
26 }
27 return RootData::getAttrClass(name);
28 }
29
getAttrFlag(const std::string & name) const30 int RootOperationData::getAttrFlag(const std::string& name) const
31 {
32 std::map<std::string, int>::const_iterator I = attr_flags_RootOperationData->find(name);
33 if (I != attr_flags_RootOperationData->end()) {
34 return I->second;
35 }
36 return RootData::getAttrFlag(name);
37 }
38
copyAttr(const std::string & name,Element & attr) const39 int RootOperationData::copyAttr(const std::string& name, Element & attr) const
40 {
41 if (name == SERIALNO_ATTR) { attr = getSerialno(); return 0; }
42 if (name == REFNO_ATTR) { attr = getRefno(); return 0; }
43 if (name == FROM_ATTR) { attr = getFrom(); return 0; }
44 if (name == TO_ATTR) { attr = getTo(); return 0; }
45 if (name == SECONDS_ATTR) { attr = getSeconds(); return 0; }
46 if (name == FUTURE_SECONDS_ATTR) { attr = getFutureSeconds(); return 0; }
47 if (name == ARGS_ATTR) { attr = getArgsAsList(); return 0; }
48 return RootData::copyAttr(name, attr);
49 }
50
setAttr(const std::string & name,const Element & attr)51 void RootOperationData::setAttr(const std::string& name, const Element& attr)
52 {
53 if (name == SERIALNO_ATTR) { setSerialno(attr.asInt()); return; }
54 if (name == REFNO_ATTR) { setRefno(attr.asInt()); return; }
55 if (name == FROM_ATTR) { setFrom(attr.asString()); return; }
56 if (name == TO_ATTR) { setTo(attr.asString()); return; }
57 if (name == SECONDS_ATTR) { setSeconds(attr.asFloat()); return; }
58 if (name == FUTURE_SECONDS_ATTR) { setFutureSeconds(attr.asFloat()); return; }
59 if (name == ARGS_ATTR) { setArgsAsList(attr.asList()); return; }
60 RootData::setAttr(name, attr);
61 }
62
removeAttr(const std::string & name)63 void RootOperationData::removeAttr(const std::string& name)
64 {
65 if (name == SERIALNO_ATTR)
66 { m_attrFlags &= ~SERIALNO_FLAG; return;}
67 if (name == REFNO_ATTR)
68 { m_attrFlags &= ~REFNO_FLAG; return;}
69 if (name == FROM_ATTR)
70 { m_attrFlags &= ~FROM_FLAG; return;}
71 if (name == TO_ATTR)
72 { m_attrFlags &= ~TO_FLAG; return;}
73 if (name == SECONDS_ATTR)
74 { m_attrFlags &= ~SECONDS_FLAG; return;}
75 if (name == FUTURE_SECONDS_ATTR)
76 { m_attrFlags &= ~FUTURE_SECONDS_FLAG; return;}
77 if (name == ARGS_ATTR)
78 { m_attrFlags &= ~ARGS_FLAG; return;}
79 RootData::removeAttr(name);
80 }
81
sendSerialno(Atlas::Bridge & b) const82 inline void RootOperationData::sendSerialno(Atlas::Bridge & b) const
83 {
84 if(m_attrFlags & SERIALNO_FLAG) {
85 b.mapIntItem(SERIALNO_ATTR, attr_serialno);
86 }
87 }
88
sendRefno(Atlas::Bridge & b) const89 inline void RootOperationData::sendRefno(Atlas::Bridge & b) const
90 {
91 if(m_attrFlags & REFNO_FLAG) {
92 b.mapIntItem(REFNO_ATTR, attr_refno);
93 }
94 }
95
sendFrom(Atlas::Bridge & b) const96 inline void RootOperationData::sendFrom(Atlas::Bridge & b) const
97 {
98 if(m_attrFlags & FROM_FLAG) {
99 b.mapStringItem(FROM_ATTR, attr_from);
100 }
101 }
102
sendTo(Atlas::Bridge & b) const103 inline void RootOperationData::sendTo(Atlas::Bridge & b) const
104 {
105 if(m_attrFlags & TO_FLAG) {
106 b.mapStringItem(TO_ATTR, attr_to);
107 }
108 }
109
sendSeconds(Atlas::Bridge & b) const110 inline void RootOperationData::sendSeconds(Atlas::Bridge & b) const
111 {
112 if(m_attrFlags & SECONDS_FLAG) {
113 b.mapFloatItem(SECONDS_ATTR, attr_seconds);
114 }
115 }
116
sendFutureSeconds(Atlas::Bridge & b) const117 inline void RootOperationData::sendFutureSeconds(Atlas::Bridge & b) const
118 {
119 if(m_attrFlags & FUTURE_SECONDS_FLAG) {
120 b.mapFloatItem(FUTURE_SECONDS_ATTR, attr_future_seconds);
121 }
122 }
123
sendArgs(Atlas::Bridge & b) const124 inline void RootOperationData::sendArgs(Atlas::Bridge & b) const
125 {
126 if(m_attrFlags & ARGS_FLAG) {
127 b.mapListItem(ARGS_ATTR);
128 const std::vector<Root> & v = attr_args;
129 std::vector<Root>::const_iterator I = v.begin();
130 for (; I != v.end(); ++I) {
131 b.listMapItem();
132 (*I)->sendContents(b);
133 b.mapEnd();
134 }
135 b.listEnd();
136 }
137 }
138
sendContents(Bridge & b) const139 void RootOperationData::sendContents(Bridge & b) const
140 {
141 sendSerialno(b);
142 sendRefno(b);
143 sendFrom(b);
144 sendTo(b);
145 sendSeconds(b);
146 sendFutureSeconds(b);
147 sendArgs(b);
148 RootData::sendContents(b);
149 }
150
addToMessage(MapType & m) const151 void RootOperationData::addToMessage(MapType & m) const
152 {
153 RootData::addToMessage(m);
154 if(m_attrFlags & SERIALNO_FLAG)
155 m[SERIALNO_ATTR] = attr_serialno;
156 if(m_attrFlags & REFNO_FLAG)
157 m[REFNO_ATTR] = attr_refno;
158 if(m_attrFlags & FROM_FLAG)
159 m[FROM_ATTR] = attr_from;
160 if(m_attrFlags & TO_FLAG)
161 m[TO_ATTR] = attr_to;
162 if(m_attrFlags & SECONDS_FLAG)
163 m[SECONDS_ATTR] = attr_seconds;
164 if(m_attrFlags & FUTURE_SECONDS_FLAG)
165 m[FUTURE_SECONDS_ATTR] = attr_future_seconds;
166 if(m_attrFlags & ARGS_FLAG)
167 m[ARGS_ATTR] = getArgsAsList();
168 return;
169 }
170
iterate(int & current_class,std::string & attr) const171 void RootOperationData::iterate(int& current_class, std::string& attr) const
172 {
173 // If we've already finished this class, chain to the parent
174 if(current_class >= 0 && current_class != ROOT_OPERATION_NO) {
175 RootData::iterate(current_class, attr);
176 return;
177 }
178
179 static const char *attr_list[] = {"serialno","refno","from","to","seconds","future_seconds","args",};
180 static const unsigned n_attr = sizeof(attr_list) / sizeof(const char*);
181
182 unsigned next_attr = n_attr; // so we chain to the parent if we don't find attr
183
184 if(attr.empty()) // just staring on this class
185 next_attr = 0;
186 else {
187 for(unsigned i = 0; i < n_attr; ++i) {
188 if(attr == attr_list[i]) {
189 next_attr = i + 1;
190 break;
191 }
192 }
193 }
194
195 if(next_attr == n_attr) { // last one on the list
196 current_class = -1;
197 attr = "";
198 RootData::iterate(current_class, attr); // chain to parent
199 }
200 else {
201 current_class = ROOT_OPERATION_NO;
202 attr = attr_list[next_attr];
203 }
204 }
205
~RootOperationData()206 RootOperationData::~RootOperationData()
207 {
208 }
209
copy() const210 RootOperationData * RootOperationData::copy() const
211 {
212 RootOperationData * copied = RootOperationData::alloc();
213 *copied = *this;
214 copied->m_refCount = 0;
215 return copied;
216 }
217
instanceOf(int classNo) const218 bool RootOperationData::instanceOf(int classNo) const
219 {
220 if(ROOT_OPERATION_NO == classNo) return true;
221 return RootData::instanceOf(classNo);
222 }
223
224 //freelist related methods specific to this class
225 RootOperationData *RootOperationData::defaults_RootOperationData = 0;
226 RootOperationData *RootOperationData::begin_RootOperationData = 0;
227
alloc()228 RootOperationData *RootOperationData::alloc()
229 {
230 if(begin_RootOperationData) {
231 RootOperationData *res = begin_RootOperationData;
232 assert( res->m_refCount == 0 );
233 res->m_attrFlags = 0;
234 res->m_attributes.clear();
235 begin_RootOperationData = (RootOperationData *)begin_RootOperationData->m_next;
236 return res;
237 }
238 return new RootOperationData(RootOperationData::getDefaultObjectInstance());
239 }
240
free()241 void RootOperationData::free()
242 {
243 m_next = begin_RootOperationData;
244 begin_RootOperationData = this;
245 }
246
247 std::map<std::string, int> * RootOperationData::attr_flags_RootOperationData = 0;
248
getDefaultObjectInstance()249 RootOperationData *RootOperationData::getDefaultObjectInstance()
250 {
251 if (defaults_RootOperationData == 0) {
252 defaults_RootOperationData = new RootOperationData;
253 defaults_RootOperationData->attr_objtype = "op";
254 defaults_RootOperationData->attr_serialno = 0;
255 defaults_RootOperationData->attr_refno = 0;
256 defaults_RootOperationData->attr_seconds = 0.0;
257 defaults_RootOperationData->attr_future_seconds = 0.0;
258 defaults_RootOperationData->attr_stamp = 0.0;
259 defaults_RootOperationData->attr_parents = std::list<std::string>(1, "root_operation");
260 attr_flags_RootOperationData = new std::map<std::string, int>;
261 (*attr_flags_RootOperationData)[SERIALNO_ATTR] = SERIALNO_FLAG;
262 (*attr_flags_RootOperationData)[REFNO_ATTR] = REFNO_FLAG;
263 (*attr_flags_RootOperationData)[FROM_ATTR] = FROM_FLAG;
264 (*attr_flags_RootOperationData)[TO_ATTR] = TO_FLAG;
265 (*attr_flags_RootOperationData)[SECONDS_ATTR] = SECONDS_FLAG;
266 (*attr_flags_RootOperationData)[FUTURE_SECONDS_ATTR] = FUTURE_SECONDS_FLAG;
267 (*attr_flags_RootOperationData)[ARGS_ATTR] = ARGS_FLAG;
268 RootData::getDefaultObjectInstance();
269 }
270 return defaults_RootOperationData;
271 }
272
getDefaultObject()273 RootOperationData *RootOperationData::getDefaultObject()
274 {
275 return RootOperationData::getDefaultObjectInstance();
276 }
277
278 } } } // namespace Atlas::Objects::Operation
279