Loading...
Searching...
No Matches
mostream.hh
/* ========================================================================= *
* *
* OpenMesh *
* Copyright (c) 2001-2022, RWTH-Aachen University *
* Department of Computer Graphics and Multimedia *
* All rights reserved. *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
*---------------------------------------------------------------------------*
* *
* Redistribution and use in source and binary forms, with or without *
* modification, are permitted provided that the following conditions *
* are met: *
* *
* 1. Redistributions of source code must retain the above copyright notice, *
* this list of conditions and the following disclaimer. *
* *
* 2. Redistributions in binary form must reproduce the above copyright *
* notice, this list of conditions and the following disclaimer in the *
* documentation and/or other materials provided with the distribution. *
* *
* 3. Neither the name of the copyright holder nor the names of its *
* contributors may be used to endorse or promote products derived from *
* this software without specific prior written permission. *
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
* *
* ========================================================================= */
//=============================================================================
//
// multiplex streams & ultilities
//
//=============================================================================
#ifndef OPENMESH_MOSTREAM_HH
#define OPENMESH_MOSTREAM_HH
//== INCLUDES =================================================================
#include <OpenMesh/Core/System/config.h>
#include <ostream>
#if defined( OM_CC_GCC ) && OM_CC_VERSION < 30000
# include <streambuf.h>
#else
# include <streambuf>
#endif
#include <vector>
#include <map>
#include <string>
#include <algorithm>
#if (defined(_MSC_VER) && (_MSC_VER >= 1800)) || __cplusplus > 199711L || defined( __GXX_EXPERIMENTAL_CXX0X__ )
#include <mutex>
#endif
//== NAMESPACES ===============================================================
namespace OpenMesh {
#ifndef DOXY_IGNORE_THIS
//== CLASS DEFINITION =========================================================
class basic_multiplex_target
{
public:
virtual ~basic_multiplex_target() {}
virtual void operator<<(const std::string& _s) = 0;
};
template <class T>
class multiplex_target : public basic_multiplex_target
{
public:
explicit multiplex_target(T& _t) : target_(_t) {}
virtual void operator<<(const std::string& _s) override { target_ << _s; }
private:
T& target_;
};
//== CLASS DEFINITION =========================================================
#if defined( OM_CC_GCC ) && OM_CC_VERSION < 30000
# define STREAMBUF streambuf
# define INT_TYPE int
# define TRAITS_TYPE
#else
# define STREAMBUF std::basic_streambuf<char>
#endif
class multiplex_streambuf : public STREAMBUF
{
public:
typedef STREAMBUF base_type;
#if defined( OM_CC_GCC ) && OM_CC_VERSION < 30000
typedef int int_type;
struct traits_type
{
static int_type eof() { return -1; }
static char to_char_type(int_type c) { return char(c); }
};
#else
typedef base_type::int_type int_type;
typedef base_type::traits_type traits_type;
#endif
// Constructor
multiplex_streambuf() : enabled_(true) { buffer_.reserve(100); }
// Destructor
~multiplex_streambuf()
{
tmap_iter t_it(target_map_.begin()), t_end(target_map_.end());
for (; t_it!=t_end; ++t_it)
delete t_it->second;
}
// buffer enable/disable
bool is_enabled() const { return enabled_; }
void enable() { enabled_ = true; }
void disable() { enabled_ = false; }
// construct multiplex_target<T> and add it to targets
template <class T> bool connect(T& _target)
{
void* key = (void*) &_target;
if (target_map_.find(key) != target_map_.end())
return false;
target_type* mtarget = new multiplex_target<T>(_target);
target_map_[key] = mtarget;
__connect(mtarget);
return true;
}
// disconnect target from multiplexer
template <class T> bool disconnect(T& _target)
{
void* key = (void*) &_target;
tmap_iter t_it = target_map_.find(key);
if (t_it != target_map_.end())
{
__disconnect(t_it->second);
target_map_.erase(t_it);
return true;
}
return false;
}
protected:
// output what's in buffer_
virtual int sync()
{
// If working on multiple threads, we need to serialize the output correctly (requires c++11 headers)
#if (defined(_MSC_VER) && (_MSC_VER >= 1800)) || __cplusplus > 199711L || defined( __GXX_EXPERIMENTAL_CXX0X__ )
std::lock_guard<std::mutex> lck (serializer_);
#endif
if (!buffer_.empty())
{
if (enabled_) multiplex();
#if defined( OM_CC_GCC ) && OM_CC_VERSION < 30000
buffer_ = ""; // member clear() not available!
#else
buffer_.clear();
#endif
}
return base_type::sync();
}
// take on char and add it to buffer_
// if '\n' is encountered, trigger a sync()
virtual
int_type overflow(int_type _c = multiplex_streambuf::traits_type::eof())
{
char c = traits_type::to_char_type(_c);
// If working on multiple threads, we need to serialize the output correctly (requires c++11 headers)
#if (defined(_MSC_VER) && (_MSC_VER >= 1800)) || __cplusplus > 199711L || defined( __GXX_EXPERIMENTAL_CXX0X__ )
{
std::lock_guard<std::mutex> lck (serializer_);
buffer_.push_back(c);
}
#else
buffer_.push_back(c);
#endif
if (c == '\n') sync();
return 0;
}
private:
typedef basic_multiplex_target target_type;
typedef std::vector<target_type*> target_list;
typedef target_list::iterator tlist_iter;
typedef std::map<void*, target_type*> target_map;
typedef target_map::iterator tmap_iter;
// add _target to list of multiplex targets
void __connect(target_type* _target) { targets_.push_back(_target); }
// remove _target from list of multiplex targets
void __disconnect(target_type* _target) {
targets_.erase(std::find(targets_.begin(), targets_.end(), _target));
}
// multiplex output of buffer_ to all targets
void multiplex()
{
tlist_iter t_it(targets_.begin()), t_end(targets_.end());
for (; t_it!=t_end; ++t_it)
**t_it << buffer_;
}
private:
target_list targets_;
target_map target_map_;
std::string buffer_;
bool enabled_;
// If working on multiple threads, we need to serialize the output correctly (requires c++11 headers)
#if (defined(_MSC_VER) && (_MSC_VER >= 1800)) || __cplusplus > 199711L || defined( __GXX_EXPERIMENTAL_CXX0X__ )
std::mutex serializer_;
#endif
};
#undef STREAMBUF
//== CLASS DEFINITION =========================================================
class mostream : public std::ostream
{
public:
explicit mostream() : std::ostream(nullptr) { init(&streambuffer_); }
template <class T> bool connect(T& _target)
{
return streambuffer_.connect(_target);
}
template <class T> bool disconnect(T& _target)
{
return streambuffer_.disconnect(_target);
}
bool is_enabled() const { return streambuffer_.is_enabled(); }
void enable() { streambuffer_.enable(); }
void disable() { streambuffer_.disable(); }
private:
multiplex_streambuf streambuffer_;
};
//=============================================================================
#endif
} // namespace OpenMesh
//=============================================================================
#endif // OPENMESH_MOSTREAM_HH defined
//=============================================================================
OpenMesh
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition MeshItems.hh:59