IoStreams.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DDG4_IOSTREAMS_H
#define DDG4_IOSTREAMS_H
 
// C/C++ include files
#include <string>
 
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wshadow" // Code that causes warning goes here
#endif
 
// booost iostreams include files
#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/detail/ios.hpp>
#include <boost/iostreams/detail/path.hpp>
#include <boost/iostreams/positioning.hpp>
 
#ifdef __GNUC__
// Boost spits out an error if __GNUC__ is defined!
#define __DD4HEP_LOCAL_GNUC__ __GNUC__
#undef __GNUC__
#include <boost/iostreams/stream.hpp>
#define __GNUC__ __DD4HEP_LOCAL_GNUC__
#else
#include <boost/iostreams/stream.hpp>
#endif
 
// Forward declarations
class TFile;
 
namespace dd4hep {
 
  // Forward declarations
  template <typename T> class dd4hep_file_source;
  template <typename T> class dd4hep_file_sink;
 
  enum dd4hep_file_flags   {
    never_close_handle = 0,
    close_handle = 3
  };
 
 
  template <typename T> class dd4hep_file {
  public:
    friend class dd4hep_file_source<T>;
    friend class dd4hep_file_sink<T>;
    typedef T     handle_type;
    typedef char  char_type;
    typedef boost::iostreams::stream_offset stream_offset;
    typedef boost::iostreams::detail::path detail_path;
    struct  category : boost::iostreams::seekable_device_tag, boost::iostreams::closable_tag { };
 
    dd4hep_file() = default;
    dd4hep_file(handle_type fd, dd4hep_file_flags);
    dd4hep_file(const char* fname, BOOST_IOS::openmode mode);
    //~dd4hep_file() = default;
    void open(handle_type fd, dd4hep_file_flags flags);
    void open(const char* path, BOOST_IOS::openmode mode = BOOST_IOS::in | BOOST_IOS::out );
    void close();
    std::streamsize read(char_type* s, std::streamsize n);
    std::streamsize write(const char_type* s, std::streamsize n);
    std::streampos seek(stream_offset off, BOOST_IOS::seekdir way);
    bool is_open() const  {  return m_handle != 0;  }
    handle_type handle() const   {   return m_handle; }
 
  private:
    handle_type       m_handle = 0;
    dd4hep_file_flags m_flag = close_handle;
  };
 
 
 
  template <typename T=int> class dd4hep_file_source : private dd4hep_file<T> {
  public:
    typedef dd4hep_file<T> descriptor;
    struct category : boost::iostreams::input_seekable,
                      boost::iostreams::device_tag,
                      boost::iostreams::closable_tag      { };
    typedef typename descriptor::handle_type handle_type;
    typedef typename descriptor::char_type   char_type;
    using descriptor::is_open;
    using descriptor::close;
    using descriptor::read;
    using descriptor::seek;
    using descriptor::handle;
 
    dd4hep_file_source() : descriptor() {  }
 
    dd4hep_file_source(const dd4hep_file_source<T>& other)
      : descriptor(other)      {                     }
 
    explicit dd4hep_file_source(handle_type h, dd4hep_file_flags flags)
      : descriptor(h,flags)  {                       }
 
    explicit dd4hep_file_source(const char* name, BOOST_IOS::openmode mode = BOOST_IOS::in)
      : descriptor(name,mode) {                      }
 
    void open(handle_type h, dd4hep_file_flags flags)
    {     this->descriptor::open(h, flags);              }
 
    void open(const char* path, BOOST_IOS::openmode mode = BOOST_IOS::in)
    {     this->descriptor::open(path,mode);             }
 
    void open(const std::string& path, BOOST_IOS::openmode mode = BOOST_IOS::in)
    {     open(path.c_str(), mode);                                 }
 
    template<typename Path> void open(const Path& path, BOOST_IOS::openmode mode = BOOST_IOS::in)
    {     open(detail_path(path), mode);                           }
  };
 
 
  template <typename T>
  class  dd4hep_file_sink : private dd4hep_file<T> {
  public:
    typedef dd4hep_file<T> descriptor;
    struct category : boost::iostreams::output_seekable,
                      boost::iostreams::device_tag,
                      boost::iostreams::closable_tag  { };
    typedef typename descriptor::handle_type handle_type;
    typedef typename descriptor::char_type   char_type;
    using descriptor::is_open;
    using descriptor::close;
    using descriptor::write;
    using descriptor::seek;
    using descriptor::handle;
 
    dd4hep_file_sink()  {                        }
 
    dd4hep_file_sink(const dd4hep_file_sink<T>& other)
      : descriptor(other) {                     }
 
    explicit dd4hep_file_sink(handle_type fd, dd4hep_file_flags flags)
      : descriptor(fd, flags)      {            }
 
    explicit dd4hep_file_sink(const std::string& path, BOOST_IOS::openmode mode = BOOST_IOS::out)
      : descriptor(path.c_str(), mode)     {    }
 
    explicit dd4hep_file_sink(const char* path, BOOST_IOS::openmode mode = BOOST_IOS::out )
      : descriptor(path, mode)     {            }
 
    template<typename Path>
    explicit dd4hep_file_sink(const Path& path, BOOST_IOS::openmode mode = BOOST_IOS::out )
      : descriptor(detail_path(path), mode)  { }
 
    void open(handle_type fd, dd4hep_file_flags flags)
    {   this->descriptor::open(fd,flags);         }
 
    void open(const std::string& path, BOOST_IOS::openmode mode = BOOST_IOS::out )
    {  open(path.c_str(),mode);                            }
 
    void open(const char* path, BOOST_IOS::openmode mode = BOOST_IOS::out )
    {  this->descriptor::open(path, mode);      }
 
    template<typename Path> void open(const Path& path, BOOST_IOS::openmode mode = BOOST_IOS::out )
    {  open(detail_path(path), mode);                     }
  };
}   // End namespace boost
 
 
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
 
#endif // DDG4_IOSTREAMS_H