Atlas  0.7.0
Networking protocol for the Worldforge system.
Element.cpp
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 (C) 2001 Stefanus Du Toit, Karsten-O. Laux
4 
5 // $Id$
6 
7 #include <Atlas/Message/Element.h>
8 
9 namespace Atlas { namespace Message {
10 
11 void Element::clear(Type new_type)
12 {
13  switch(t)
14  {
15  case TYPE_NONE:
16  case TYPE_INT:
17  case TYPE_FLOAT:
18  case TYPE_PTR:
19  break;
20  case TYPE_STRING:
21  s->unref();
22  break;
23  case TYPE_MAP:
24  m->unref();
25  break;
26  case TYPE_LIST:
27  l->unref();
28  break;
29  }
30 
31  t = new_type;
32 }
33 
34 Element::Element(const Element& obj) : t(obj.t)
35 {
36  switch(t)
37  {
38  case TYPE_NONE:
39  break;
40  case TYPE_INT:
41  i = obj.i;
42  break;
43  case TYPE_FLOAT:
44  f = obj.f;
45  break;
46  case TYPE_PTR:
47  p = obj.p;
48  break;
49  case TYPE_STRING:
50  s = obj.s;
51  s->ref();
52  break;
53  case TYPE_MAP:
54  m = obj.m;
55  m->ref();
56  break;
57  case TYPE_LIST:
58  l = obj.l;
59  l->ref();
60  break;
61  }
62 
63 }
64 
65 Element::Element(Element&& obj) noexcept : t(obj.t)
66 {
67  //Move data from the incoming object, and set the type of it to none, which
68  //results in the incoming object "forgetting" all about the data.
69  switch(t)
70  {
71  case TYPE_NONE:
72  break;
73  case TYPE_INT:
74  i = obj.i;
75  break;
76  case TYPE_FLOAT:
77  f = obj.f;
78  break;
79  case TYPE_PTR:
80  p = obj.p;
81  break;
82  case TYPE_STRING:
83  s = obj.s;
84  break;
85  case TYPE_MAP:
86  m = obj.m;
87  break;
88  case TYPE_LIST:
89  l = obj.l;
90  break;
91  }
92  obj.t = TYPE_NONE;
93 
94 }
95 
97 {
98  //check for self assignment
99  if(&obj == this)
100  return *this;
101 
102  //first clear
103  clear(obj.t);
104 
105  // then perform actual assignment of members
106  switch(t)
107  {
108  case TYPE_NONE:
109  break;
110  case TYPE_INT:
111  i = obj.i;
112  break;
113  case TYPE_FLOAT:
114  f = obj.f;
115  break;
116  case TYPE_PTR:
117  p = obj.p;
118  break;
119  case TYPE_STRING:
120  s = obj.s;
121  s->ref();
122  break;
123  case TYPE_MAP:
124  m = obj.m;
125  m->ref();
126  break;
127  case TYPE_LIST:
128  l = obj.l;
129  l->ref();
130  break;
131  }
132 
133  return *this;
134 }
135 
137 {
138  //check for self assignment
139  if(&obj == this)
140  return *this;
141 
142  //first clear
143  clear(obj.t);
144 
145  //Move data from the incoming object, and set the type of it to none, which
146  //results in the incoming object "forgetting" all about the data.
147  switch(t)
148  {
149  case TYPE_NONE:
150  break;
151  case TYPE_INT:
152  i = obj.i;
153  break;
154  case TYPE_FLOAT:
155  f = obj.f;
156  break;
157  case TYPE_PTR:
158  p = obj.p;
159  break;
160  case TYPE_STRING:
161  s = obj.s;
162  break;
163  case TYPE_MAP:
164  m = obj.m;
165  break;
166  case TYPE_LIST:
167  l = obj.l;
168  break;
169  }
170  obj.t = TYPE_NONE;
171 
172 
173  return *this;
174 }
175 
176 bool Element::operator==(const Element& o) const
177 {
178  if (t != o.t) { return false; }
179  switch(t) {
180  case TYPE_NONE: return true;
181  case TYPE_INT: return i == o.i;
182  case TYPE_FLOAT: return Equal(f, o.f);
183  case TYPE_PTR: return p == o.p;
184  case TYPE_STRING: return *s == *o.s;
185  case TYPE_MAP: return *m == *o.m;
186  case TYPE_LIST: return *l == *o.l;
187  }
188  return false;
189 }
190 
191 const char * Element::typeName(Type ot)
192 {
193  switch (ot) {
194  case TYPE_NONE: return "none";
195  case TYPE_INT: return "int";
196  case TYPE_FLOAT: return "float";
197  case TYPE_PTR: return "pointer";
198  case TYPE_STRING: return "string";
199  case TYPE_MAP: return "map";
200  case TYPE_LIST: return "list";
201  }
202  return "UNKNOWN";
203 }
204 
205 } } //namespace Atlas::Message
206 
Atlas::Message::Element::operator==
bool operator==(const Element &o) const
Check for equality with another Element.
Definition: Element.cpp:176
Atlas::Message::Element::Element
Element()
Construct an empty object.
Definition: Element.h:58
Atlas::Message::Element
Definition: Element.h:39
Atlas::Message::Element::operator=
Element & operator=(const Element &obj)
overload assignment operator !
Definition: Element.cpp:96
Atlas
Definition: Bridge.h:20