xbmc/utils/Variant.cpp

   1 /*
   2  *      Copyright (C) 2005-2010 Team XBMC
   3  *      http://www.xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *  http://www.gnu.org/copyleft/gpl.html
  19  *
  20  */
  21 #include "Variant.h"
  22 #include "PlatformDefs.h"
  23 #include <string.h>
  24
  25 using namespace std;
  26
  27 CVariant CVariant::ConstNullVariant = CVariant::VariantTypeConstNull;
  28
  29 CVariant::CVariant(VariantType type)
  30 {
  31   m_type = type;
  32
  33   if (isString())
  34     m_data.string = NULL;
  35   else if (isArray())
  36     m_data.array = new VariantArray();
  37   else if (isObject())
  38     m_data.map = new VariantMap();
  39   else
  40     memset(&m_data, 0, sizeof(m_data));
  41 }
  42
  43 CVariant::CVariant(int integer)
  44 {
  45   m_type = VariantTypeInteger;
  46   m_data.integer = integer;
  47 }
  48
  49 CVariant::CVariant(int64_t integer)
  50 {
  51   m_type = VariantTypeInteger;
  52   m_data.integer = integer;
  53 }
  54
  55 CVariant::CVariant(unsigned int unsignedinteger)
  56 {
  57   m_type = VariantTypeUnsignedInteger;
  58   m_data.unsignedinteger = unsignedinteger;
  59 }
  60
  61 CVariant::CVariant(uint64_t unsignedinteger)
  62 {
  63   m_type = VariantTypeUnsignedInteger;
  64   m_data.unsignedinteger = unsignedinteger;
  65 }
  66
  67 CVariant::CVariant(bool boolean)
  68 {
  69   m_type = VariantTypeBoolean;
  70   m_data.boolean = boolean;
  71 }
  72
  73 CVariant::CVariant(const char *str)
  74 {
  75   m_type = VariantTypeString;
  76   m_data.string = new string(str);
  77 }
  78
  79 CVariant::CVariant(const CVariant &variant)
  80 {
  81   m_type = variant.m_type;
  82   *this = variant;
  83 }
  84
  85 CVariant::~CVariant()
  86 {
  87   if (isString() && m_data.string)
  88   {
  89     delete m_data.string;
  90     m_data.string = NULL;
  91   }
  92   else if (isArray() && m_data.array)
  93   {
  94     delete m_data.array;
  95     m_data.array = NULL;
  96   }
  97   else if (isObject() && m_data.map)
  98   {
  99     delete m_data.map;
 100     m_data.map = NULL;
 101   }
 102 }
 103
 104 bool CVariant::isInteger() const
 105 {
 106   return m_type == VariantTypeInteger;
 107 }
 108
 109 bool CVariant::isUnsignedInteger() const
 110 {
 111   return m_type == VariantTypeUnsignedInteger;
 112 }
 113
 114 bool CVariant::isBoolean() const
 115 {
 116   return m_type == VariantTypeBoolean;
 117 }
 118
 119 bool CVariant::isString() const
 120 {
 121   return m_type == VariantTypeString;
 122 }
 123
 124 bool CVariant::isArray() const
 125 {
 126   return m_type == VariantTypeArray;
 127 }
 128
 129 bool CVariant::isObject() const
 130 {
 131   return m_type == VariantTypeObject;
 132 }
 133
 134 bool CVariant::isNull() const
 135 {
 136   return m_type == VariantTypeNull || m_type == VariantTypeConstNull;
 137 }
 138
 139 int64_t CVariant::asInteger(int64_t fallback) const
 140 {
 141   if (isInteger())
 142     return m_data.integer;
 143   else
 144     return fallback;
 145 }
 146
 147 uint64_t CVariant::asUnsignedInteger(uint64_t fallback) const
 148 {
 149   if (isUnsignedInteger())
 150     return m_data.unsignedinteger;
 151   else
 152     return fallback;
 153 }
 154
 155 bool CVariant::asBoolean(bool fallback) const
 156 {
 157   if (isBoolean())
 158     return m_data.boolean;
 159   else
 160     return fallback;
 161 }
 162
 163 const char *CVariant::asString(const char *fallback) const
 164 {
 165   if (isString())
 166     return m_data.string->c_str();
 167   else
 168     return fallback;
 169 }
 170
 171 CVariant &CVariant::operator[](string key)
 172 {
 173   if (m_type == VariantTypeNull)
 174   {
 175     m_type = VariantTypeObject;
 176     m_data.map = new VariantMap();
 177   }
 178
 179   if (isObject())
 180     return (*m_data.map)[key];
 181   else
 182     return ConstNullVariant;
 183 }
 184
 185 CVariant &CVariant::operator[](unsigned int position)
 186 {
 187   if (isArray() && size() > position)
 188     return (*m_data.array)[position];
 189   else
 190     return ConstNullVariant;
 191 }
 192
 193 CVariant &CVariant::operator=(const CVariant &rhs)
 194 {
 195   if (m_type == VariantTypeConstNull)
 196     return *this;
 197
 198   m_type = rhs.m_type;
 199
 200   switch (m_type)
 201   {
 202   case VariantTypeInteger:
 203     m_data.integer = rhs.m_data.integer;
 204     break;
 205   case VariantTypeUnsignedInteger:
 206     m_data.integer = rhs.m_data.unsignedinteger;
 207     break;
 208   case VariantTypeBoolean:
 209     m_data.boolean = rhs.m_data.boolean;
 210     break;
 211   case VariantTypeString:
 212     m_data.string = new string(rhs.m_data.string->c_str());
 213     break;
 214   case VariantTypeArray:
 215     m_data.array = new VariantArray(rhs.m_data.array->begin(), rhs.m_data.array->end());
 216     break;
 217   case VariantTypeObject:
 218     m_data.map = new VariantMap(rhs.m_data.map->begin(), rhs.m_data.map->end());
 219     break;
 220   default:
 221     break;
 222   }
 223
 224   return *this;
 225 }
 226
 227 void CVariant::push_back(CVariant variant)
 228 {
 229   if (m_type == VariantTypeNull)
 230   {
 231     m_type = VariantTypeArray;
 232     m_data.array = new VariantArray();
 233   }
 234
 235   if (isArray())
 236     m_data.array->push_back(variant);
 237 }
 238
 239 unsigned int CVariant::size() const
 240 {
 241   if (isObject())
 242     return m_data.map->size();
 243   else if (isArray())
 244     return m_data.array->size();
 245   else
 246     return 0;
 247 }
 248
 249 bool CVariant::empty() const
 250 {
 251   if (isObject())
 252     return m_data.map->empty();
 253   else if (isArray())
 254     return m_data.array->empty();
 255   else
 256     return true;
 257 }
 258
 259 void CVariant::clear()
 260 {
 261   if (isObject())
 262     m_data.map->clear();
 263   else if (isArray())
 264     m_data.array->clear();
 265 }
 266
 267 void CVariant::erase(std::string key)
 268 {
 269   if (m_type == VariantTypeNull)
 270   {
 271     m_type = VariantTypeObject;
 272     m_data.map = new VariantMap();
 273   }
 274   else if (isObject())
 275     m_data.map->erase(key);
 276 }
 277
 278 void CVariant::erase(unsigned int position)
 279 {
 280   if (m_type == VariantTypeNull)
 281   {
 282     m_type = VariantTypeArray;
 283     m_data.array = new VariantArray();
 284   }
 285
 286   if (isArray() && position < size())
 287     m_data.array->erase(m_data.array->begin() + position);
 288 }
 289
 290 #include <stdio.h>
 291
 292 void CVariant::debug()
 293 {
 294   internaldebug();
 295   printf("\n");
 296 }
 297
 298 void CVariant::internaldebug()
 299 {
 300   switch (m_type)
 301   {
 302   case VariantTypeInteger:
 303     printf("int: %"PRIu64"", m_data.integer);
 304     break;
 305   case VariantTypeUnsignedInteger:
 306     printf("uint: %"PRIu64"", m_data.unsignedinteger);
 307     break;
 308   case VariantTypeBoolean:
 309     printf("bool: %s", m_data.boolean ? "true" : "false");
 310     break;
 311   case VariantTypeString:
 312     printf("string: \"%s\"", m_data.string->c_str());
 313     break;
 314   case VariantTypeArray:
 315     printf("array: [");
 316     for (unsigned int i = 0; i < size(); i++)
 317     {
 318       (*m_data.array)[i].internaldebug();
 319       if (i < size() - 1)
 320         printf(", ");
 321     }
 322     printf("]");
 323     break;
 324   case VariantTypeObject:
 325     printf("map: [");
 326     for (VariantMap::iterator itr = m_data.map->begin(); itr != m_data.map->end(); itr++)
 327     {
 328       printf("key='%s' value='", itr->first.c_str());
 329       itr->second.internaldebug();
 330       printf("' ");
 331     }
 332     printf("]");
 333     break;
 334   default:
 335     break;
 336   }
 337 }