cmnDeSerializer.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Anton Deguet, Min Yang Jung
  Created on: 2007-04-08

  (C) Copyright 2007-2013 Johns Hopkins University (JHU), All Rights Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---

*/


#pragma once

#ifndef _cmnDeSerializer_h
#define _cmnDeSerializer_h

#include <cisstCommon/cmnPortability.h>
#include <cisstCommon/cmnTypeTraits.h>
#include <cisstCommon/cmnGenericObject.h>
#include <cisstCommon/cmnClassRegister.h>
#include <cisstCommon/cmnThrow.h>
#include <cisstCommon/cmnAssert.h>

#include <string>
#include <fstream>
#include <map>
#include <cstddef>

#include <cisstCommon/cmnExport.h>


// Implementation class to provide deserialization when _elementType is not derived from cmnGenericObject
template <class _elementType, bool>
class cmnDeSerializeRawImpl
{
public:
    static void DeSerializeRaw(std::istream & inputStream, _elementType & data) throw (std::runtime_error)
    {
        inputStream.read(reinterpret_cast<char *>(&data), sizeof(_elementType));
        if (inputStream.fail()) {
            std::string message("cmnDeSerializeRaw(_elementType): Error occured with std::istream::read, _elementType = ");
            message += typeid(_elementType).name();
            cmnThrow(message);
        }
    }
};

// Implementation class to provide deserialization when _elementType is derived from cmnGenericObject
template <class _elementType>
class cmnDeSerializeRawImpl<_elementType, true>
{
public:
    static void DeSerializeRaw(std::istream & inputStream, _elementType & data) throw (std::runtime_error)
    {
        data.DeSerializeRaw(inputStream);
    }
};

template <class _elementType>
inline void cmnDeSerializeRaw(std::istream & inputStream, _elementType & data)
    throw (std::runtime_error)
{
    typedef cmnDeSerializeRawImpl<_elementType, cmnIsDerivedFrom<_elementType, cmnGenericObject>::IS_DERIVED> impl;
    impl::DeSerializeRaw(inputStream, data);
}

inline void cmnDeSerializeSizeRaw(std::istream & inputStream, size_t & data)
    throw (std::runtime_error)
{
    unsigned long long int dataToRead;
    cmnDeSerializeRaw(inputStream, dataToRead);
    if (dataToRead <= cmnTypeTraits<size_t>::MaxPositiveValue()) {
        data = static_cast<size_t>(dataToRead);
    } else {
        cmnThrow("cmnDeSerializeSizeRaw: received size greater than maximum supported on this configuration");
    }
}


inline void cmnDeSerializeRaw(std::istream & inputStream, std::string & data)
    throw (std::runtime_error)
{
    std::string::size_type size = 0;
    cmnDeSerializeSizeRaw(inputStream, size);
    data.resize(size);
    // The following seems to work fine, but may not be valid for all implementations of std::string
    // because it is not guaranteed that c_str(), or data(), returns a pointer to the internal buffer;
    // it could create a copy and then return a pointer to the copy.
    //
    // inputStream.read(const_cast<char *>(data.c_str()), size * sizeof(std::string::value_type));
    //
    // So, even though it is less efficient, the data is first deserialized to a buffer and then
    // assigned to the string.
    std::string::value_type *buffer = new std::string::value_type[size];
    inputStream.read(static_cast<char *>(buffer), size * sizeof(std::string::value_type));
    data.assign(buffer, size);
    delete [] buffer;
    if (inputStream.fail()) {
        cmnThrow("cmnDeSerializeRaw(std::string): Error occured with std::istream::read");
    }
}


template <class _elementType>
inline void cmnDeSerializeRaw(std::istream & inputStream, std::vector<_elementType> & data)
    throw (std::runtime_error)
{
    typename std::vector<_elementType>::size_type size = 0;
    cmnDeSerializeSizeRaw(inputStream, size);
    data.resize(size);
    for (size_t i = 0; i < size; i++) {
        cmnDeSerializeRaw(inputStream, data[i]);
        if (inputStream.fail()) {
            cmnThrow("cmnDeSerializeRaw(std::vector<_elementType>): Error occured with std::istream::read");
        }
    }
}


class CISST_EXPORT cmnDeSerializer: public cmnGenericObject {
    CMN_DECLARE_SERVICES(CMN_NO_DYNAMIC_CREATION, CMN_LOG_ALLOW_DEFAULT);

public:
    typedef long long int TypeId;

    cmnDeSerializer(std::istream & inputStream);

    ~cmnDeSerializer();

    void Reset(void);

    cmnGenericObject * DeSerialize(const bool serializeObject = true);


    template <class _elementType>
    inline void DeSerialize(_elementType & object, const bool serializeObject = true) {
        // get object services
        TypeId typeId;
        cmnDeSerializeRaw(this->InputStream, typeId);
        if (typeId == 0) {
            this->DeSerializeServices();
            // read again to deserialize coming object
            if (serializeObject) {
                this->DeSerialize(object);
            }
        } else {
            const const_iterator end = ServicesContainer.end();
            const const_iterator iterator = ServicesContainer.find(typeId);
            if (iterator == end) {
                cmnThrow("DeSerialize: Can't find corresponding class information");
            } else {
                cmnClassServicesBase * servicesPointerLocal = iterator->second;
                if (servicesPointerLocal != object.Services()) {
                    CMN_LOG_CLASS_RUN_ERROR << "DeSerialize: Object types don't match, local class = "
                        << servicesPointerLocal->GetName() << ", object class = " << object.Services()->GetName()
                        << std::endl;
                    cmnThrow("DeSerialize: Object types don't match");
                } else {
                    if (serializeObject) {
                        object.DeSerializeRaw(this->InputStream);
                    }
                }
            }
        }
    }


 private:
    void DeSerializeServices(void) throw(std::runtime_error);

    std::istream & InputStream;

    typedef std::map<TypeId, cmnClassServicesBase *> ServicesContainerType;
    typedef ServicesContainerType::value_type EntryType;

    typedef ServicesContainerType::const_iterator const_iterator;
    typedef ServicesContainerType::iterator iterator;

    ServicesContainerType ServicesContainer;
};


// Add services instantiation
CMN_DECLARE_SERVICES_INSTANTIATION(cmnDeSerializer)


#endif // _cmnDeSerialize_h