← Back to branch summary

~ubuntu-branches/ubuntu/breezy/atlas-cpp/breezy

« back to all changes in this revision

Viewing changes to Atlas/Message/Element.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Koch
  • Date: 2005-10-02 11:41:44 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051002114144-8qmn4d1cdn9g27ta
Tags: 0.5.98-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
Atlas/Message/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
#include <Atlas/Message/Element.h>
 
6
 
 
7
namespace Atlas { namespace Message {
 
8
 
 
9
void Element::clear(Type new_type)
 
10
{
 
11
  switch(t) 
 
12
     {
 
13
   case TYPE_NONE:
 
14
   case TYPE_INT:
 
15
   case TYPE_FLOAT:
 
16
   case TYPE_PTR:
 
17
     break;
 
18
   case TYPE_STRING:
 
19
     s->unref();
 
20
     break;
 
21
   case TYPE_MAP:
 
22
     m->unref();
 
23
     break;
 
24
   case TYPE_LIST:
 
25
     l->unref();
 
26
     break;
 
27
   }
 
28
  
 
29
  t = new_type;
 
30
}
 
31
 
 
32
Element::Element(const Element& obj) : t(obj.t)
 
33
{
 
34
  switch(t) 
 
35
    {
 
36
      case TYPE_NONE:
 
37
        break;
 
38
      case TYPE_INT:
 
39
        i = obj.i;
 
40
        break;
 
41
      case TYPE_FLOAT:
 
42
        f = obj.f;
 
43
        break;
 
44
      case TYPE_PTR:
 
45
        p = obj.p;
 
46
        break;
 
47
      case TYPE_STRING:
 
48
        s = obj.s;
 
49
        s->ref();
 
50
        break;
 
51
      case TYPE_MAP:
 
52
        m = obj.m;
 
53
        m->ref();
 
54
        break;
 
55
      case TYPE_LIST:
 
56
        l = obj.l;
 
57
        l->ref();
 
58
        break;
 
59
    }
 
60
        
 
61
}
 
62
 
 
63
Element& Element::operator=(const Element& obj) 
 
64
{
 
65
  //check for self assignment
 
66
  if(&obj == this)
 
67
    return *this;
 
68
 
 
69
  //first clear
 
70
  clear(obj.t);
 
71
 
 
72
  // then perform actual assignment of members
 
73
  switch(t) 
 
74
    {
 
75
    case TYPE_NONE:
 
76
      break;
 
77
    case TYPE_INT:
 
78
      i = obj.i;
 
79
      break;
 
80
    case TYPE_FLOAT:
 
81
      f = obj.f;
 
82
      break;
 
83
    case TYPE_PTR:
 
84
      p = obj.p;
 
85
      break;
 
86
    case TYPE_STRING:
 
87
      s = obj.s;
 
88
      s->ref();
 
89
      break;
 
90
    case TYPE_MAP:
 
91
      m = obj.m;
 
92
      m->ref();
 
93
      break;
 
94
    case TYPE_LIST:
 
95
      l = obj.l;
 
96
      l->ref();
 
97
      break;
 
98
    }
 
99
 
 
100
  return *this;
 
101
}
 
102
 
 
103
bool Element::operator==(const Element& o) const
 
104
{
 
105
    if (t != o.t) { return false; }
 
106
    switch(t) {
 
107
        case TYPE_NONE: return true;
 
108
        case TYPE_INT: return i == o.i;
 
109
        case TYPE_FLOAT: return f == o.f;
 
110
        case TYPE_PTR: return p == o.p;
 
111
        case TYPE_STRING: return *s == *o.s;
 
112
        case TYPE_MAP: return *m == *o.m;
 
113
        case TYPE_LIST: return *l == *o.l;
 
114
    }
 
115
    return false;
 
116
}
 
117
 
 
118
const char * Element::typeName(Type ot)
 
119
{
 
120
    switch (ot) {
 
121
        case TYPE_NONE: return "none";
 
122
        case TYPE_INT: return "int";
 
123
        case TYPE_FLOAT: return "float";
 
124
        case TYPE_PTR: return "pointer";
 
125
        case TYPE_STRING: return "string";
 
126
        case TYPE_MAP: return "map";
 
127
        case TYPE_LIST: return "list";
 
128
    }
 
129
    return "UNKNOWN";
 
130
}
 
131
 
 
132
} } //namespace Atlas::Message
 
133