registry/protocol.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_REGISTRY_PROTOCOL_H
#define __SSRC_WSPR_REGISTRY_PROTOCOL_H

#include <boost/serialization/vector.hpp>

#include <ssrc/wispers/protocol.h>

#if !defined(SWIG)

__BEGIN_NS_SSRC_WSPR_PROTOCOL

WSPR_DEFINE_PROTOCOL(Registry,registry);

__END_NS_SSRC_WSPR_PROTOCOL

#endif

__BEGIN_NS_SSRC_WSPR_REGISTRY

using std::string;

struct RegistryEntry {
  string service_name;
  string service_type;

  RegistryEntry() : service_name(), service_type() { }

  RegistryEntry(const string & name, const string & type) :
    service_name(name), service_type(type)
  { }

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

enum RegistryMessageType {
  Register, Reregister, Unregister,
  QueryResult, QueryByName, QueryByType, QueryAll
};

enum IndexScheme { ByName, ByType, ByComposite};

#if !defined(SWIG)
typedef boost::multi_index_container<
  RegistryEntry,
  boost::multi_index::indexed_by<
    boost::multi_index::hashed_non_unique<
      boost::multi_index::member<RegistryEntry, string,
                                 &RegistryEntry::service_name> >,
    boost::multi_index::hashed_non_unique<
      boost::multi_index::member<RegistryEntry, string,
                                 &RegistryEntry::service_type> >,
    boost::multi_index::hashed_unique<
      boost::multi_index::composite_key<
        RegistryEntry,
        boost::multi_index::member<RegistryEntry, string,
                                   &RegistryEntry::service_name>,
        boost::multi_index::member<RegistryEntry, string,
                                   &RegistryEntry::service_type> >
      >
    > > service_map;
#endif

typedef service_map::nth_index<ByName>::type index_by_name;
typedef service_map::nth_index<ByType>::type index_by_type;
typedef service_map::nth_index<ByComposite>::type index_by_composite;

inline string service_group_registry() {
  return protocol::service_type_registry();
}

inline string event_group_register() {
  return WSPR_EVENT_GROUP("registry", "register");
}

typedef std::vector<string> query_list;
typedef std::vector<string> service_type_list;

typedef protocol::MessageRegistry<QueryAll> MessageQueryAll;

#define WSPR_MESSAGE_REGISTRATION(message_id)                    \
  WISP_PROTOCOL_MESSAGE(message_id, protocol::MessageRegistry,   \
                       ((string, service_name))                 \
                       ((service_type_list, service_types)))

WSPR_MESSAGE_REGISTRATION(Register);
WSPR_MESSAGE_REGISTRATION(Reregister);
WSPR_MESSAGE_REGISTRATION(Unregister);

#undef WSPR_MESSAGE_REGISTRATION

WISP_PROTOCOL_MESSAGE(QueryResult, protocol::MessageRegistry,
                     ((service_map, result)));
WISP_PROTOCOL_MESSAGE(QueryByName, protocol::MessageRegistry,
                     ((query_list, keys)));
WISP_PROTOCOL_MESSAGE(QueryByType, protocol::MessageRegistry,
                     ((query_list, keys)));

typedef BinaryPackingTraits RegistryPackingTraits;
typedef NS_SSRC_WISP_PROTOCOL::Caller<RegistryPackingTraits> RegistryCaller;

WISP_ONE_WAY_CALL(RegistryCaller, Register);
WISP_ONE_WAY_CALL(RegistryCaller, Reregister);
WISP_ONE_WAY_CALL(RegistryCaller, Unregister);
WISP_ONE_WAY_CALL(RegistryCaller, QueryResult);

WISP_TWO_WAY_CALL(RegistryCaller, QueryByName, QueryResult);
WISP_TWO_WAY_CALL(RegistryCaller, QueryByType, QueryResult);
WISP_TWO_WAY_CALL(RegistryCaller, QueryAll, QueryResult);

/* Utility functions. */

template<typename caller_type>
string get_service_by_type(caller_type & caller, string service_type) {
  CallQueryByType::parameter_type query;
  CallQueryByType::return_type result;

  query.keys.push_back(service_type);

  caller(CallQueryByType(), service_group_registry(), query, &result);

  if(result.result.size() > 0)
    return result.result.begin()->service_name;

  return string();
}

__END_NS_SSRC_WSPR_REGISTRY

#endif