byteutil.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file byteutil.h
///
/// Utility procedures for writing and reading entire data structures
/// with bzip2 compression, using the two classes "ByteCompressor"
/// and "ByteDecompressor" defined elsewhere.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2014 by Pawel Pilarczyk.
//
// This file is part of my research software package. This is free software:
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// This software 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software; see the file "license.txt". If not,
// please, see <https://www.gnu.org/licenses/>.
 
// Started on July 7, 2014. Last revision: July 8, 2014.
 
 
#ifndef _PWP_BYTEUTIL_H_
#define _PWP_BYTEUTIL_H_
 
 
// include some standard C++ header files
#include <algorithm>
#include <new>
#include <vector>
#include <string>
 
// include selected header files from the CHomP library
#include "chomp/system/textfile.h"
#include "chomp/cubes/pointset.h"
#include "chomp/struct/digraph.h"
#include "chomp/struct/multitab.h"
#include "chomp/struct/hashsets.h"
#include "chomp/system/timeused.h"
 
// include local header files
#include "config.h"
#include "typedefs.h"
#include "conindex.h"
#include "morsedec.h"
#include "typedyns.h"
#include "utils.h"
#include "bytecompr.h"
 
 
// --------------------------------------------------
// ------------------ std::string -------------------
// --------------------------------------------------
 
inline ByteCompressor &operator << (ByteCompressor &c,
        const std::string &v)
{
        size_t size (v. size ());
        c << size;
        for (size_t i = 0; i < size; ++ i)
                c << v [i];
        return c;
} /* operator << */
 
inline ByteDecompressor &operator >> (ByteDecompressor &c,
        std::string &v)
{
        size_t size (0);
        c >> size;
        v. resize (size);
        for (size_t i = 0; i < size; ++ i)
                c >> v [i];
        return c;
} /* operator >> */
 
 
// --------------------------------------------------
// ------------------ std::vector -------------------
// --------------------------------------------------
 
template <class T>
inline ByteCompressor &operator << (ByteCompressor &c,
        const std::vector<T> &v)
{
        size_t size (v. size ());
        c << size;
        for (size_t i = 0; i < size; ++ i)
                c << v [i];
        return c;
} /* operator << */
 
template <class T>
inline ByteDecompressor &operator >> (ByteDecompressor &c,
        std::vector<T> &v)
{
        size_t size (0);
        c >> size;
        v. resize (size);
        for (size_t i = 0; i < size; ++ i)
                c >> v [i];
        return c;
} /* operator >> */
 
 
// --------------------------------------------------
// ------------------- hashedset --------------------
// --------------------------------------------------
 
template <class T>
inline ByteCompressor &operator << (ByteCompressor &c,
        const chomp::homology::hashedset<T> &v)
{
        size_t size (v. size ());
        c << size;
        for (size_t i = 0; i < size; ++ i)
                c << v [i];
        return c;
} /* operator << */
 
template <class T>
inline ByteDecompressor &operator >> (ByteDecompressor &c,
        chomp::homology::hashedset<T> &v)
{
        size_t size (0);
        c >> size;
        chomp::homology::hashedset<T> w;
        for (size_t i = 0; i < size; ++ i)
        {
                T element;
                c >> element;
                w. add (element);
        }
        v. swap (w);
        return c;
} /* operator >> */
 
 
// --------------------------------------------------
// -------------------- spcCube ---------------------
// --------------------------------------------------
 
inline ByteCompressor &operator << (ByteCompressor &c,
        const spcCube &q)
{
        spcCoord coord [spaceDim];
        q. coord (coord);
        for (int i = 0; i < spaceDim; ++ i)
                c << coord [i];
        return c;
} /* operator << */
 
inline ByteDecompressor &operator >> (ByteDecompressor &c,
        spcCube &q)
{
        spcCoord coord [spaceDim];
        for (int i = 0; i < spaceDim; ++ i)
                c >> coord [i];
        q = spcCube (coord, spaceDim);
        return c;
} /* operator >> */
 
 
#endif // _PWP_BYTEUTIL_H_