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

网格计算

开发平台:

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. #ifndef HADOOP_SERIAL_UTILS_HH
  19. #define HADOOP_SERIAL_UTILS_HH
  20. #include <string>
  21. namespace HadoopUtils {
  22.   /**
  23.    * A simple exception class that records a message for the user.
  24.    */
  25.   class Error {
  26.   private:
  27.     std::string error;
  28.   public:
  29.     /**
  30.      * Create an error object with the given message.
  31.      */
  32.     Error(const std::string& msg);
  33.     /**
  34.      * Construct an error object with the given message that was created on
  35.      * the given file, line, and functino.
  36.      */
  37.     Error(const std::string& msg, 
  38.           const std::string& file, int line, const std::string& function);
  39.     /**
  40.      * Get the error message.
  41.      */
  42.     const std::string& getMessage() const;
  43.   };
  44.   /**
  45.    * Check to make sure that the condition is true, and throw an exception
  46.    * if it is not. The exception will contain the message and a description
  47.    * of the source location.
  48.    */
  49.   #define HADOOP_ASSERT(CONDITION, MESSAGE) 
  50.     { 
  51.       if (!(CONDITION)) { 
  52.         throw HadoopUtils::Error((MESSAGE), __FILE__, __LINE__, 
  53.                                     __PRETTY_FUNCTION__); 
  54.       } 
  55.     }
  56.   /**
  57.    * An interface for an input stream.
  58.    */
  59.   class InStream {
  60.   public:
  61.     /**
  62.      * Reads len bytes from the stream into the buffer.
  63.      * @param buf the buffer to read into
  64.      * @param buflen the length of the buffer
  65.      * @throws Error if there are problems reading
  66.      */
  67.     virtual void read(void *buf, size_t len) = 0;
  68.     virtual ~InStream() {}
  69.   };
  70.   /**
  71.    * An interface for an output stream.
  72.    */
  73.   class OutStream {
  74.   public:
  75.     /**
  76.      * Write the given buffer to the stream.
  77.      * @param buf the data to write
  78.      * @param len the number of bytes to write
  79.      * @throws Error if there are problems writing
  80.      */
  81.     virtual void write(const void *buf, size_t len) = 0;
  82.     /**
  83.      * Flush the data to the underlying store.
  84.      */
  85.     virtual void flush() = 0;
  86.     virtual ~OutStream() {}
  87.   };
  88.   /**
  89.    * A class to read a file as a stream.
  90.    */
  91.   class FileInStream : public InStream {
  92.   public:
  93.     FileInStream();
  94.     bool open(const std::string& name);
  95.     bool open(FILE* file);
  96.     void read(void *buf, size_t buflen);
  97.     bool skip(size_t nbytes);
  98.     bool close();
  99.     virtual ~FileInStream();
  100.   private:
  101.     /**
  102.      * The file to write to.
  103.      */
  104.     FILE *mFile;
  105.     /**
  106.      * Does is this class responsible for closing the FILE*?
  107.      */
  108.     bool isOwned;
  109.   };
  110.   /**
  111.    * A class to write a stream to a file.
  112.    */
  113.   class FileOutStream: public OutStream {
  114.   public:
  115.     /**
  116.      * Create a stream that isn't bound to anything.
  117.      */
  118.     FileOutStream();
  119.     /**
  120.      * Create the given file, potentially overwriting an existing file.
  121.      */
  122.     bool open(const std::string& name, bool overwrite);
  123.     bool open(FILE* file);
  124.     void write(const void* buf, size_t len);
  125.     bool advance(size_t nbytes);
  126.     void flush();
  127.     bool close();
  128.     virtual ~FileOutStream();
  129.   private:
  130.     FILE *mFile;
  131.     bool isOwned;
  132.   };
  133.   /**
  134.    * A stream that reads from a string.
  135.    */
  136.   class StringInStream: public InStream {
  137.   public:
  138.     StringInStream(const std::string& str);
  139.     virtual void read(void *buf, size_t buflen);
  140.   private:
  141.     const std::string& buffer;
  142.     std::string::const_iterator itr;
  143.   };
  144.   void serializeInt(int32_t t, OutStream& stream);
  145.   int32_t deserializeInt(InStream& stream);
  146.   void serializeLong(int64_t t, OutStream& stream);
  147.   int64_t deserializeLong(InStream& stream);
  148.   void serializeFloat(float t, OutStream& stream);
  149.   float deserializeFloat(InStream& stream);
  150.   void serializeString(const std::string& t, OutStream& stream);
  151.   void deserializeString(std::string& t, InStream& stream);
  152. }
  153. #endif