login/ws.h

Go to the documentation of this file.

/*
 * Copyright 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_LOGIN_WS_H
#define __SSRC_WSPR_LOGIN_WS_H

#include <ssrc/wispers/login/protocol.h>
#include <ssrc/wispers/ws/protocol.h>
#include <ssrc/wispers/group_session/protocol.h>
#include <ssrc/wispers/utility/ToString.h>

__BEGIN_NS_SSRC_WSPR_LOGIN

using NS_SSRC_WSPR_GROUP_SESSION::GroupSessionProtocol;
using NS_SSRC_WSPR_WS::WebServiceProtocol;
using NS_SSRC_WSPR_WS::WebServiceCallContextTwoWay;
using NS_SSRC_WSPR_UTILITY::properties_ptr;
using NS_SSRC_WSPR_UTILITY::ToString;

// The representation of a uid_to_login map entry is as an array:
//   { login, is_logged_in }
// This is more compact than:
//   { login = value, is_logged_in = value }
// which requires that key strings be allocated for each entry.
inline const properties_ptr &
set_uid_to_login(const properties_ptr & template_data,
                 const uid_login_map & login_map,
                 ToString & to_string)
{
  using NS_SSRC_WSPR_UTILITY::Properties;
  using NS_SSRC_WSPR_UTILITY::primitive_property_vector;
  Properties * logins = template_data->create_node("uid_to_login");

  for(uid_login_map::const_iterator && it = login_map.begin(),
        && end = login_map.end(); it != end; ++it)
  {
    // We store login/status pair as array to avoid overhead of storing
    // extra keys for each entry since generating uid_login_maps is such
    // a common operation.
    primitive_property_vector & values =
      logins->create_primitive_property_vector(to_string(it->first));
    values.push_back(it->second.login);
    values.push_back(it->second.is_logged_in);
  }

  return template_data;
}

namespace detail {

template<typename caller_type>
inline void
continue_find_logins(caller_type & caller, ToString & to_string,
                     const WebServiceCallContextTwoWay & context,
                     const properties_ptr & template_data,
                     const LoginProtocol::CallFindLoginForUID::return_type & result)
{
  caller.template reply<WebServiceProtocol::CallResponse>(ssrc::spread::Message::FIFOSelfDiscard, context.sender, context.token, context.session, set_uid_to_login(template_data, result.logins, to_string));
}

template<typename caller_type>
inline void
continue_find_logins2(caller_type & caller, ToString & to_string,
                      const std::string & relay_group,
                      const GroupSessionProtocol::MessageRelayEvent & mre,
                      const LoginProtocol::CallFindLoginForUID::return_type & result)
{
  set_uid_to_login(mre.event, result.logins, to_string);
  caller.template send<GroupSessionProtocol::CallRelayEvent>(relay_group, mre);
}

template<typename caller_type>
inline void
continue_find_logins3(caller_type & caller, ToString & to_string,
                      const std::string & event_queue,
                      const WebServiceProtocol::MessageDeliverEvent & mde,
                      const LoginProtocol::CallFindLoginForUID::return_type & result)
{
  set_uid_to_login(mde.template_data, result.logins, to_string);
  caller.template send<WebServiceProtocol::CallDeliverEvent>(event_queue, mde);
}

}

template<typename caller_type>
inline void find_logins(caller_type & caller,
                        ToString & to_string,
                        const std::string & login_service,
                        const LoginProtocol::MessageFindLoginForUID & msg,
                        const WebServiceCallContextTwoWay & context,
                        const properties_ptr & template_data)
{
  auto continuation =
    [&caller, &to_string, context, template_data](const LoginProtocol::CallFindLoginForUID::return_type & result)->void {
    detail::continue_find_logins<caller_type>(caller, to_string, context,
                                              template_data, result);
  };
  caller.template
    future_call<LoginProtocol::CallFindLoginForUID>(std::move(continuation),
                                                    login_service, msg);
}

template<typename caller_type>
inline void find_logins(caller_type & caller,
                        ToString & to_string,
                        const std::string & login_service,
                        const LoginProtocol::MessageFindLoginForUID & msg,
                        const std::string & relay_group,
                        const GroupSessionProtocol::MessageRelayEvent & mre)
{
  auto continuation =
    [&caller, &to_string, relay_group, mre](const LoginProtocol::CallFindLoginForUID::return_type & result)->void {
    detail::continue_find_logins2<caller_type>(caller, to_string, relay_group,
                                               mre, result);
  };
  caller.template
    future_call<LoginProtocol::CallFindLoginForUID>(std::move(continuation),
                                                    login_service, msg);
}

template<typename caller_type>
inline void find_logins(caller_type & caller,
                        ToString & to_string,
                        const std::string & login_service,
                        const LoginProtocol::MessageFindLoginForUID & msg,
                        const std::string & event_queue,
                        const WebServiceProtocol::MessageDeliverEvent & mde)
{
  auto continuation =
    [&caller, &to_string, event_queue, mde](const LoginProtocol::CallFindLoginForUID::return_type & result)->void {
    detail::continue_find_logins3<caller_type>(caller, to_string, event_queue,
                                               mde, result);
  };
  caller.template
    future_call<LoginProtocol::CallFindLoginForUID>(std::move(continuation),
                                                    login_service, msg);
}

__END_NS_SSRC_WSPR_LOGIN

#endif