src/JsonSerializer.cpp

   1 //! \file
   2
   3 #include <json/json.h>
   4
   5 #include "Article.h"
   6 #include "JsonSerializer.h"
   7 #include "WalkerException.h"
   8
   9 namespace WikiWalker
  10 {
  11   namespace JsonSerializerInformation
  12   {
  13     constexpr const char* SchemeVersionName = "scheme-version";
  14     static int SchemeVersion                = 2;
  15
  16     constexpr const char* ProgramKeyName = "program";
  17     constexpr const char* ProgramValue   = "wikiwalker";
  18
  19     constexpr const char* CollectionKey = "ArticleCollection";
  20   }  // namespace JsonSerializerInformation
  21
  22   /*! Get article links in an array.
  23    * Basically undoing the Wikipedia to article conversion...
  24    * \param article pointer to article which links should be extracted
  25    * \return Json::Value array with titles as string
  26    * \todo should / could be a member function, but then I'd have to expose
  27    * Json::Value, which is ugly and clutters up other classes...
  28    */
  29   static Json::Value getArticleLinks(const Article* article)
  30   {
  31     Json::Value array(Json::ValueType::arrayValue);
  32
  33     for(auto ali = article->linkBegin(); ali != article->linkEnd(); ali++) {
  34       auto a = ali->lock();
  35       if(a != nullptr) {
  36         std::string tit = a->title();
  37         array.append(Json::Value(tit));
  38       }
  39       // nullptrs in articles will simply be *omitted*
  40       // else {
  41       //   // do nothing!
  42       // }
  43     }
  44
  45     return array;
  46   }
  47
  48   /*! Convert article to string representation of JSON representation.
  49    * \param ac reference to articlecollection to be converted
  50    * \return json as string
  51    * \internal uses the following format:
  52    * {"title":{"forward_links":[...]}, "title2":{"forward_links":[...]}, ...}
  53    */
  54   static std::string convertToJson(const CollectionUtils::ArticleCollection& ac)
  55   {
  56     Json::Value header(Json::ValueType::objectValue);
  57     header[JsonSerializerInformation::ProgramKeyName] =
  58         JsonSerializerInformation::ProgramValue;
  59     header[JsonSerializerInformation::SchemeVersionName] =
  60         JsonSerializerInformation::SchemeVersion;
  61
  62     Json::Value val(Json::ValueType::objectValue);
  63
  64     for(auto ar : ac) {
  65       Json::Value linkObj(Json::ValueType::objectValue);
  66
  67       if(ar.second->analyzed()) {
  68         linkObj["forward_links"] = getArticleLinks(ar.second.get());
  69       } else {
  70         linkObj["forward_links"] = Json::Value::nullSingleton();
  71       }
  72
  73       val[ar.first] = linkObj;
  74     }
  75     header[JsonSerializerInformation::CollectionKey] = val;
  76
  77     Json::StreamWriterBuilder swb;
  78     swb["indentation"] = "";
  79     return Json::writeString(swb, header);
  80   }
  81
  82   void JsonSerializer::serialize(
  83       const CollectionUtils::ArticleCollection& collection,
  84       std::ostream& outstream)
  85   {
  86     outstream << convertToJson(collection);
  87   }
  88
  89   CollectionUtils::ArticleCollection JsonSerializer::deserialize(
  90       std::istream& instream)
  91   {
  92     CollectionUtils::ArticleCollection ac;
  93     deserialize(ac, instream);
  94     return ac;
  95   }
  96
  97   void JsonSerializer::deserialize(
  98       CollectionUtils::ArticleCollection& collection,
  99       std::istream& instream)
 100   {
 101     Json::Value document;
 102     Json::CharReaderBuilder crb;
 103     Json::CharReaderBuilder::strictMode(&crb.settings_);
 104     bool success = Json::parseFromStream(crb, instream, &document, nullptr);
 105
 106     if(!success) {
 107       throw WalkerException("Error parsing JSON");
 108     }
 109
 110     if(!document.isObject()) {
 111       throw WalkerException("Error: Json root is not an object");
 112     }
 113
 114     {
 115       auto programName = document.get(JsonSerializerInformation::ProgramKeyName,
 116                                       Json::Value::nullSingleton());
 117       if(programName.isNull() || !programName.isString() ||
 118          programName.asString() != JsonSerializerInformation::ProgramValue) {
 119         throw WalkerException("Error: Wrong program name");
 120       }
 121     }
 122     {
 123       auto schemeVersion =
 124           document.get(JsonSerializerInformation::SchemeVersionName,
 125                        Json::Value::nullSingleton());
 126       if(schemeVersion.isNull() || !schemeVersion.isNumeric() ||
 127          schemeVersion.asLargestUInt() !=
 128              JsonSerializerInformation::SchemeVersion) {
 129         throw WalkerException("Error: Wrong scheme version");
 130       }
 131     }
 132
 133     auto coll = document.get(JsonSerializerInformation::CollectionKey,
 134                              Json::Value::nullSingleton());
 135     if(coll.isNull() || !coll.isObject()) {
 136       throw WalkerException("Error: collection is not serialized correctly");
 137     }
 138
 139     // get all "main" articles first
 140     for(auto& titleElement : coll.getMemberNames()) {
 141       std::string title = titleElement;
 142
 143       //! \todo find a better solution than get-compare-add
 144       auto a = CollectionUtils::get(collection, title);
 145
 146       if(a == nullptr) {
 147         a = std::make_shared<Article>(title);
 148         CollectionUtils::add(collection, a);
 149       }
 150
 151       auto links = coll.get(title, Json::Value::nullSingleton())
 152                        .get("forward_links", Json::Value::nullSingleton());
 153
 154       if(links.isNull()) {
 155         /* don't need to set article analyzed to false,
 156          * since that's the default */
 157         continue;
 158       }
 159
 160       a->analyzed(true);
 161
 162       for(const auto& linkedArticle : links) {
 163         std::string linkedTitle = linkedArticle.asString();
 164         std::shared_ptr<Article> la =
 165             CollectionUtils::get(collection, linkedTitle);
 166
 167         if(la == nullptr) {
 168           la = std::make_shared<Article>(linkedTitle);
 169           CollectionUtils::add(collection, la);
 170         }
 171
 172         a->addLink(la);
 173       }
 174     }
 175   }
 176 }  // namespace WikiWalker