QueryUtils.h

Go to the documentation of this file.

/*
 * QueryUtils.h
 *
 *  Created on: Apr 7, 2016
 *      Author: rigazilla
 */

#ifndef INCLUDE_INFINISPAN_HOTROD_QUERYUTILS_H_
#define INCLUDE_INFINISPAN_HOTROD_QUERYUTILS_H_

#include "infinispan/hotrod/Query.h"
#include <tuple>
using namespace org::infinispan::protostream;
using namespace google::protobuf;
using namespace org::infinispan::query::remote::client;


// extract a resultset of entities from a QueryResponse obj
template <class T> bool unwrapResults(QueryResponse resp, std::vector<T> &res)
{
        if (resp.projectionsize()>0)
        {  // Query has select
                return false;
        }
    for (int i=0; i<resp.results_size(); i++)
    {
        const WrappedMessage &wm =resp.results(i);
        if ( wm.has_wrappedbytes() )
        {
                WrappedMessage wmn;
                wmn.ParseFromString(wm.wrappedbytes());
                        if (wmn.has_wrappedmessagebytes()) {
                                T u1;
                                u1.ParseFromString(wmn.wrappedmessagebytes());
                                res.push_back(u1);
                        }
        }
    }
    return true;
}

// typesafe method to extract the value obj from a WrappedMessage obj
template <typename T> T unwrapSingleValue(const WrappedMessage& wm);

template <> inline std::string unwrapSingleValue<std::string>(const WrappedMessage& wm)
{
        if (wm.has_wrappedstring())
        {
        return wm.wrappedstring();
        }
        else
        {
                throw "std::string type not found in response";
        }
}

template <> inline int unwrapSingleValue<int>(const WrappedMessage& wm)
{
        if (wm.has_wrappedint32())
        {
        return wm.wrappedint32();
        }
        else if (wm.has_wrappedint64())
        {
                return wm.wrappedint64();
        }
        else
        {
                throw "int type not found in response";
        }
}

template <> inline double unwrapSingleValue<double>(const WrappedMessage& wm)
{
        if (wm.has_wrappeddouble())
        {
        return wm.wrappeddouble();
        }
        else
        {
                throw "double type not found in response";
        }
}

template <typename T> T unwrapSingleResult(const QueryResponse &qr)
{
        return unwrapSingleValue<T>(qr.results(0));
}


#if !defined (_MSC_VER) || (_MSC_VER>=1800)

// typesafe method to turn one projection row of a array of WrappedMessage objs into a tuple
template <typename H, typename... Params> std::tuple<H, Params...> popTuple(const RepeatedPtrField<WrappedMessage >& wMsgs,  int &k)
{
        H s = unwrapSingleValue<H>(wMsgs.Get(k++));
        std::tuple<Params...> p = popTuple<Params... >(wMsgs,k);
        return std::tuple_cat(std::tie(s),p);
}

template<>
inline std::tuple<int> popTuple<int>(const RepeatedPtrField<WrappedMessage >& wMsgs, int &k)
                {
          int s(unwrapSingleValue<int>(wMsgs.Get(k++)));
          return std::make_tuple<int>(std::move(s));
}

template<>
inline std::tuple<std::string> popTuple<std::string>(const RepeatedPtrField<WrappedMessage >& wMsgs, int &k)
                {
          std::string s(unwrapSingleValue<std::string>(wMsgs.Get(k++)));
          return std::make_tuple<std::string>(std::move(s));
}

// typesafe method to turn one projection row of a QueryResponse obj into a tuple
template <typename H, typename... Params> std::tuple<H, Params...> popTuple(QueryResponse &resp,  int &k)
{
        H s = unwrapSingleValue<H>(resp.results(k++));
        std::tuple<Params...> p=popTuple<Params... >(resp,k);
        return std::tuple_cat(std::tie(s),p);
}

template<>
inline std::tuple<std::string> popTuple<std::string>(QueryResponse& resp, int &k)
                {
          std::string s(unwrapSingleValue<std::string>(resp.results(k++)));
          return std::make_tuple<std::string>(std::move(s));
}

template<>
inline std::tuple<int> popTuple<int>(QueryResponse & resp, int &k)
                {
          int s(unwrapSingleValue<int>(resp.results(k++)));
          return std::make_tuple<int>(std::move(s));
}

template<>
inline std::tuple<double> popTuple<double>(QueryResponse & resp, int &k)
                {
          int s(unwrapSingleValue<double>(resp.results(k++)));
          return std::make_tuple<double>(std::move(s));
}

// typesafe method to convert QueryResponse containing a resultset of projections to a std::tuple
template<typename... Params> bool unwrapProjection(QueryResponse &resp, std::vector<std::tuple<Params...> > &prjRes)
{
        if (resp.projectionsize() == 0) {
                return false;
        }
        int numTuple = resp.results_size() / resp.projectionsize();
        int k = 0;
        for (int i = 0; i < numTuple; i++) {
                                std::tuple<Params...> tp= popTuple<Params...>(resp, k) ;
                                prjRes.push_back(tp);
                        }
        return true;
}
#endif

#endif /* INCLUDE_INFINISPAN_HOTROD_QUERYUTILS_H_ */