IoStreams.h

Go to the documentation of this file.

// $Id: $
//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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 DD4HEP_DD4HEP_IOSTREAMS_H
#define DD4HEP_DD4HEP_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 { };

    // Default constructor
    dd4hep_file() : m_handle(0) {   }
    // Constructors taking file desciptors
    dd4hep_file(handle_type fd, dd4hep_file_flags);
    // Constructors taking file desciptors
    dd4hep_file(const char* fname, BOOST_IOS::openmode mode);

    // open overloads taking file descriptors
    void open(handle_type fd, dd4hep_file_flags flags);

    // open overload taking C-style string
    void open(const char* path, BOOST_IOS::openmode mode = BOOST_IOS::in | BOOST_IOS::out );

    bool is_open() const  {  return m_handle != 0;  }
    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);
    handle_type handle() const   {   return m_handle; }
  private:
    handle_type m_handle;
    dd4hep_file_flags m_flag;
  };



  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 // DD4HEP_DD4HEP_IOSTREAMs_H