packager.h

Go to the documentation of this file.

/*  Glass - a distributed computing library
    Copyright (C) 2003-2009 Bruno Barberi Gnecco
    Copyright (C) 2009-2010 Corollarium Technologies


    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef _GLASS_PACKAGER_HH_
#define _GLASS_PACKAGER_HH_

#include <iostream>
#include "chain.h"
#include "types.h"
#include <sstream>

// using namespace libglass;

namespace libglass {

#define Serializer(name, type) \
        bool (name)(chain &, type const &, unsigned int, void *)
#define Unserializer(name, type) \
        bool (name)(const chain &, unsigned int, type &, unsigned int &, \
                unsigned int, void *)

/*
 * Interoperable using STL
 */

template<typename T>
bool toString(chain &c, T const &t, unsigned int nmemb = 1, void *extra = NULL) {
        std::ostringstream              s;
        s << t;

        string st = s.str(); 

#if defined(_MSC_VER)
        // Push the current warning state so that we can restore later */
#  pragma warning( push )
        // Disable warning message 4267: conversion from 'size_t' to 'unsigned int', possible loss of data
#  pragma warning( disable: 4267 )
#endif // _MSC_VER
        unsigned int size = st.size(); // *** Possible loss of data here ***
#if defined(_MSC_VER)
        // Restore compiler warning state to previous state
#  pragma warning( pop )
#endif // _MSC_VER

        // TODO: use a special allocator in string st to avoid this copy/malloc
        char *p = new char[size];
        memcpy(p, st.data(), size);
        c.append(p, size, true);
        return true;
}

template<typename T>
bool toString(chain &c, T *const &t, unsigned int nmemb = 1, void *extra = NULL) {
        std::ostringstream              s;
        T                               *ptr = t;

        while (nmemb-- > 0) {
                s << *ptr++ << " ";
        }
        string st = s.str();
        int size = st.size();
        char *p = new char[size];
        memcpy(p, st.data(), size);
//      std::cerr << "p " << p << endl;
        c.append(p, size, true);
        return true;
}

template<typename T>
bool fromString(const chain &c, unsigned int offset, T &data, unsigned int &used,
                        unsigned int nmemb = 1, void *extra = NULL) {
        try {
                std::istringstream is(c.toString(offset));
                is >> data;
                used = is.tellg();
        }
        catch (Exception e) {
                return false;
        }
        return true;
} 

template<typename T>
bool fromString(const chain &c, unsigned int offset, T * const &data, unsigned int &used,
                        unsigned int nmemb = 1, void *extra = NULL) {
        T                                               *ptr = data;

        try {
                std::istringstream is(c.toString(offset));
                while (nmemb-- > 0) {
                        is >> *ptr++;
                        used += is.tellg();
                }
        }
        catch (Exception e) {
                return false;
        }
        return true;
} 

/*
 * RAW
 */
template<typename T>
bool rawPack(chain &c, T const &t, unsigned int nmemb = 1, void *extra = NULL) {
        c.append(reinterpret_cast<const char *>(&t), sizeof(T));
        return true;
}
template<typename T>
bool rawPack(chain &c, T *const &t, unsigned int nmemb = 1, void *extra = NULL) {
        unsigned int used = sizeof(T)*nmemb;
        c.append(reinterpret_cast<const char *>(t), used);
        return true;
}

template<typename T>
bool rawUnpack(const chain &c, unsigned int offset, T &data, unsigned int &used,
                        unsigned int nmemb = 1, void *extra = NULL) {
        used = sizeof(T);
        try {
                c.substrcopy(reinterpret_cast<char *>(&data), offset, offset+used-1);
        }
        catch (Exception e) {
                return false;
        }
        return true;
}
template<typename T>
bool rawUnpack(const chain &c, unsigned int offset, T * const &data, unsigned int &used,
                        unsigned int nmemb = 1, void *extra = NULL) {
        used = sizeof(T)*nmemb;
        try {
                c.substrcopy(reinterpret_cast<char *>(data), offset, offset+used-1);
        }
        catch (Exception e) {
                return false;
        }
        return true;
}

/* 
 * Specializations
 */
#ifdef TODO
template<>
bool toString<int>(chain &c, const int & t, unsigned int nmemb = 1, 
                void *extra = NULL);
template<>
bool toString<int>(chain &c, int *const &t, unsigned int nmemb = 1, 
                void *extra = NULL);

template<>
bool fromString(const chain &c, unsigned int offset, int &data, 
                unsigned int &used, unsigned int nmemb = 1, void *extra = NULL);
template<>
bool fromString(const chain &c, unsigned int offset, int * &data, 
                unsigned int &used, unsigned int nmemb = 1, void *extra = NULL);


template<>
bool toString<float>(chain &c, const T& t);
template<>
bool fromString<float>(const chain &c, unsigned int offset, T &data, unsigned int &used);
#endif

template<>
bool fromString<std::string>(const chain &c, unsigned int offset, 
                std::string &data, unsigned int &used, unsigned int nmemb, 
                void *extra);

template<>
bool rawPack<std::string>(chain &c, std::string const &t, 
                unsigned int nmemb, void *extra);
template<>
bool rawUnpack<std::string>(const chain &c, unsigned int offset, 
                std::string &data, unsigned int &used, unsigned int nmemb, 
                void *extra);

template<>
bool rawPack<char *>(chain &c, char* const &t, unsigned int nmemb, void *extra);
template<>
bool rawUnpack<char *>(const chain &c, unsigned int offset,
                char * &data, unsigned int &used, unsigned int nmemb,
                void *extra);


} // namespace

#endif

---