root/trunk/whisperlib/net/rpc/lib/types/rpc_map.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_MAP_H__
#define __NET_RPC_LIB_TYPES_RPC_MAP_H__

#include <map>
#include <string>
#include <whisperlib/common/base/types.h>
#include <whisperlib/common/base/log.h>
#include <whisperlib/common/base/strutil.h>
#include <whisperlib/net/rpc/lib/types/rpc_object.h>

// Both K and V:
//  - must be a superclass of RPCObject.
//  - must have an implicit constructor with 0 arguments.
//  - must have an implicit constructor with 1 arguments: T(const T&).
//  - must implement static function: static const char * T::Name()
//                { .. return type name for T .. }.

namespace rpc {

template <typename K, typename V>
class Map : public Object {
 public:
  inline static const char* Name() { return RPC_TYPENAME_MAP; }

  typedef typename map<K, V>::iterator Iterator;
  typedef typename map<K, V>::const_iterator ConstIterator;
  Iterator Begin() { return map_.begin(); }
  Iterator End() { return map_.end(); }
  ConstIterator Begin() const { return map_.begin(); }
  ConstIterator End() const { return map_.end(); }
  Iterator Find(const K& key) { return map_.find(key); }
  ConstIterator Find(const K& key) const { return map_.find(key); }

 public:
  Map()
      : Object(),
        map_() {
  }
  Map(const Map<K, V>& m)
      : Object(),
        map_(m.map_) {
  }
  virtual ~Map() {
  }

  uint32 Size() const {
    return map_.size();
  }

  const V& Get(const K& key) const {
    return map_[key];
  }
  bool Insert(const K& key, const V& value) {
    pair<Iterator, bool> result = map_.insert(make_pair(key, value));
    return result.second;
  }
  bool Contains(const K& key) const {
    return map_.find(key) != map_.end();
  }
  V& operator[](const K& key) {
    return map_[key];
  }
  const V& operator[](const K& key) const {
    return map_[key];
  }
  Map<K, V>& operator=(const Map<K, V>& m) {
    map_ = m.map_;
    return *this;
  }

  bool operator==(const Map<K, V>& v) const {
    return map_ == v.map_;
  }
  bool operator!=(const Map<K, V>& v) const {
    return !operator==(v);
  }

  void Erase(const K& key) {
    map_.erase(key);
  }

  void Clear() {
    map_.clear();
  }

  //////////////////////////////////////////////////////////////////////
  //
  //                rpc::Object interface methods
  //
  Object* Clone() const {
    return new Map<K, V>(*this);
  }
  string ToString() const {
    string text(strutil::StringPrintf(
                    "Map (of [%s, %s] #%u): {", K::Name(), V::Name(),
                    static_cast<unsigned int>(Size())));
    if ( map_.empty() ) {
      text += "}";
      return text;
    }
    for ( ConstIterator it = Begin(); ; ) {
      text += string("[") + it->first.ToString() +
              ", " + it->second.ToString() + "]";
      ++it;
      if ( it != End() ) {
        text += ", ";
      } else {
        break;
      }
    }
    text += "}";
    return text;
  }
  virtual void Encode(io::MemoryStream& result, Codec& codec) const;

 private:
  map<K, V> map_;
};
}

#endif   // __NET_RPC_LIB_TYPES_RPC_MAP_H__