lib/mappropertytype.hpp

   1 #ifndef _MAPPROPERTYTYPE_H_
   2 #define _MAPPROPERTYTYPE_H_
   3
   4
   5 #include "abstractpropertytype.h"
   6 #include <map>
   7 #include <debugout.h>
   8 //#include <json-glib/json-glib.h>
   9 #include <json/json.h>
  10 template <class T, class N>
  11 class MapPropertyType: public AbstractPropertyType
  12 {
  13 public:
  14         MapPropertyType(){}
  15
  16         void append(T  key, N  value)
  17         {
  18                 appendPriv(key,value);
  19         }
  20
  21         AbstractPropertyType* copy()
  22         {
  23                 MapPropertyType<T,N> *t = new MapPropertyType<T,N>();
  24
  25                 t->setMap(mMap);
  26
  27                 return t;
  28         }
  29
  30         std::string toString() const
  31         {
  32                 std::stringstream str;
  33
  34                 str<<"{";
  35
  36                 for(auto itr = mMap.begin(); itr != mMap.end(); itr++)
  37                 {
  38                         if(str.str() != "{")
  39                                 str << ", ";
  40
  41                          auto t = *itr;
  42
  43                          str <<"'"<< t.first.toString() <<"':'"<<t.second.toString()<<"'";
  44                 }
  45
  46                 str << "}";
  47
  48                 return str.str();
  49         }
  50
  51         void fromString(std::string str)
  52         {
  53                 json_object *rootobject;
  54                 json_tokener *tokener = json_tokener_new();
  55                 enum json_tokener_error err;
  56                 do
  57                 {
  58                         rootobject = json_tokener_parse_ex(tokener, str.c_str(),str.length());
  59                 } while ((err = json_tokener_get_error(tokener)) == json_tokener_continue);
  60                 if (err != json_tokener_success)
  61                 {
  62                         fprintf(stderr, "Error: %s\n", json_tokener_error_desc(err));
  63                         // Handle errors, as appropriate for your application.
  64                 }
  65                 if (tokener->char_offset < str.length()) // XXX shouldn't access internal fields
  66                 {
  67                         // Handle extra characters after parsed object as desired.
  68                         // e.g. issue an error, parse another object from that point, etc...
  69                 }
  70                 //Good!
  71
  72                 json_object_object_foreach(rootobject, key, val)
  73                 {
  74                         T one(key);
  75                         N two(json_object_get_string(val));
  76                         append(one,two);
  77
  78                 }
  79                 json_object_put(rootobject);
  80                 /*
  81                 DebugOut()<<"Config members: "<<json_reader_count_members(reader)<<endl;
  82
  83                 gchar** srcMembers = json_reader_list_members(reader);
  84
  85                 for(int i=0; i< json_reader_count_members(reader); i++)
  86                 {
  87                         json_reader_read_member(reader,srcMembers[i]);
  88                         T one(srcMembers[i]);
  89                         N two(json_reader_get_string_value(reader));
  90
  91                         append(one,two);
  92                         json_reader_end_member(reader);
  93                 }
  94
  95                 g_free(srcMembers);
  96                 g_object_unref(reader);
  97                 g_object_unref(parser);*/
  98         }
  99
 100         GVariant* toVariant()
 101         {
 102                 GVariantBuilder params;
 103                 g_variant_builder_init(&params, G_VARIANT_TYPE_DICTIONARY);
 104
 105                 for(auto itr = mMap.begin(); itr != mMap.end(); itr++)
 106                 {
 107                         GVariant **v = g_new(GVariant*,2);
 108                         auto &foo = (*itr).first;
 109                         v[0] = const_cast<T&>(foo).toVariant();
 110                         v[1] = (*itr).second.toVariant();
 111                         GVariant* tuple = g_variant_new_tuple(v,2);
 112
 113                         g_variant_builder_add_value(&params,tuple);
 114
 115                         g_free(v);
 116                 }
 117
 118                 GVariant* var =  g_variant_builder_end(&params);
 119                 g_assert(var);
 120                 return var;
 121         }
 122
 123         void fromVariant(GVariant*)
 124         {
 125
 126         }
 127
 128         void setMap(std::map<T, N> m)
 129         {
 130                 mMap = m;
 131         }
 132
 133 private:
 134
 135         void appendPriv(T  key, N  value)
 136         {
 137                 mMap[key] = value;
 138         }
 139
 140         std::map<T, N> mMap;
 141 };
 142
 143
 144 #endif