git.maemo.org Git - xmlrpc-c/blob - src/cpp/param_list.cpp

   1 #include <climits>
   2 #include <cfloat>
   3 #include <ctime>
   4 #include <string>
   5
   6 #include "xmlrpc-c/girerr.hpp"
   7 using girerr::error;
   8 #include "xmlrpc-c/base.h"
   9 #include "xmlrpc-c/base.hpp"
  10
  11 using namespace std;
  12 using namespace xmlrpc_c;
  13
  14 namespace xmlrpc_c {
  15
  16
  17 paramList::paramList(unsigned int const paramCount) {
  18
  19     this->paramVector.reserve(paramCount);
  20 }
  21
  22
  23
  24 void
  25 paramList::add(xmlrpc_c::value const param) {
  26
  27     this->paramVector.push_back(param);
  28 }
  29
  30
  31
  32 unsigned int
  33 paramList::size() const {
  34     return this->paramVector.size();
  35 }
  36
  37
  38
  39 xmlrpc_c::value
  40 paramList::operator[](unsigned int const subscript) const {
  41
  42     if (subscript >= this->paramVector.size())
  43         throw(girerr::error(
  44             "Subscript of xmlrpc_c::paramList out of bounds"));
  45
  46     return this->paramVector[subscript];
  47 }
  48
  49
  50
  51 int
  52 paramList::getInt(unsigned int const paramNumber,
  53                   int          const minimum,
  54                   int          const maximum) const {
  55
  56     if (paramNumber >= this->paramVector.size())
  57         throw(fault("Not enough parameters", fault::CODE_TYPE));
  58
  59     if (this->paramVector[paramNumber].type() != value::TYPE_INT)
  60         throw(fault("Parameter that is supposed to be integer is not",
  61                     fault::CODE_TYPE));
  62
  63     int const intvalue(static_cast<int>(
  64         value_int(this->paramVector[paramNumber])));
  65
  66     if (intvalue < minimum)
  67         throw(fault("Integer parameter too low", fault::CODE_TYPE));
  68
  69     if (intvalue > maximum)
  70         throw(fault("Integer parameter too high", fault::CODE_TYPE));
  71
  72     return intvalue;
  73 }
  74
  75
  76
  77 bool
  78 paramList::getBoolean(unsigned int const paramNumber) const {
  79
  80     if (paramNumber >= this->paramVector.size())
  81         throw(fault("Not enough parameters", fault::CODE_TYPE));
  82
  83     if (this->paramVector[paramNumber].type() != value::TYPE_BOOLEAN)
  84         throw(fault("Parameter that is supposed to be boolean is not",
  85                     fault::CODE_TYPE));
  86
  87     return static_cast<bool>(value_boolean(this->paramVector[paramNumber]));
  88 }
  89
  90
  91
  92 double
  93 paramList::getDouble(unsigned int const paramNumber,
  94                      double       const minimum,
  95                      double       const maximum) const {
  96
  97     if (paramNumber >= this->paramVector.size())
  98         throw(fault("Not enough parameters", fault::CODE_TYPE));
  99
 100     if (this->paramVector[paramNumber].type() != value::TYPE_DOUBLE)
 101         throw(fault("Parameter that is supposed to be floating point number "
 102                     "is not",
 103                     fault::CODE_TYPE));
 104
 105     double const doublevalue(static_cast<double>(
 106         value_double(this->paramVector[paramNumber])));
 107
 108     if (doublevalue < minimum)
 109         throw(fault("Floating point number parameter too low",
 110                     fault::CODE_TYPE));
 111
 112     if (doublevalue > maximum)
 113         throw(fault("Floating point number parameter too high",
 114                     fault::CODE_TYPE));
 115
 116     return doublevalue;
 117 }
 118
 119
 120
 121 time_t
 122 paramList::getDatetime_sec(
 123     unsigned int              const paramNumber,
 124     paramList::timeConstraint const constraint) const {
 125
 126     if (paramNumber >= this->paramVector.size())
 127         throw(fault("Not enough parameters", fault::CODE_TYPE));
 128
 129     const xmlrpc_c::value * const paramP(&this->paramVector[paramNumber]);
 130
 131     if (paramP->type() != value::TYPE_DATETIME)
 132         throw(fault("Parameter that is supposed to be a datetime is not",
 133                     fault::CODE_TYPE));
 134
 135     time_t const timeValue(static_cast<time_t>(value_datetime(*paramP)));
 136     time_t const now(time(NULL));
 137
 138     switch (constraint) {
 139     case TC_ANY:
 140         /* He'll take anything; no problem */
 141         break;
 142     case TC_NO_FUTURE:
 143         if (timeValue > now)
 144             throw(fault("Datetime parameter that is not supposed to be in "
 145                         "the future is.", fault::CODE_TYPE));
 146         break;
 147     case TC_NO_PAST:
 148         if (timeValue < now)
 149             throw(fault("Datetime parameter that is not supposed to be in "
 150                         "the past is.", fault::CODE_TYPE));
 151         break;
 152     }
 153
 154     return timeValue;
 155 }
 156
 157
 158
 159 string
 160 paramList::getString(unsigned int const paramNumber) const {
 161
 162     if (paramNumber >= this->paramVector.size())
 163         throw(fault("Not enough parameters", fault::CODE_TYPE));
 164
 165     if (this->paramVector[paramNumber].type() != value::TYPE_STRING)
 166         throw(fault("Parameter that is supposed to be a string is not",
 167                     fault::CODE_TYPE));
 168
 169     return static_cast<string>(value_string(this->paramVector[paramNumber]));
 170 }
 171
 172
 173
 174 std::vector<unsigned char>
 175 paramList::getBytestring(unsigned int const paramNumber) const {
 176
 177     if (paramNumber >= this->paramVector.size())
 178         throw(fault("Not enough parameters", fault::CODE_TYPE));
 179
 180     const xmlrpc_c::value * const paramP(&this->paramVector[paramNumber]);
 181
 182     if (paramP->type() != value::TYPE_BYTESTRING)
 183         throw(fault("Parameter that is supposed to be a byte string is not",
 184                     fault::CODE_TYPE));
 185
 186     return value_bytestring(*paramP).vectorUcharValue();
 187 }
 188
 189
 190 std::vector<xmlrpc_c::value>
 191 paramList::getArray(unsigned int const paramNumber,
 192                      unsigned int const minSize,
 193                      unsigned int const maxSize) const {
 194
 195     if (paramNumber >= this->paramVector.size())
 196         throw(fault("Not enough parameters", fault::CODE_TYPE));
 197
 198     const xmlrpc_c::value * const paramP(&this->paramVector[paramNumber]);
 199
 200     if (paramP->type() != value::TYPE_ARRAY)
 201         throw(fault("Parameter that is supposed to be an array is not",
 202                     fault::CODE_TYPE));
 203
 204     xmlrpc_c::value_array const arrayValue(*paramP);
 205
 206     if (arrayValue.size() < minSize)
 207         throw(fault("Array parameter has too few elements",
 208                     fault::CODE_TYPE));
 209
 210     if (arrayValue.size() > maxSize)
 211         throw(fault("Array parameter has too many elements",
 212                     fault::CODE_TYPE));
 213
 214     return value_array(*paramP).vectorValueValue();
 215 }
 216
 217
 218
 219 std::map<string, xmlrpc_c::value>
 220 paramList::getStruct(unsigned int const paramNumber) const {
 221
 222     if (paramNumber >= this->paramVector.size())
 223         throw(fault("Not enough parameters", fault::CODE_TYPE));
 224
 225     const xmlrpc_c::value * const paramP(&this->paramVector[paramNumber]);
 226
 227     if (paramP->type() != value::TYPE_STRUCT)
 228         throw(fault("Parameter that is supposed to be a structure is not",
 229                     fault::CODE_TYPE));
 230
 231     return static_cast<std::map<string, xmlrpc_c::value> >(
 232         value_struct(*paramP));
 233 }
 234
 235
 236
 237 void
 238 paramList::getNil(unsigned int const paramNumber) const {
 239
 240     if (paramNumber >= this->paramVector.size())
 241         throw(fault("Not enough parameters", fault::CODE_TYPE));
 242
 243     if (this->paramVector[paramNumber].type() != value::TYPE_NIL)
 244         throw(fault("Parameter that is supposed to be nil is not",
 245                     fault::CODE_TYPE));
 246 }
 247
 248
 249
 250 void
 251 paramList::verifyEnd(unsigned int const paramNumber) const {
 252
 253     if (paramNumber < this->paramVector.size())
 254         throw(fault("Too many parameters", fault::CODE_TYPE));
 255     if (paramNumber > this->paramVector.size())
 256         throw(fault("Not enough parameters", fault::CODE_TYPE));
 257 }
 258
 259 }  // namespace