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_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::parser_error error((char*)errorMsg);
  76                 yajl_free_error(hand, errorMsg);
  77                 throw error;
  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         }
 118
 119         static int parsedMapKey(void* ctx, const unsigned char* value,
 120                         unsigned length)
 121         {
 122                 return parsedString(ctx, value, length);
 123         }
 124
 125         static int parsedEndMap(void* ctx)
 126         {
 127                 ((deserializer_impl*)ctx)->parsed.push(0);
 128                 return 1;
 129         }
 130
 131         static int parsedBeginArray(void* ctx)
 132         {
 133                 ((deserializer_impl*)ctx)->parsed.push(new wrapped_array);
 134                 return 1;
 135         }
 136
 137         static int parsedEndArray(void* ctx)
 138         {
 139                 ((deserializer_impl*)ctx)->parsed.push(0);
 140                 return 1;
 141         }
 142
 143
 144         void parse()
 145         {
 146                 unsigned char buffer[4096];
 147
 148                 yajl_status stat;
 149
 150                 while (parsed.empty() && in->good())
 151                 {
 152                         in->read((char*)buffer, sizeof(buffer));
 153                         unsigned readIn = in->gcount();
 154
 155                         if (readIn > 0)
 156                         {
 157                                 stat = yajl_parse(hand, buffer, readIn);
 158                         }
 159                         else
 160                         {
 161                                 stat = yajl_parse_complete(hand);
 162                         }
 163
 164                         if (stat != yajl_status_ok &&
 165                                         stat != yajl_status_insufficient_data)
 166                         {
 167                                 throwError();
 168                         }
 169                 }
 170         }
 171
 172
 173         yajl_handle hand;
 174
 175         std::istream* in;
 176         bool deleteWhenDone;
 177
 178         std::queue<serializable*> parsed;
 179
 180 private:
 181         void init(std::istream& input, bool deleteIn, bool comments, bool check)
 182         {
 183                 const yajl_callbacks callbacks =
 184                 {
 185                         deserializer_impl::parsedNull,
 186                         deserializer_impl::parsedBoolean,
 187                         deserializer_impl::parsedInteger,
 188                         deserializer_impl::parsedFloat,
 189                         0,
 190                         deserializer_impl::parsedString,
 191                         deserializer_impl::parsedBeginMap,
 192                         deserializer_impl::parsedMapKey,
 193                         deserializer_impl::parsedEndMap,
 194                         deserializer_impl::parsedBeginArray,
 195                         deserializer_impl::parsedEndArray
 196                 };
 197
 198                 in = &input;
 199                 deleteWhenDone = deleteIn;
 200
 201                 yajl_parser_config config = {comments, check};
 202                 hand = yajl_alloc(&callbacks, &config, NULL, this);
 203         }
 204 };
 205
 206
 207 deserializer::deserializer(const std::string& filePath, bool comments,
 208                 bool check) : impl(new deserializer_impl(filePath, comments, check)) {}
 209
 210 deserializer::deserializer(std::istream& input, bool comments, bool check) :
 211                 impl(new deserializer_impl(input, comments, check)) {}
 212
 213
 214 serializable_ptr deserializer::deserialize()
 215 {
 216         serializable* ptr = pullNext();
 217         if (ptr)
 218         {
 219                 ptr->deserialize(*this);
 220         }
 221         return serializable_ptr(ptr);
 222 }
 223
 224
 225 serializable* deserializer::pullNext()
 226 {
 227         impl->parse();
 228         if (!impl->parsed.empty())
 229         {
 230                 serializable* ptr = impl->parsed.front();
 231                 return ptr;
 232         }
 233         return 0;
 234 }
 235
 236 void deserializer::pop()
 237 {
 238         impl->parsed.pop();
 239 }
 240
 241
 242 } // namespace dc
 243