IndexService.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_INDEX_SERVICE_H
#define __SSRC_WSPR_INDEX_INDEX_SERVICE_H

#include <ssrc/wispers/service/service.h>

__BEGIN_NS_SSRC_WSPR_INDEX

using std::string;
using NS_SSRC_SPREAD::Message;
using NS_SSRC_WISP_PROTOCOL::MessageInfo;
using NS_SSRC_WISP_PROTOCOL::GroupMembershipDisable;

// TODO: If possible, don't make this a service.  Make it a class
// that gets aggregated.

template<typename MapType, typename IndexScheme = unsigned int,
         bool group_membership = GroupMembershipDisable>
class IndexService : public service::ServiceProtocolProcessor {
  typedef service::ServiceProtocolProcessor super;
  friend class NS_SSRC_WISP_SERVICE::ServiceProtocolProcessor<typename super::packing_traits>;

public:
  static const bool GroupMembership = group_membership;

  typedef MapType map_type;
  typedef IndexScheme index_scheme;

protected:

  map_type _index;

  template<index_scheme scheme, typename ResultTraits, typename QueryType>
  void process_query(const QueryType & msg, const MessageInfo & msginfo)
  {
    unsigned int i = msg.keys.size();
    typename ResultTraits::parameter_type reply;

    while(i-- > 0) {
      std::pair<typename map_type::template nth_index_iterator<scheme>::type,
                typename map_type::template nth_index_iterator<scheme>::type>
        range = equal_range<scheme>(msg.keys[i]);

      while(range.first != range.second) {
        reply.result.insert(*range.first);
        ++range.first;
      }
    }

    _caller.reply<ResultTraits>(msginfo.sender(), msginfo.token(), reply,
                                Message::FIFOSelfDiscard);
  }

  template<index_scheme scheme, typename SingleResultTraits, typename SingleQueryType>
  void process_single_query(const SingleQueryType & msg,
                            const MessageInfo & msginfo)
  {
    typename map_type::template nth_index_iterator<scheme>::type it =
      find<scheme>(msg.key);

    _caller.
      reply<SingleResultTraits>(msginfo.sender(), msginfo.token(),
      (it == end<scheme>() ?
       typename SingleResultTraits::parameter_type() :
       typename SingleResultTraits::parameter_type(*it)),
                                Message::FIFOSelfDiscard);
  }

  template<index_scheme scheme>
  typename map_type::template nth_index<scheme>::type &
  get_index() {
    return _index.template get<scheme>();
  }

  template<index_scheme scheme>
  const typename map_type::template nth_index<scheme>::type &
  get_index() const {
    return _index.template get<scheme>();
  }

  virtual void transition(typename super::State state) {
    super::transition(state);
    if(super::state() == super::Stopped)
      _index.clear();
  }

  explicit IndexService(typename super::caller_type & caller) :
    super(caller)
  { }

public:

  virtual ~IndexService() { }

  template<index_scheme scheme>
  bool empty() const {
    return get_index<scheme>().empty();
  }

  template<index_scheme scheme>
  typename map_type::template nth_index<scheme>::type::size_type
  size() const {
    return get_index<scheme>().size();
  }

  template<index_scheme scheme>
  typename map_type::template nth_index_iterator<scheme>::type
  begin() {
    return get_index<scheme>().begin();
  }

  template<index_scheme scheme>
  typename map_type::template nth_index_const_iterator<scheme>::type
  begin() const {
    return get_index<scheme>().begin();
  }

  template<index_scheme scheme>
  typename map_type::template nth_index_iterator<scheme>::type
  end() {
    return get_index<scheme>().end();
  }

  template<index_scheme scheme>
  typename map_type::template nth_index_const_iterator<scheme>::type
  end() const {
    return get_index<scheme>().end();
  }

  template<index_scheme scheme>
  std::pair<typename map_type::template nth_index_iterator<scheme>::type, bool>
  insert(const typename map_type::template nth_index<scheme>::type::value_type & value)
  {
    return get_index<scheme>().insert(value);
  }

  template<index_scheme scheme>
  typename map_type::template nth_index<scheme>::type::size_type
  erase(const typename map_type::template nth_index<scheme>::type::key_type & key)
  {
    return get_index<scheme>().erase(key);
  }

  template<index_scheme scheme>
  bool replace(typename map_type::template nth_index_iterator<scheme>::type position,
               const typename map_type::template nth_index<scheme>::type::value_type & value)
  {
    return get_index<scheme>().replace(position, value);
  }

  template<index_scheme scheme, typename CompatibleKey>
  typename map_type::template nth_index_iterator<scheme>::type
  find(const CompatibleKey & key) const {
    return get_index<scheme>().find(key);
  }

  template<index_scheme scheme, typename CompatibleKey>
  std::pair<typename map_type::template nth_index_iterator<scheme>::type,
            typename map_type::template nth_index_iterator<scheme>::type>
  equal_range(const CompatibleKey & key) const {
    return get_index<scheme>().equal_range(key);
  }

  template<index_scheme scheme, typename CompatibleKey>
  typename map_type::template nth_index<scheme>::type::size_type
  count(const CompatibleKey & key) const {
    return get_index<scheme>().count(key);
  }
};

__END_NS_SSRC_WSPR_INDEX

#endif