root/trunk/whisperlib/net/rpc/lib/rpc_util.h

// Copyright (c) 2009, Whispersoft s.r.l.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Whispersoft s.r.l. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: Cosmin Tudorache

#ifndef __NET_RPC_LIB_RPC_UTIL_H__
#define __NET_RPC_LIB_RPC_UTIL_H__

#include <string>
#include <vector>

#include <whisperlib/net/base/address.h>
#include <whisperlib/net/rpc/lib/types/rpc_all_types.h>
#include <whisperlib/net/rpc/lib/codec/rpc_codec_id.h>
#include <whisperlib/net/rpc/lib/client/irpc_client_connection.h>

namespace rpc {
//  Creates an all-in-one address containing all the given parameters.
//  e.g.: "http://192.168.2.3:8081/rpc/manager/master?codec=json"
string CreateUri(const net::HostPort& host_port,
                 const string& path,
                 rpc::CONNECTION_TYPE connection_type,
                 rpc::CODEC_ID codec_id);

//  The reverse of CreateUri.
// input:
//  [IN]  address: the all-in-one master address to be parsed
//  [OUT] host_port: receives the ip & port
//  [OUT] path: receives the request path (usefull only for HTTP)
//  [OUT] connection_type: receives the connection type (HTTP, TCP)
//  [OUT] codec_id: receives the codec id (RPC_CID_BINARY, RPC_CID_JSON)
// returns:
//   success state.
// e.g.:
//    for uri: "http://192.168.2.3:8081/rpc/manager/master?codec=json" returns:
//      host_port: 192.168.2.3:8081
//      path: "/rpc/manager/master"
//      connection_type: rpc::CONNECTION_HTTP
//      codec_id: RPC_CID_JSON
//    for uri: "tcp://192.168.2.3:1234?codec=binary" returns:
//      host_port: 192.168.2.3:1234
//      path: ""
//      connection_type: rpc::CONNECTION_TCP
//      codec_id: RPC_CID_BINARY
bool ParseUri(const string& uri,
              net::HostPort& host_port,
              string& path,
              rpc::CONNECTION_TYPE& connection_type,
              rpc::CODEC_ID& codec_id);
}

namespace rpc_util {

template<typename T>
void AppendToRpcArrayT(const vector<T>& v, rpc::Array<T>& out) {
  uint32 i = out.Size();
  out.Resize(out.Size() + v.size());
  for ( typename vector<T>::const_iterator it = v.begin();
        it != v.end(); ++it, ++i ) {
    const T& t = *it;
    out.Set(i, t);
  }
}

template<typename T>
rpc::Array<T> MakeRpcArrayT(const vector<T>& v) {
  rpc::Array<T> out;
  AppendToRpcArrayT(v, out);
  return out;
}

template <typename T>
void AppendToStdArrayT(const rpc::Array<T>& v, vector<T>& out) {
  out.reserve(out.size() + v.Size());
  for ( uint32 i = 0; i < v.Size(); ++i ) {
    out.push_back(v.Get(i));
  }
}

template <typename T>
vector<T> MakeStdArrayT(const rpc::Array<T>& v) {
  vector<T> out;
  AppendToStdArrayT(v, out);
  return out;
}

/////////////////////////////////////////////////////////////////////////
// specializations of MakeRpcArray, MakeStdArray for basic types: string, int ..

void AppendToRpcArray(const vector<string>& v, rpc::Array<rpc::String>& out);
void AppendToRpcArray(const set<string>& v, rpc::Array<rpc::String>& out);
rpc::Array<rpc::String> MakeRpcArray(const vector<string>& v);
rpc::Array<rpc::String> MakeRpcArray(const set<string>& v);

void AppendToStdArray(const rpc::Array<rpc::String>& v, vector<string>& out);
vector<string> MakeStdArray(const rpc::Array<rpc::String>& v);

};   // namespace rpc_util

#endif   // __NET_RPC_LIB_RPC_UTIL_H__