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

网格计算

开发平台:

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 "hadoop/SerialUtils.hh"
  19. #include "hadoop/StringUtils.hh"
  20. #include <errno.h>
  21. #include <rpc/types.h>
  22. #include <rpc/xdr.h>
  23. #include <string>
  24. using std::string;
  25. namespace HadoopUtils {
  26.   Error::Error(const std::string& msg): error(msg) {
  27.   }
  28.   Error::Error(const std::string& msg, 
  29.                const std::string& file, int line, 
  30.                const std::string& function) {
  31.     error = msg + " at " + file + ":" + toString(line) + 
  32.             " in " + function;
  33.   }
  34.   const std::string& Error::getMessage() const {
  35.     return error;
  36.   }
  37.   FileInStream::FileInStream()
  38.   {
  39.     mFile = NULL;
  40.     isOwned = false;
  41.   }
  42.   bool FileInStream::open(const std::string& name)
  43.   {
  44.     mFile = fopen(name.c_str(), "rb");
  45.     isOwned = true;
  46.     return (mFile != NULL);
  47.   }
  48.   bool FileInStream::open(FILE* file)
  49.   {
  50.     mFile = file;
  51.     isOwned = false;
  52.     return (mFile != NULL);
  53.   }
  54.   void FileInStream::read(void *buf, size_t len)
  55.   {
  56.     size_t result = fread(buf, len, 1, mFile);
  57.     if (result == 0) {
  58.       if (feof(mFile)) {
  59.         HADOOP_ASSERT(false, "end of file");
  60.       } else {
  61.         HADOOP_ASSERT(false, string("read error on file: ") + strerror(errno));
  62.       }
  63.     }
  64.   }
  65.   bool FileInStream::skip(size_t nbytes)
  66.   {
  67.     return (0==fseek(mFile, nbytes, SEEK_CUR));
  68.   }
  69.   bool FileInStream::close()
  70.   {
  71.     int ret = 0;
  72.     if (mFile != NULL && isOwned) {
  73.       ret = fclose(mFile);
  74.     }
  75.     mFile = NULL;
  76.     return (ret==0);
  77.   }
  78.   FileInStream::~FileInStream()
  79.   {
  80.     if (mFile != NULL) {
  81.       close();
  82.     }
  83.   }
  84.   FileOutStream::FileOutStream()
  85.   {
  86.     mFile = NULL;
  87.     isOwned = false;
  88.   }
  89.   bool FileOutStream::open(const std::string& name, bool overwrite)
  90.   {
  91.     if (!overwrite) {
  92.       mFile = fopen(name.c_str(), "rb");
  93.       if (mFile != NULL) {
  94.         fclose(mFile);
  95.         return false;
  96.       }
  97.     }
  98.     mFile = fopen(name.c_str(), "wb");
  99.     isOwned = true;
  100.     return (mFile != NULL);
  101.   }
  102.   bool FileOutStream::open(FILE* file)
  103.   {
  104.     mFile = file;
  105.     isOwned = false;
  106.     return (mFile != NULL);
  107.   }
  108.   void FileOutStream::write(const void* buf, size_t len)
  109.   {
  110.     size_t result = fwrite(buf, len, 1, mFile);
  111.     HADOOP_ASSERT(result == 1,
  112.                   string("write error to file: ") + strerror(errno));
  113.   }
  114.   bool FileOutStream::advance(size_t nbytes)
  115.   {
  116.     return (0==fseek(mFile, nbytes, SEEK_CUR));
  117.   }
  118.   bool FileOutStream::close()
  119.   {
  120.     int ret = 0;
  121.     if (mFile != NULL && isOwned) {
  122.       ret = fclose(mFile);
  123.     }
  124.     mFile = NULL;
  125.     return (ret == 0);
  126.   }
  127.   void FileOutStream::flush()
  128.   {
  129.     fflush(mFile);
  130.   }
  131.   FileOutStream::~FileOutStream()
  132.   {
  133.     if (mFile != NULL) {
  134.       close();
  135.     }
  136.   }
  137.   StringInStream::StringInStream(const std::string& str): buffer(str) {
  138.     itr = buffer.begin();
  139.   }
  140.   void StringInStream::read(void *buf, size_t buflen) {
  141.     size_t bytes = 0;
  142.     char* output = (char*) buf;
  143.     std::string::const_iterator end = buffer.end();
  144.     while (bytes < buflen) {
  145.       output[bytes++] = *itr;
  146.       ++itr;
  147.       if (itr == end) {
  148.         break;
  149.       }
  150.     }
  151.     HADOOP_ASSERT(bytes == buflen, "unexpected end of string reached");
  152.   }
  153.   void serializeInt(int32_t t, OutStream& stream) {
  154.     serializeLong(t,stream);
  155.   }
  156.   void serializeLong(int64_t t, OutStream& stream)
  157.   {
  158.     if (t >= -112 && t <= 127) {
  159.       int8_t b = t;
  160.       stream.write(&b, 1);
  161.       return;
  162.     }
  163.         
  164.     int8_t len = -112;
  165.     if (t < 0) {
  166.       t ^= -1ll; // reset the sign bit
  167.       len = -120;
  168.     }
  169.         
  170.     uint64_t tmp = t;
  171.     while (tmp != 0) {
  172.       tmp = tmp >> 8;
  173.       len--;
  174.     }
  175.   
  176.     stream.write(&len, 1);      
  177.     len = (len < -120) ? -(len + 120) : -(len + 112);
  178.         
  179.     for (uint32_t idx = len; idx != 0; idx--) {
  180.       uint32_t shiftbits = (idx - 1) * 8;
  181.       uint64_t mask = 0xFFll << shiftbits;
  182.       uint8_t b = (t & mask) >> shiftbits;
  183.       stream.write(&b, 1);
  184.     }
  185.   }
  186.   int32_t deserializeInt(InStream& stream) {
  187.     return deserializeLong(stream);
  188.   }
  189.   int64_t deserializeLong(InStream& stream)
  190.   {
  191.     int8_t b;
  192.     stream.read(&b, 1);
  193.     if (b >= -112) {
  194.       return b;
  195.     }
  196.     bool negative;
  197.     int len;
  198.     if (b < -120) {
  199.       negative = true;
  200.       len = -120 - b;
  201.     } else {
  202.       negative = false;
  203.       len = -112 - b;
  204.     }
  205.     uint8_t barr[len];
  206.     stream.read(barr, len);
  207.     int64_t t = 0;
  208.     for (int idx = 0; idx < len; idx++) {
  209.       t = t << 8;
  210.       t |= (barr[idx] & 0xFF);
  211.     }
  212.     if (negative) {
  213.       t ^= -1ll;
  214.     }
  215.     return t;
  216.   }
  217.   void serializeFloat(float t, OutStream& stream)
  218.   {
  219.     char buf[sizeof(float)];
  220.     XDR xdrs;
  221.     xdrmem_create(&xdrs, buf, sizeof(float), XDR_ENCODE);
  222.     xdr_float(&xdrs, &t);
  223.     stream.write(buf, sizeof(float));
  224.   }
  225.   void deserializeFloat(float& t, InStream& stream)
  226.   {
  227.     char buf[sizeof(float)];
  228.     stream.read(buf, sizeof(float));
  229.     XDR xdrs;
  230.     xdrmem_create(&xdrs, buf, sizeof(float), XDR_DECODE);
  231.     xdr_float(&xdrs, &t);
  232.   }
  233.   void serializeString(const std::string& t, OutStream& stream)
  234.   {
  235.     serializeInt(t.length(), stream);
  236.     if (t.length() > 0) {
  237.       stream.write(t.data(), t.length());
  238.     }
  239.   }
  240.   void deserializeString(std::string& t, InStream& stream)
  241.   {
  242.     int32_t len = deserializeInt(stream);
  243.     if (len > 0) {
  244.       // resize the string to the right length
  245.       t.resize(len);
  246.       // read into the string in 64k chunks
  247.       const int bufSize = 65536;
  248.       int offset = 0;
  249.       char buf[bufSize];
  250.       while (len > 0) {
  251.         int chunkLength = len > bufSize ? bufSize : len;
  252.         stream.read(buf, chunkLength);
  253.         t.replace(offset, chunkLength, buf, chunkLength);
  254.         offset += chunkLength;
  255.         len -= chunkLength;
  256.       }
  257.     } else {
  258.       t.clear();
  259.     }
  260.   }
  261. }