root/trunk/whisperlib/net/rpc/lib/codec/rpc_encoder.h

// Copyright (c) 2009, Whispersoft s.r.l.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Whispersoft s.r.l. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: Cosmin Tudorache

#ifndef __NET_RPC_LIB_CODEC_RPC_ENCODER_H__
#define __NET_RPC_LIB_CODEC_RPC_ENCODER_H__

#include <whisperlib/common/io/output_stream.h>
#include <whisperlib/common/io/num_streaming.h>
#include <whisperlib/net/rpc/lib/types/rpc_object.h>
#include <whisperlib/net/rpc/lib/types/rpc_object_simple.h>
#include <whisperlib/net/rpc/lib/types/rpc_bool.h>
#include <whisperlib/net/rpc/lib/types/rpc_void.h>
#include <whisperlib/net/rpc/lib/types/rpc_string.h>
#include <whisperlib/net/rpc/lib/types/rpc_date.h>
#include <whisperlib/net/rpc/lib/types/rpc_array.h>
#include <whisperlib/net/rpc/lib/types/rpc_map.h>
#include <whisperlib/net/rpc/lib/types/rpc_custom.h>
#include <whisperlib/net/rpc/lib/types/rpc_message.h>

#include <whisperlib/net/rpc/lib/codec/rpc_typename_codec.h>

namespace rpc {

class Encoder {
 public:
  // Construct an encoder that writes data to the given output stream.
  explicit Encoder(io::MemoryStream& out)
      : out_(&out),
        tmp_() {
  }
  virtual ~Encoder() {
  }

 public:
  //////////////////////////////////////////////////////////////////////
  //
  //                    Encoding methods
  //

  // Methods for serializing complex types: structure, array, map.
  virtual void EncodeStructStart(uint32 nAttribs) = 0;
  virtual void EncodeStructContinue() = 0;
  virtual void EncodeStructEnd() = 0;
  virtual void EncodeStructAttribStart() = 0;
  virtual void EncodeStructAttribMiddle() = 0;
  virtual void EncodeStructAttribEnd() = 0;
  virtual void EncodeArrayStart(uint32 nElements) = 0;
  virtual void EncodeArrayContinue() = 0;
  virtual void EncodeArrayEnd() = 0;
  virtual void EncodeArrayElementStart() = 0;
  virtual void EncodeArrayElementEnd() = 0;
  virtual void EncodeMapStart(uint32 nPairs) = 0;
  virtual void EncodeMapContinue() = 0;
  virtual void EncodeMapEnd() = 0;
  virtual void EncodeMapPairStart() = 0;
  virtual void EncodeMapPairMiddle() = 0;
  virtual void EncodeMapPairEnd() = 0;

 protected:
  // Encode the value of a base type object in the output stream.
  // The reverse of these methods is rpc::Decoder::DecodeBody(..).
  virtual void EncodeBody(const rpc::Void& obj) = 0;
  virtual void EncodeBody(const rpc::Bool& obj) = 0;
  virtual void EncodeBody(const rpc::Int8& obj) = 0;
  virtual void EncodeBody(const rpc::UInt8& obj) = 0;
  virtual void EncodeBody(const rpc::Int16& obj) = 0;
  virtual void EncodeBody(const rpc::UInt16& obj) = 0;
  virtual void EncodeBody(const rpc::Int32& obj) = 0;
  virtual void EncodeBody(const rpc::UInt32& obj) = 0;
  virtual void EncodeBody(const rpc::Int64& obj) = 0;
  virtual void EncodeBody(const rpc::UInt64& obj) = 0;
  virtual void EncodeBody(const rpc::Float& obj) = 0;
  virtual void EncodeBody(const rpc::Double& obj) = 0;
  virtual void EncodeBody(const rpc::String& obj) = 0;
  virtual void EncodeBody(const rpc::Date& obj) = 0;

  template<typename T>
  void EncodeBody(const rpc::Array<T>& obj) {
    uint32 count = obj.Size();
    EncodeArrayStart(count);            // encode the items count
    for ( uint32 i = 0; i < count; i++ ) {
      EncodeArrayElementStart();
      Encode(obj.Get(i));               // encode the items themselves
      EncodeArrayElementEnd();
      if ( i + 1 < count ) {
        EncodeArrayContinue();
      }
    }
    EncodeArrayEnd();
  }

  template<typename K, typename V>
  void EncodeBody(const rpc::Map<K, V>& obj) {
    uint32 count = obj.Size();          // count
    EncodeMapStart(count);              // encode the items count
    uint32 i = 0;
    for ( typename rpc::Map<K, V>::ConstIterator it = obj.Begin();
          it != obj.End(); ++it, ++i ) {
      EncodeMapPairStart();
      Encode(it->first);                // encode the key for an item
      EncodeMapPairMiddle();
      Encode(it->second);               // encode the value for an item
      EncodeMapPairEnd();
      if ( i + 1 < count ) {
        EncodeMapContinue();
      }
    }
    EncodeMapEnd();
  }

  // Encode a custom type object.
  void EncodeBody(const rpc::Custom& obj) {
    obj.SerializeSave(*this);
  }

 public:
  // Encode generic rpc::Object.
  // This method has no reason to fail.
  template <typename T>
  void Encode(const T& obj) {
    RPC_TYPENAME_ENCODE(T::Name());
    EncodeBody(obj);
  }
  // specialization for rpc::Message
  void Encode(const rpc::Message& p) {
    EncodePacket(p);
  }

  template <typename T>
  uint32 EstimateEncodingSize(const T& obj) {
    tmp_.Clear();

    // switch to this output ..
    io::MemoryStream* originalOut = out_;
    out_ = &tmp_;

    // encode the object (using the tmp buffer);
    Encode(obj);

    // switch back to original output
    out_ = originalOut;

    uint32 size = tmp_.Size();
    return size;
  }


  // Encode the given rpc::Message "p".
  // This method has no reason to fail.
  virtual void EncodePacket(const rpc::Message& p);

 protected:
  // the original output stream (as given in constructor)
  io::MemoryStream* out_;
  // an additional buffer used to temporary encode
  // an object for size measurement.
  io::MemoryStream tmp_;

  DISALLOW_EVIL_CONSTRUCTORS(Encoder);
};
}
#endif   // __NET_RPC_LIB_CODEC_RPC_ENCODER_H__