cmnSerializer.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 _cmnSerializer_h
#define _cmnSerializer_h

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

#include <string>
#include <vector>
#include <fstream>
#include <cstddef>

#include <cisstCommon/cmnExport.h>


// Implementation class to provide serialization when _elementType is not derived from cmnGenericObject
template <class _elementType, bool>
class cmnSerializeRawImpl
{
public:
    static void SerializeRaw(std::ostream & outputStream, const _elementType & data) throw (std::runtime_error)
    {
        outputStream.write(reinterpret_cast<const char *>(&data), sizeof(_elementType));
        if (outputStream.fail()) {
            cmnThrow("cmnSerializeRaw(_elementType): Error occured with std::ostream::write");
        }
    }
};

// Implementation class to provide serialization when _elementType is derived from cmnGenericObject
template <class _elementType>
class cmnSerializeRawImpl<_elementType, true>
{
public:
    static void SerializeRaw(std::ostream & outputStream, const _elementType & data) throw (std::runtime_error)
    {
        data.SerializeRaw(outputStream);
    }
};

template <class _elementType>
inline void cmnSerializeRaw(std::ostream & outputStream, const _elementType & data)
    throw (std::runtime_error)
{
    typedef cmnSerializeRawImpl<_elementType, cmnIsDerivedFrom<_elementType, cmnGenericObject>::IS_DERIVED> impl;
    impl::SerializeRaw(outputStream, data);
}


inline void cmnSerializeSizeRaw(std::ostream & outputStream, const size_t & data)
    throw (std::runtime_error)
{
    unsigned long long int dataToSend = data;
    cmnSerializeRaw(outputStream, dataToSend);
}


inline void cmnSerializeRaw(std::ostream & outputStream, const std::string & data)
    throw (std::runtime_error)
{
    const std::string::size_type size = data.size();
    cmnSerializeSizeRaw(outputStream, size);
    outputStream.write(data.c_str(), size * sizeof(std::string::value_type));
    if (outputStream.fail()) {
        cmnThrow("cmnSerializeRaw(std::string): Error occured with std::ostream::write");
    }
}


template <class _elementType>
inline void cmnSerializeRaw(std::ostream & outputStream, const std::vector<_elementType> & data)
    throw (std::runtime_error)
{
    const typename std::vector<_elementType>::size_type size = data.size();
    cmnSerializeSizeRaw(outputStream, size);
    for (size_t i = 0; i < size; i++) {
        cmnSerializeRaw(outputStream, data[i]);
        if (outputStream.fail()) {
            cmnThrow("cmnSerializeRaw(std::vector<_elementType>): Error occured with std::ostream::write");
        }
    }
}


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

public:

    typedef unsigned long long int TypeId;

    cmnSerializer(std::ostream & outputStream);

    ~cmnSerializer();

    bool ServicesSerialized(const cmnClassServicesBase *servicesPointer) const;

    void Reset(void);

    void Serialize(const cmnGenericObject & object, const bool serializeObject = true);


    void SerializeServices(const cmnClassServicesBase * servicesPointer);


 private:

    std::ostream & OutputStream;

    typedef std::list<const cmnClassServicesBase *> ServicesContainerType;
    typedef ServicesContainerType::const_iterator const_iterator;
    typedef ServicesContainerType::iterator iterator;

    ServicesContainerType ServicesContainer;
};


// Add services instantiation
CMN_DECLARE_SERVICES_INSTANTIATION(cmnSerializer)


#endif // _cmnSerialize_h