root/trunk/whisperlib/net/rpc/lib/codec/rpc_decoder.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_DECODER_H__
#define __NET_RPC_LIB_CODEC_RPC_DECODER_H__

#include <list>

#include <whisperlib/common/base/types.h>
#include <whisperlib/common/io/input_stream.h>
#include <whisperlib/common/io/output_stream.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_decode_result.h>
#include <whisperlib/net/rpc/lib/codec/rpc_typename_codec.h>

namespace rpc {

class Decoder {
 public:
  // Construct a decoder that reads data from the given input stream.
  explicit Decoder(io::MemoryStream& in)
      : in_(in) {
  }
  virtual ~Decoder() {
  }

 public:
  //  Methods for unwinding complex types: structure, array, map.
  // returns:
  //  success status.
  // NOTE: in case of error or not-enough-data, the read data is not restored.
  virtual DECODE_RESULT DecodeStructStart(uint32& nAttribs) = 0;
  virtual DECODE_RESULT DecodeStructContinue(bool& bMoreAttribs) = 0;
  virtual DECODE_RESULT DecodeStructAttribStart() = 0;
  virtual DECODE_RESULT DecodeStructAttribMiddle() = 0;
  virtual DECODE_RESULT DecodeStructAttribEnd() = 0;
  virtual DECODE_RESULT DecodeArrayStart(uint32& nElements) = 0;
  virtual DECODE_RESULT DecodeArrayContinue(bool& bMoreElements) = 0;
  virtual DECODE_RESULT DecodeMapStart(uint32& nPairs) = 0;
  virtual DECODE_RESULT DecodeMapContinue(bool& bMorePairs) = 0;
  virtual DECODE_RESULT DecodeMapPairStart() = 0;
  virtual DECODE_RESULT DecodeMapPairMiddle() = 0;
  virtual DECODE_RESULT DecodeMapPairEnd() = 0;

 protected:
  //  Decode a basic type value from the input stream. Usually the object type
  //  is not stored in stream, so the decoder cannot check data correctness.
  //  You must know somehow the type of data you're expecting.
  //  These methods are the oposite of rpc::Encoder::EncodeBody(..).
  // returns:
  //   -   1  if the object succeessfully loads from stream
  //   -   0  if there is not enough data in stream
  //   - (-1) error loading object. Bad data in stream.
  // NOTE: in case of error or not-enough-data, the read data is not restored.
  virtual DECODE_RESULT DecodeBody(rpc::Void& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::Bool& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::Int8& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::UInt8& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::Int16& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::UInt16& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::Int32& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::UInt32& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::Int64& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::UInt64& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::Float& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::Double& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::String& out) = 0;
  virtual DECODE_RESULT DecodeBody(rpc::Date& out) = 0;

#define DECODE_VERIFY(dec_op)                     \
  do {                                            \
    const rpc::DECODE_RESULT result = dec_op;     \
    if ( result != rpc::DECODE_RESULT_SUCCESS ) { \
      return result;                              \
    }                                             \
  } while ( false )

  template <typename T>
  DECODE_RESULT DecodeBody(rpc::Array<T>& out) {
    // decode array items count
    uint32 count;
    DECODE_VERIFY(DecodeArrayStart(count));
    if ( count != kMaxUInt32 ) {
      // TODO(cpopescu): well, this may not be that smart - to check
      out.Resize(count);

      // decode elements
      bool has_more = false;
      for ( int i = 0; i < count; i++ ) {
        DECODE_VERIFY(DecodeArrayContinue(has_more));
        CHECK(has_more);
        T& item = out.Get(i);

        DECODE_VERIFY(Decode(item));
      }

      // bug-trap
      has_more = false;
      DECODE_VERIFY(DecodeArrayContinue(has_more));
      CHECK(!has_more);
      return DECODE_RESULT_SUCCESS;
    }
    list<T> tmp;
    T empty_item;

    // decode elements in a temporary list
    bool has_more = false;
    while ( true ) {
      DECODE_VERIFY(DecodeArrayContinue(has_more));
      if ( !has_more ) {
        break;
      }
      tmp.push_back(empty_item);
      T& item = tmp.back();
      DECODE_VERIFY(Decode(item));
    }

    // copy elements from temporary list to output array
    //
    out.Resize(tmp.size());
    uint32 i = 0;
    for ( typename list<T>::iterator it = tmp.begin();
          it != tmp.end(); ++it, ++i ) {
      T& item = *it;
      out.Set(i, item);
    }
    return DECODE_RESULT_SUCCESS;
  }

