fileunit.cc

Go to the documentation of this file.

#define TF_FILEUNIT_CC_VERSION \
  "TF_FILEUNIT_CC   V1.2"

#include<fstream>
#include <fapidxx/fileunit.h>
#include <fapidxx/error.h>
#include <fapidxx/helper.h>

namespace fapidxx {

  ::fapidxx::IFileUnits istreammanager;

  ::fapidxx::OFileUnits ostreammanager;

  datrw::Eformat selectedformat=datrw::Fsff;

  /*======================================================================*/

  IFileUnits::IFileUnits()
    : Mformat(datrw::anyID(datrw::Fsff))
  {
    Mstreammap.clear();
  } // IFileUnits::IFileUnits()

  /*----------------------------------------------------------------------*/

  IFileUnits::~IFileUnits()
  {
    while (Mstreammap.size()>0)
    {
      Tstreammap::iterator first=Mstreammap.begin();
      this->close(first->first);
    }
    Mstreammap.clear();
  } // IFileUnits::~IFileUnits()

  /*----------------------------------------------------------------------*/
  datrw::ianystream& IFileUnits::open(const int& unit,
                                        const std::string& filename)
  {
    FAPIDXX_fuassert((!this->isopen(unit)), unit,
                     "IFileUnits::open: file is already open");
    IstreamCompound &compound=Mstreammap[unit];
    compound.Mistream=new std::ifstream(filename.c_str(),
                                        datrw::ianystream::openmode(Mformat));
    compound.Mianystream=new datrw::ianystream(*compound.Mistream, Mformat);
    return (this->getstream(unit));
  } // datrw::ianystream& IFileUnits::open

  /*----------------------------------------------------------------------*/

  void IFileUnits::close(const int& unit) 
  {
    FAPIDXX_fuassert((this->isopen(unit)), unit,
                     "IFileUnits::close: file is not open");
    IstreamCompound &compound=Mstreammap[unit];
    delete compound.Mianystream;
    delete compound.Mistream;
    Mstreammap.erase(unit);
  } // void IFileUnits::close(const int& unit)

  /*----------------------------------------------------------------------*/

  bool IFileUnits::isopen(const int& unit) const
  {
    bool retval=false;
    retval = (Mstreammap.count(unit)>0);
    return(retval);
  } // bool IFileUnits::isopen(const int& unit) const

  /*----------------------------------------------------------------------*/

  datrw::ianystream& IFileUnits::getstream(const int& unit)
  {
    FAPIDXX_fuassert((this->isopen(unit)), unit,
                     "IFileUnits::getstream: file is not open");
    return (*Mstreammap[unit].Mianystream);
  } // datrw::ianystream& IFileUnits::getstream(const int& unit)

  /*----------------------------------------------------------------------*/

  void IFileUnits::setformat(const std::string& format)
  {
    Mformat=format;
  } // void IFileUnits::setformat(const std::string& format)

  /*======================================================================*/

  OFileUnits::OFileUnits()
    : Mformat(datrw::anyID(datrw::Fsff))
  {
    Mstreammap.clear();
  } // OFileUnits::OFileUnits()

  /*----------------------------------------------------------------------*/

  OFileUnits::~OFileUnits()
  {
    while (Mstreammap.size()>0)
    {
      Tstreammap::iterator first=Mstreammap.begin();
      this->close(first->first);
    }
    Mstreammap.clear();
  } // OFileUnits::~OFileUnits()

  /*----------------------------------------------------------------------*/
  datrw::oanystream& OFileUnits::open(const int& unit,
                                      const std::string& filename)
  {
    FAPIDXX_fuassert((!this->isopen(unit)), unit,
                     "OFileUnits::open: file is already open");
    OstreamCompound &compound=Mstreammap[unit];
    datrw::abort_if_exists(filename);
    compound.Mostream=new std::ofstream(filename.c_str(),
                                        datrw::oanystream::openmode(Mformat));
    compound.Moanystream=new datrw::oanystream(*compound.Mostream, Mformat);
    return (this->getstream(unit));
  } // datrw::oanystream& OFileUnits::open

  /*----------------------------------------------------------------------*/

  void OFileUnits::close(const int& unit) 
  {
    FAPIDXX_fuassert((this->isopen(unit)), unit,
                     "OFileUnits::close: file is not open");
    OstreamCompound &compound=Mstreammap[unit];
    delete compound.Moanystream;
    delete compound.Mostream;
    Mstreammap.erase(unit);
  } // void OFileUnits::close(const int& unit)

  /*----------------------------------------------------------------------*/

  bool OFileUnits::isopen(const int& unit) const
  {
    bool retval=false;
    retval = (Mstreammap.count(unit)>0);
    return(retval);
  } // bool OFileUnits::isopen(const int& unit) const

  /*----------------------------------------------------------------------*/

  datrw::oanystream& OFileUnits::getstream(const int& unit)
  {
    FAPIDXX_fuassert((this->isopen(unit)), unit,
                     "OFileUnits::getstream: file is not open");
    return (*Mstreammap[unit].Moanystream);
  } // datrw::oanystream& OFileUnits::getstream(const int& unit)

  /*----------------------------------------------------------------------*/

  void OFileUnits::setformat(const std::string& format)
  {
    Mformat=format;
  } // void OFileUnits::setformat(const std::string& format)

} // namespace fapidxx

/* ----- END OF fileunit.cc ----- */