DictionaryProtocol.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_INDEX_DICTIONARY_PROTOCOL_H
#define __SSRC_WSPR_INDEX_DICTIONARY_PROTOCOL_H

#include <boost/serialization/vector.hpp>

#include <ssrc/wispers/protocol.h>

__BEGIN_NS_SSRC_WSPR_INDEX

using NS_SSRC_WISP_PROTOCOL::wisp_message_id;

template<template <wisp_message_id id> class MessageBase,
         typename MapType, typename IndexScheme>
struct DictionaryProtocol :
  public protocol::ServiceProtocol<MessageBase<0>::protocol>
{
  typedef protocol::ServiceProtocol<MessageBase<0>::protocol> super;

  WISP_IMPORT_T(super, caller_type);

  // Note that Insert will replace an existing entry if present.
  enum {
    Insert, Erase, QueryResult, QueryAll, QueryByDefault, SingleQueryResult,
    SingleQueryByDefault
  };

  // Custom message ids must be greater than this value.
  enum {
    MaxDictionaryMessageID = SingleQueryByDefault
  };

  typedef MapType map_type;
  typedef IndexScheme index_scheme;

  static const index_scheme ByDefault = static_cast<index_scheme>(0);

  typedef
  typename map_type::template nth_index<ByDefault>::type index_by_default;

  typedef MessageBase<QueryAll> MessageQueryAll;

  enum { protocol = MessageQueryAll::protocol };

  struct MessageInsert : public MessageBase<Insert> {
    std::vector<typename map_type::value_type> values;

    template<class Archive>
    void serialize(Archive & ar, const unsigned int) {
      ar & values;
    }
  };

  struct MessageQueryResult : public MessageBase<QueryResult> {
    map_type result;

    MessageQueryResult() { }

    explicit MessageQueryResult(const map_type & result) :
      result(result)
    { }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int) {
      ar & result;
    }
  };

  template<wisp_message_id message_id, index_scheme scheme>
  struct MessageQuery : public MessageBase<message_id> {
    typedef typename map_type::template nth_index<scheme>::type index;
    std::vector<typename index::key_type> keys;

    template<class Archive>
    void serialize(Archive & ar, const unsigned int) {
      ar & keys;
    }
  };

  typedef MessageQuery<QueryByDefault, ByDefault> MessageQueryByDefault;
  typedef MessageQuery<Erase, ByDefault> MessageErase;

  struct MessageSingleQueryResult : public MessageBase<QueryResult> {
    typedef typename map_type::value_type value_type;
    bool found;
    value_type result;

    MessageSingleQueryResult() :
      found(false), result()
    { }

    explicit MessageSingleQueryResult(const value_type & result) :
      found(true), result(result)
    { }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int) {
      ar & found & result;
    }
  };

  template<wisp_message_id message_id, index_scheme scheme>
  struct MessageSingleQuery : public MessageBase<message_id> {
    typedef typename map_type::template nth_index<scheme>::type index;
    typename index::key_type key;

    MessageSingleQuery() { }

    explicit MessageSingleQuery(const typename index::key_type & key) :
      key(key)
    { }

    template<class Archive>
    void serialize(Archive & ar, const unsigned int) {
      ar & key;
    }
  };

  typedef
  MessageSingleQuery<SingleQueryByDefault, ByDefault>
  MessageSingleQueryByDefault;

  WISP_ONE_WAY_CALL(caller_type, Insert);
  WISP_ONE_WAY_CALL(caller_type, Erase);
  WISP_ONE_WAY_CALL(caller_type, QueryResult);
  WISP_ONE_WAY_CALL(caller_type, SingleQueryResult);
  WISP_TWO_WAY_CALL(caller_type, QueryAll, QueryResult);
  WISP_TWO_WAY_CALL(caller_type, QueryByDefault, QueryResult);
  WISP_TWO_WAY_CALL(caller_type, SingleQueryByDefault, SingleQueryResult);
};

__END_NS_SSRC_WSPR_INDEX

#endif