root/trunk/whisperlib/net/rpc/lib/types/rpc_custom.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_TYPES_RPC_CUSTOM_H__
#define __NET_RPC_LIB_TYPES_RPC_CUSTOM_H__

#include <string>
#include <whisperlib/net/rpc/lib/types/rpc_object.h>
#include <whisperlib/net/rpc/lib/codec/rpc_decode_result.h>

namespace rpc {

class Encoder;
class Decoder;

class Custom : public Object {
 public:
  Custom();
  virtual ~Custom();

 protected:
  friend class Encoder;
  friend class Decoder;

  // Write object data using the given encoder.
  // There's no reason for this serialization to fail.
  virtual void SerializeSave(Encoder& output) const = 0;

  //  Read object data from the given decoder.
  virtual DECODE_RESULT SerializeLoad(Decoder& input) = 0;

 public:
  //////////////////////////////////////////////////////////////////////
  //
  //                rpc::Custom interface methods
  //
  virtual const char* GetName() const = 0;

  //////////////////////////////////////////////////////////////////////
  //
  //                rpc::Object interface methods
  //
  virtual Object* Clone() const = 0;
  virtual void Encode(io::MemoryStream& result, Codec& codec) const;

  //////////////////////////////////////////////////////////////////////
  //
  //                rpc::Loggable interface methods
  //
  virtual string ToString() const = 0;

 protected:
  // Attribute type for Custom derived classes.
  //
  // Usage example:
  //       class Person : public Custom {
  //          ...
  //        public:
  //          Attribute<rpc::String> name_; //
  //          Attribute<rpc::Date> birthday_;
  //          ...
  //       };
  //       Person p;
  //       p.name_ = rpc::String("Gigel");
  //       p.birthday_ = rpc::Date(1990, 2, 28, 12, 0, 0, 0, true);
  template <typename T>
  class Attribute : public Loggable {
   public:
    Attribute()
        : value_(),
          is_set_(false) {
    }
    Attribute(T& value)
        : value_(value),
          is_set_(true) {
    }
    virtual ~Attribute() {
    }

    void Set(const T& value) {
      value_ = value;
      is_set_ = true;
    }
    void Set(const Attribute<T>& attr) {
      if ( attr.IsSet() ) {
        Set(attr.Get());
      } else {
        Reset();
      }
    }
    bool IsSet() const {
      return is_set_;
    }
    void Reset() {
      is_set_ = false;
    }
    Attribute<T>& operator=(const T& value) {
      Set(value);
      return *this;
    }
    Attribute<T>& operator=(const Attribute<T>& attr) {
      Set(attr);
      return *this;
    }
    const T& Get() const {
      return value_;
    }
    operator const T& () const {
      return value_;
    }
    T& Ref() {
      is_set_ = true;
      return value_;
    }
    bool operator==(const T& value) const {
      return IsSet() && Get() == value;
    }
    bool operator==(const Attribute<T>& attr) const {
      return ((!IsSet() && !attr.IsSet()) ||
              (IsSet() && attr.IsSet() && Get() == attr.Get()));
    }
    string ToString() const {
      if ( IsSet() ) {
        return value_.ToString();
      } else {
        return string("[missing]");
      }
    }
   private:
    T value_;
    bool is_set_;
  };
};
}

#endif  //  __NET_RPC_LIB_TYPES_RPC_CUSTOM_H__