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-2018 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) CISST_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) CISST_THROW(std::runtime_error)
    {
        data.SerializeRaw(outputStream);
    }
};

 
template <class _elementType>
inline void cmnSerializeRaw(std::ostream & outputStream, const _elementType & data)
    CISST_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)
    CISST_THROW(std::runtime_error)
{
    unsigned long long int dataToSend = data;
    cmnSerializeRaw(outputStream, dataToSend);
}
 

inline void cmnSerializeRaw(std::ostream & outputStream, const std::string & data)
    CISST_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)
    CISST_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