DictionaryService.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_SERVICE_H
#define __SSRC_WSPR_INDEX_DICTIONARY_SERVICE_H

#include <ssrc/wispers/index/IndexService.h>

__BEGIN_NS_SSRC_WSPR_INDEX

template<typename ProtocolTraits,
         bool group_membership = GroupMembershipDisable>
class DictionaryService :
  public IndexService<typename ProtocolTraits::map_type,
                      typename ProtocolTraits::index_scheme,
                      group_membership>
{
public:
  typedef ProtocolTraits protocol_traits;
  
  WISP_IMPORT_T(protocol_traits, packing_traits);
  WISP_IMPORT_T(protocol_traits, map_type);
  WISP_IMPORT_T(protocol_traits, index_scheme);

  WISP_IMPORT_T(protocol_traits, MessageInsert);
  WISP_IMPORT_T(protocol_traits, MessageErase);
  WISP_IMPORT_T(protocol_traits, MessageQueryResult);
  WISP_IMPORT_T(protocol_traits, MessageQueryAll);
  WISP_IMPORT_T(protocol_traits, MessageQueryByDefault);
  WISP_IMPORT_T(protocol_traits, MessageSingleQueryResult);
  WISP_IMPORT_T(protocol_traits, MessageSingleQueryByDefault);

  WISP_IMPORT_T(protocol_traits, CallQueryResult);
  WISP_IMPORT_T(protocol_traits, CallSingleQueryResult);

private:
  friend class NS_SSRC_WISP_SERVICE::ServiceProtocolProcessor<packing_traits>;
  typedef IndexService<map_type, index_scheme, group_membership> super;
 
protected:

  virtual void process_request(const MessageInsert & msg,
                               const MessageInfo &)
  {
    unsigned int i = msg.values.size();

    while(i-- > 0) {
      std::pair<typename map_type::iterator, bool> result =
        super::template insert<protocol_traits::ByDefault>(msg.values[i]);

      if(!result.second)
        super::template
          replace<protocol_traits::ByDefault>(result.first, msg.values[i]);
    }
  }

  void process_request(const MessageErase & msg, const MessageInfo &) {
    unsigned int i = msg.keys.size();

    while(i-- > 0)
      super::template erase<protocol_traits::ByDefault>(msg.keys[i]);
  }

  void process_request(const MessageSingleQueryByDefault & msg,
                       const MessageInfo & msginfo)
  {
    super::template process_single_query<protocol_traits::ByDefault, CallSingleQueryResult>(msg, msginfo);
  }

  void process_request(const MessageQueryByDefault & msg,
                       const MessageInfo & msginfo)
  {
    super::template
      process_query<protocol_traits::ByDefault, CallQueryResult>(msg, msginfo);
  }

  void process_request(const MessageQueryAll & msg, const MessageInfo & msginfo)
  {
    super::_caller.template
      reply<CallQueryResult>(Message::FIFOSelfDiscard, msginfo.sender(),
                             msginfo.token(), super::_index);
  }

public:

  explicit DictionaryService(typename super::caller_type & caller) :
    super(caller)
  {
    WISP_SERVICE_REQUEST_T(MessageInsert);
    WISP_SERVICE_REQUEST_T(MessageErase);
    WISP_SERVICE_REQUEST_T(MessageQueryAll);
    WISP_SERVICE_REQUEST_T(MessageQueryByDefault);
    WISP_SERVICE_REQUEST_T(MessageSingleQueryByDefault);
  }

  virtual ~DictionaryService() { }

};

__END_NS_SSRC_WSPR_INDEX

#endif