binarchive.cc
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:7k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. #include "binarchive.hh"
  19. #include <rpc/types.h>
  20. #include <rpc/xdr.h>
  21. using namespace hadoop;
  22. template <typename T>
  23. static void serialize(T t, OutStream& stream)
  24. {
  25.   if (sizeof(T) != stream.write((const void *) &t, sizeof(T))) {
  26.     throw new IOException("Error serializing data.");
  27.   }
  28. }
  29. template <typename T>
  30. static void deserialize(T& t, InStream& stream)
  31. {
  32.   if (sizeof(T) != stream.read((void *) &t, sizeof(T))) {
  33.     throw new IOException("Error deserializing data.");
  34.   }
  35. }
  36. static void serializeLong(int64_t t, OutStream& stream)
  37. {
  38.   if (t >= -112 && t <= 127) {
  39.     int8_t b = t;
  40.     stream.write(&b, 1);
  41.     return;
  42.   }
  43.         
  44.   int8_t len = -112;
  45.   if (t < 0) {
  46.     t ^= 0xFFFFFFFFFFFFFFFFLL; // take one's complement
  47.     len = -120;
  48.   }
  49.         
  50.   uint64_t tmp = t;
  51.   while (tmp != 0) {
  52.     tmp = tmp >> 8;
  53.     len--;
  54.   }
  55.   
  56.   stream.write(&len, 1);
  57.         
  58.   len = (len < -120) ? -(len + 120) : -(len + 112);
  59.         
  60.   for (uint32_t idx = len; idx != 0; idx--) {
  61.     uint32_t shiftbits = (idx - 1) * 8;
  62.     uint64_t mask = 0xFFLL << shiftbits;
  63.     uint8_t b = (t & mask) >> shiftbits;
  64.     stream.write(&b, 1);
  65.   }
  66. }
  67. static void deserializeLong(int64_t& t, InStream& stream)
  68. {
  69.   int8_t b;
  70.   if (1 != stream.read(&b, 1)) {
  71.     throw new IOException("Error deserializing long.");
  72.   }
  73.   if (b >= -112) {
  74.     t = b;
  75.     return;
  76.   }
  77.   bool isNegative = (b < -120);
  78.   b = isNegative ? -(b + 120) : -(b + 112);
  79.   uint8_t barr[b];
  80.   if (b != stream.read(barr, b)) {
  81.     throw new IOException("Error deserializing long.");
  82.   }
  83.   t = 0;
  84.   for (int idx = 0; idx < b; idx++) {
  85.     t = t << 8;
  86.     t |= (barr[idx] & 0xFF);
  87.   }
  88.   if (isNegative) {
  89.     t ^= 0xFFFFFFFFFFFFFFFFLL;
  90.   }
  91. }
  92. static void serializeInt(int32_t t, OutStream& stream)
  93. {
  94.   int64_t longVal = t;
  95.   ::serializeLong(longVal, stream);
  96. }
  97. static void deserializeInt(int32_t& t, InStream& stream)
  98. {
  99.   int64_t longVal;
  100.   ::deserializeLong(longVal, stream);
  101.   t = longVal;
  102. }
  103. static void serializeFloat(float t, OutStream& stream)
  104. {
  105.   char buf[sizeof(float)];
  106.   XDR xdrs;
  107.   xdrmem_create(&xdrs, buf, sizeof(float), XDR_ENCODE);
  108.   xdr_float(&xdrs, &t);
  109.   stream.write(buf, sizeof(float));
  110. }
  111. static void deserializeFloat(float& t, InStream& stream)
  112. {
  113.   char buf[sizeof(float)];
  114.   if (sizeof(float) != stream.read(buf, sizeof(float))) {
  115.     throw new IOException("Error deserializing float.");
  116.   }
  117.   XDR xdrs;
  118.   xdrmem_create(&xdrs, buf, sizeof(float), XDR_DECODE);
  119.   xdr_float(&xdrs, &t);
  120. }
  121. static void serializeDouble(double t, OutStream& stream)
  122. {
  123.   char buf[sizeof(double)];
  124.   XDR xdrs;
  125.   xdrmem_create(&xdrs, buf, sizeof(double), XDR_ENCODE);
  126.   xdr_double(&xdrs, &t);
  127.   stream.write(buf, sizeof(double));
  128. }
  129. static void deserializeDouble(double& t, InStream& stream)
  130. {
  131.   char buf[sizeof(double)];
  132.   stream.read(buf, sizeof(double));
  133.   XDR xdrs;
  134.   xdrmem_create(&xdrs, buf, sizeof(double), XDR_DECODE);
  135.   xdr_double(&xdrs, &t);
  136. }
  137. static void serializeString(const std::string& t, OutStream& stream)
  138. {
  139.   ::serializeInt(t.length(), stream);
  140.   if (t.length() > 0) {
  141.     stream.write(t.data(), t.length());
  142.   }
  143. }
  144. static void deserializeString(std::string& t, InStream& stream)
  145. {
  146.   int32_t len = 0;
  147.   ::deserializeInt(len, stream);
  148.   if (len > 0) {
  149.     // resize the string to the right length
  150.     t.resize(len);
  151.     // read into the string in 64k chunks
  152.     const int bufSize = 65536;
  153.     int offset = 0;
  154.     char buf[bufSize];
  155.     while (len > 0) {
  156.       int chunkLength = len > bufSize ? bufSize : len;
  157.       stream.read((void *)buf, chunkLength);
  158.       t.replace(offset, chunkLength, buf, chunkLength);
  159.       offset += chunkLength;
  160.       len -= chunkLength;
  161.     }
  162.   }
  163. }
  164. void hadoop::IBinArchive::deserialize(int8_t& t, const char* tag)
  165. {
  166.   ::deserialize(t, stream);
  167. }
  168. void hadoop::IBinArchive::deserialize(bool& t, const char* tag)
  169. {
  170.   ::deserialize(t, stream);
  171. }
  172. void hadoop::IBinArchive::deserialize(int32_t& t, const char* tag)
  173. {
  174.   int64_t longVal = 0LL;
  175.   ::deserializeLong(longVal, stream);
  176.   t = longVal;
  177. }
  178. void hadoop::IBinArchive::deserialize(int64_t& t, const char* tag)
  179. {
  180.   ::deserializeLong(t, stream);
  181. }
  182. void hadoop::IBinArchive::deserialize(float& t, const char* tag)
  183. {
  184.   ::deserializeFloat(t, stream);
  185. }
  186. void hadoop::IBinArchive::deserialize(double& t, const char* tag)
  187. {
  188.   ::deserializeDouble(t, stream);
  189. }
  190. void hadoop::IBinArchive::deserialize(std::string& t, const char* tag)
  191. {
  192.   ::deserializeString(t, stream);
  193. }
  194. void hadoop::IBinArchive::deserialize(std::string& t, size_t& len, const char* tag)
  195. {
  196.   ::deserializeString(t, stream);
  197.   len = t.length();
  198. }
  199. void hadoop::IBinArchive::startRecord(Record& s, const char* tag)
  200. {
  201. }
  202. void hadoop::IBinArchive::endRecord(Record& s, const char* tag)
  203. {
  204. }
  205. Index* hadoop::IBinArchive::startVector(const char* tag)
  206. {
  207.   int32_t len;
  208.   ::deserializeInt(len, stream);
  209.   BinIndex *idx = new BinIndex((size_t) len);
  210.   return idx;
  211. }
  212. void hadoop::IBinArchive::endVector(Index* idx, const char* tag)
  213. {
  214.   delete idx;
  215. }
  216. Index* hadoop::IBinArchive::startMap(const char* tag)
  217. {
  218.   int32_t len;
  219.   ::deserializeInt(len, stream);
  220.   BinIndex *idx = new BinIndex((size_t) len);
  221.   return idx;
  222. }
  223. void hadoop::IBinArchive::endMap(Index* idx, const char* tag)
  224. {
  225.   delete idx;
  226. }
  227. hadoop::IBinArchive::~IBinArchive()
  228. {
  229. }
  230. void hadoop::OBinArchive::serialize(int8_t t, const char* tag)
  231. {
  232.   ::serialize(t, stream);
  233. }
  234. void hadoop::OBinArchive::serialize(bool t, const char* tag)
  235. {
  236.   ::serialize(t, stream);
  237. }
  238. void hadoop::OBinArchive::serialize(int32_t t, const char* tag)
  239. {
  240.   int64_t longVal = t;
  241.   ::serializeLong(longVal, stream);
  242. }
  243. void hadoop::OBinArchive::serialize(int64_t t, const char* tag)
  244. {
  245.   ::serializeLong(t, stream);
  246. }
  247. void hadoop::OBinArchive::serialize(float t, const char* tag)
  248. {
  249.   ::serializeFloat(t, stream);
  250. }
  251. void hadoop::OBinArchive::serialize(double t, const char* tag)
  252. {
  253.   ::serializeDouble(t, stream);
  254. }
  255. void hadoop::OBinArchive::serialize(const std::string& t, const char* tag)
  256. {
  257.   ::serializeString(t, stream);
  258. }
  259. void hadoop::OBinArchive::serialize(const std::string& t, size_t len, const char* tag)
  260. {
  261.   ::serializeString(t, stream);
  262. }
  263. void hadoop::OBinArchive::startRecord(const Record& s, const char* tag)
  264. {
  265. }
  266. void hadoop::OBinArchive::endRecord(const Record& s, const char* tag)
  267. {
  268. }
  269. void hadoop::OBinArchive::startVector(size_t len, const char* tag)
  270. {
  271.   ::serializeInt(len, stream);
  272. }
  273. void hadoop::OBinArchive::endVector(size_t len, const char* tag)
  274. {
  275. }
  276. void hadoop::OBinArchive::startMap(size_t len, const char* tag)
  277. {
  278.   ::serializeInt(len, stream);
  279. }
  280. void hadoop::OBinArchive::endMap(size_t len, const char* tag)
  281. {
  282. }
  283. hadoop::OBinArchive::~OBinArchive()
  284. {
  285. }