Dogcows Code - chaz/yoink/blob - src/serializer.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
  31 #include <yajl/yajl_gen.h>
  32
  33 #include "stringtools.hh"
  34 #include "serializer.hh"
  35
  36
  37 namespace dc {
  38
  39
  40 class serializer_impl
  41 {
  42 public:
  43         serializer_impl(const std::string& filePath, const std::string& indent = "")
  44         {
  45                 std::ofstream* output = new std::ofstream(filePath.c_str());
  46                 init(*output, true, indent);
  47         }
  48
  49         serializer_impl(std::ostream& output, const std::string& indent = "")
  50         {
  51                 init(output, false, indent);
  52         }
  53
  54         ~serializer_impl()
  55         {
  56                 if (deleteWhenDone)
  57                 {
  58                         delete out;
  59                 }
  60                 yajl_gen_free(gen);
  61         }
  62
  63         static void throwError(yajl_gen_status err)
  64         {
  65                 switch (err)
  66                 {
  67                         case yajl_gen_generation_complete:
  68                                 throw serializer::exception("the archive has already terminated");
  69                         case yajl_gen_keys_must_be_strings:
  70                                 throw serializer::exception("map keys must be strings");
  71                         case yajl_max_depth_exceeded:
  72                                 throw serializer::exception("maximum archive depth exceeded");
  73                         case yajl_gen_in_error_state:
  74                                 throw serializer::exception("serializer already in error state");
  75                 }
  76         }
  77
  78         yajl_gen gen;
  79
  80         std::ostream* out;
  81         bool deleteWhenDone;
  82
  83 private:
  84         void init(std::ostream& output, bool deleteOut, const std::string& indent)
  85         {
  86                 yajl_gen_config config;
  87
  88                 out = &output;
  89                 deleteWhenDone = deleteOut;
  90
  91                 if (indent != "")
  92                 {
  93                         config.beautify = true;
  94                         config.indentString = 0;
  95                         // FIXME: a yajl bug prevents using heap-allocated strings
  96                         //config.indentString = indent.c_str();
  97                 }
  98                 else
  99                 {
 100                         config.beautify = false;
 101                 }
 102                 gen = yajl_gen_alloc(&config, 0);
 103         }
 104 };
 105
 106
 107 serializer::serializer(const std::string& filePath, const std::string& indent) :
 108                 impl(new serializer_impl(filePath, indent)) {}
 109
 110 serializer::serializer(std::ostream& output, const std::string& indent) :
 111                 impl(new serializer_impl(output, indent)) {}
 112
 113 serializer::~serializer()
 114 {
 115         flush();
 116 }
 117
 118
 119 void serializer::push(long value)
 120 {
 121         yajl_gen_status stat = yajl_gen_integer(impl->gen, value);
 122         if (stat != yajl_gen_status_ok) serializer_impl::throwError(stat);
 123 }
 124
 125 void serializer::push(double value)
 126 {
 127         yajl_gen_status stat = yajl_gen_double(impl->gen, value);
 128         if (stat != yajl_gen_status_ok) serializer_impl::throwError(stat);
 129 }
 130
 131 void serializer::push(bool value)
 132 {
 133         yajl_gen_status stat = yajl_gen_bool(impl->gen, value);
 134         if (stat != yajl_gen_status_ok) serializer_impl::throwError(stat);
 135 }
 136
 137 void serializer::push(const std::string& value)
 138 {
 139         yajl_gen_status stat = yajl_gen_string(impl->gen,
 140                         (const unsigned char*)value.c_str(), value.length());
 141         if (stat != yajl_gen_status_ok) serializer_impl::throwError(stat);
 142 }
 143
 144 void serializer::push(const std::wstring& value)
 145 {
 146         push(wideToMulti(value));
 147 }
 148
 149 void serializer::pushNull()
 150 {
 151         yajl_gen_status stat = yajl_gen_null(impl->gen);
 152         if (stat != yajl_gen_status_ok) serializer_impl::throwError(stat);
 153 }
 154
 155
 156 void serializer::pushMapHead()
 157 {
 158         yajl_gen_status stat = yajl_gen_map_open(impl->gen);
 159         if (stat != yajl_gen_status_ok) serializer_impl::throwError(stat);
 160 }
 161
 162 void serializer::pushMapTail()
 163 {
 164         yajl_gen_status stat = yajl_gen_map_close(impl->gen);
 165         if (stat != yajl_gen_status_ok) serializer_impl::throwError(stat);
 166 }
 167
 168 void serializer::pushArrayHead()
 169 {
 170         yajl_gen_status stat = yajl_gen_array_open(impl->gen);
 171         if (stat != yajl_gen_status_ok) serializer_impl::throwError(stat);
 172 }
 173
 174 void serializer::pushArrayTail()
 175 {
 176         yajl_gen_status stat = yajl_gen_array_close(impl->gen);
 177         if (stat != yajl_gen_status_ok) serializer_impl::throwError(stat);
 178 }
 179
 180
 181 void serializer::flush()
 182 {
 183         const unsigned char* buffer;
 184         unsigned length;
 185
 186         yajl_gen_get_buf(impl->gen, &buffer, &length);
 187         impl->out->write((const char*)buffer, length);
 188         yajl_gen_clear(impl->gen);
 189 }
 190
 191
 192 } // namespace dc
 193