Dogcows Code - chaz/yoink/blob - src/deserializer.cc

   1
   2 /*******************************************************************************
   3
   4  Copyright (c) 2009, Charles McGarvey
   5  All rights reserved.
   6
   7  Redistribution   and   use  in  source  and  binary  forms,  with  or  without
   8  modification, are permitted provided that the following conditions are met:
   9
  10    * Redistributions  of  source  code  must retain the above copyright notice,
  11      this list of conditions and the following disclaimer.
  12    * Redistributions  in binary form must reproduce the above copyright notice,
  13      this  list of conditions and the following disclaimer in the documentation
  14      and/or other materials provided with the distribution.
  15
  16  THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19  DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  20  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22  SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23  CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26
  27 *******************************************************************************/
  28
  29 #include <fstream>
  30 #include <queue>
  31
  32 #include <yajl/yajl_parse.h>
  33
  34 #include "serializable.hh"
  35 #include "deserializer.hh"
  36
  37
  38 namespace dc {
  39
  40
  41 class deserializer::deserializer_impl
  42 {
  43 public:
  44         deserializer_impl(const std::string& filePath, bool comments = false,
  45                         bool check = false)
  46         {
  47                 std::ifstream* input = new std::ifstream(filePath.c_str());
  48                 init(*input, true, comments, check);
  49         }
  50
  51         deserializer_impl(std::istream& input, bool comments = false,
  52                         bool check = false)
  53         {
  54                 init(input, false, comments, check);
  55         }
  56
  57         ~deserializer_impl()
  58         {
  59                 while (!parsed.empty())
  60                 {
  61                         delete parsed.front();
  62                         parsed.pop();
  63                 }
  64
  65                 if (deleteWhenDone)
  66                 {
  67                         delete in;
  68                 }
  69                 yajl_free(hand);
  70         }
  71
  72         void throwError()
  73         {
  74                 unsigned char* errorMsg = yajl_get_error(hand, 0, 0, 0);
  75                 deserializer::exception problem((char*)errorMsg);
  76                 yajl_free_error(hand, errorMsg);
  77                 throw problem;
  78         }
  79
  80
  81         static int parsedNull(void* ctx)
  82         {
  83                 ((deserializer_impl*)ctx)->parsed.push(new null);
  84                 return 1;
  85         }
  86
  87         static int parsedBoolean(void* ctx, int value)
  88         {
  89                 ((deserializer_impl*)ctx)->parsed.push(new wrapped_boolean(value));
  90                 return 1;
  91         }
  92
  93         static int parsedInteger(void* ctx, long value)
  94         {
  95                 ((deserializer_impl*)ctx)->parsed.push(new wrapped_integer(value));
  96                 return 1;
  97         }
  98
  99         static int parsedFloat(void* ctx, double value)
 100         {
 101                 ((deserializer_impl*)ctx)->parsed.push(new wrapped_real(value));
 102                 return 1;
 103         }
 104
 105         static int parsedString(void* ctx, const unsigned char* value,
 106                         unsigned length)
 107         {
 108                 wrapped_string* parsed = new wrapped_string(std::string((char*)value,
 109                                         length));
 110                 ((deserializer_impl*)ctx)->parsed.push(parsed);
 111                 return 1;
 112         }
 113
 114         static int parsedBeginMap(void* ctx)
 115         {
 116                 ((deserializer_impl*)ctx)->parsed.push(new wrapped_dictionary);
 117                 return 1;
 118         }
 119
 120         static int parsedMapKey(void* ctx, const unsigned char* value,
 121                         unsigned length)
 122         {
 123                 // same thing as a string
 124                 return parsedString(ctx, value, length);
 125         }
 126
 127         static int parsedEndMap(void* ctx)
 128         {
 129                 ((deserializer_impl*)ctx)->parsed.push(0);
 130                 return 1;
 131         }
 132
 133         static int parsedBeginArray(void* ctx)
 134         {
 135                 ((deserializer_impl*)ctx)->parsed.push(new wrapped_array);
 136                 return 1;
 137         }
 138
 139         static int parsedEndArray(void* ctx)
 140         {
 141                 ((deserializer_impl*)ctx)->parsed.push(0);
 142                 return 1;
 143         }
 144
 145
 146         void parse()
 147         {
 148                 unsigned char buffer[4096];
 149
 150                 yajl_status stat;
 151
 152                 while (parsed.empty() && in->good())
 153                 {
 154                         in->read((char*)buffer, sizeof(buffer));
 155                         unsigned readIn = in->gcount();
 156
 157                         if (readIn > 0)
 158                         {
 159                                 stat = yajl_parse(hand, buffer, readIn);
 160                         }
 161                         else
 162                         {
 163                                 stat = yajl_parse_complete(hand);
 164                         }
 165
 166                         if (stat != yajl_status_ok &&
 167                                         stat != yajl_status_insufficient_data)
 168                         {
 169                                 throwError();
 170                         }
 171                 }
 172         }
 173
 174
 175         yajl_handle hand;
 176
 177         std::istream* in;
 178         bool deleteWhenDone;
 179
 180         std::queue<serializable*> parsed;
 181
 182 private:
 183         void init(std::istream& input, bool deleteIn, bool comments, bool check)
 184         {
 185                 // this has to be static because yajl actually does not copy it into its
 186                 // internal data structures but rather keeps a pointer to this
 187                 static const yajl_callbacks callbacks =
 188                 {
 189                         deserializer_impl::parsedNull,
 190                         deserializer_impl::parsedBoolean,
 191                         deserializer_impl::parsedInteger,
 192                         deserializer_impl::parsedFloat,
 193                         0,
 194                         deserializer_impl::parsedString,
 195                         deserializer_impl::parsedBeginMap,
 196                         deserializer_impl::parsedMapKey,
 197                         deserializer_impl::parsedEndMap,
 198                         deserializer_impl::parsedBeginArray,
 199                         deserializer_impl::parsedEndArray
 200                 };
 201
 202                 in = &input;
 203                 deleteWhenDone = deleteIn;
 204
 205                 yajl_parser_config config = {comments, check};
 206                 hand = yajl_alloc(&callbacks, &config, NULL, this);
 207         }
 208 };
 209
 210
 211 deserializer::deserializer(const std::string& filePath, bool comments,
 212                 bool check) :
 213         // pass through
 214         impl(new deserializer::deserializer_impl(filePath, comments, check)) {}
 215
 216 deserializer::deserializer(std::istream& input, bool comments, bool check) :
 217         // pass through
 218         impl(new deserializer::deserializer_impl(input, comments, check)) {}
 219
 220
 221 serializable_ptr deserializer::deserialize()
 222 {
 223         serializable* ptr = pullNext();
 224         if (ptr)
 225         {
 226                 ptr->deserialize(*this);
 227         }
 228         return serializable_ptr(ptr);
 229 }
 230
 231
 232 serializable* deserializer::pullNext()
 233 {
 234         impl->parse();
 235         if (!impl->parsed.empty())
 236         {
 237                 serializable* ptr = impl->parsed.front();
 238                 return ptr;
 239         }
 240         return 0;
 241 }
 242
 243 void deserializer::pop()
 244 {
 245         // pass through
 246         impl->parsed.pop();
 247 }
 248
 249
 250 } // namespace dc
 251
 252 /** vim: set ts=4 sw=4 tw=80: *************************************************/
 253