  template <typename K, typename V>
  DECODE_RESULT DecodeBody(rpc::Map<K, V>& out) {
    // decode map pairs count
    //
    uint32 count;
    DECODE_RESULT result = DecodeMapStart(count);
    if ( result != DECODE_RESULT_SUCCESS ) {
      return result;
    }

    out.Clear();

    // decode [key, value] pairs
    //
    bool has_more = true;
    K key;
    V value;
    while ( (result = DecodeMapContinue(has_more)) == DECODE_RESULT_SUCCESS &&
            has_more ) {
      DECODE_VERIFY(DecodeMapPairStart());
      DECODE_VERIFY(Decode(key));
      DECODE_VERIFY(DecodeMapPairMiddle());
      DECODE_VERIFY(Decode(value));
      DECODE_VERIFY(DecodeMapPairEnd());
      out.Insert(key, value);
    }
    if ( result != DECODE_RESULT_SUCCESS ) {
      return result;
    }

    // TODO(cpopescu): wtf is w/ this check here ?
    if ( count != kMaxUInt32 ) {
      CHECK_EQ(count, out.Size());
    }
    return DECODE_RESULT_SUCCESS;
  }
  // TODO(cpopescu): shall we leave this around or redefine it (is needed
  //   in rpc_json_decoder.cc
  // #undef DECODE_VERIFY

  //  Decode a custom type object.
  DECODE_RESULT DecodeBody(rpc::Custom& out) {
    return out.SerializeLoad(*this);
  }

 public:
  //  Reset internal state. Should be called before Decode.
  //  If a previous try to Decode failed for insufficient data,
  //  the internal state may be mangled.
  virtual void Reset() = 0;

  //  Decode generic rpc::Object.
  // Returns:
  //   DECODE_RESULT_SUCCESS: if the object was successfully read.
  //   DECODE_RESULT_NOT_ENOUGH_DATA: if there is not enough data
  //                                  in the input buffer.
  //                                  The read data is not restored.
  //   DECODE_RESULT_ERROR: if the data does not look like the expected object.
  //          The read data is not restored.
  template<typename T>
  DECODE_RESULT Decode(T& out) {
    RPC_TYPENAME_DECODE_AND_CHECK(T::Name());   // this normally is emptyx
    return DecodeBody(out);
  }
  // specialization for rpc::Message
  DECODE_RESULT Decode(rpc::Message& out) {
    return DecodePacket(out);
  }

  //  Skip bytes. Used to skip over unknown fields of custom objects.
  // returns:
  //   1 - on success.
  //   0 - error: the input stream contains less than "size" bytes.
  //       NOTE: on error the input stream is modified!
  int32 SkipBytes_TODO_DeleteMe(uint32 size) {
    const uint32 skipped = in_.Skip(size);
    return skipped < size ? 0 : 1;
  }

  // Decodes data from the "input" stream trying to recompose a rpc::Message
  //  which is stored in "out".
  // returns:
  //   DECODE_RESULT_SUCCESS: if a rpc::Message was successfully read.
  //   DECODE_RESULT_NOT_ENOUGH_DATA: if there is not enough data
  //                                  in the input buffer.
  //                                  The read data is not restored.
  //   DECODE_RESULT_ERROR: if the data does not look like a rpc::Message.
  //          The read data is not restored.
  // NOTE: in case of error or not-enough-data, the read data is not restored.
  virtual DECODE_RESULT DecodePacket(rpc::Message& out);

 protected:
  io::MemoryStream& in_;

  DISALLOW_EVIL_CONSTRUCTORS(Decoder);
};
}

#endif   // __NET_RPC_LIB_CODEC_RPC_DECODER_H__