fileHandler.cpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  bitpit 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 Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
 
#include"bitpit_common.hpp"
 
#include"fileHandler.hpp"
 
namespace bitpit{
 
FileHandler::FileHandler()
    : directory("./"), name("file"), appendix("dat"),
      series(false), counter(0),
      parallel(false), block(0) {
}
 
FileHandler::FileHandler(const std::string &dir_, const std::string &name_, const std::string &app_)
    : directory(dir_), name(name_), appendix(app_),
      series(false), counter(0),
      parallel(false), block(0) {
}
 
FileHandler::FileHandler(const FileHandler& other){
 
    (*this) = other ;
 
}
 
FileHandler&    FileHandler::operator=(const FileHandler& other){
 
    directory   = other.directory ;
    name        = other.name ;
    appendix    = other.appendix ;
    series      = other.series ;
    counter     = other.counter ;
    parallel    = other.parallel ;
    block       = other.block ;
 
 
    return *this ;
}
 
bool   FileHandler::exists() const {
    std::ifstream f( getPath() );
    return f.good() ;
}
 
std::string  FileHandler::getPath() const {
  std::stringstream filename ;
 
  if (!directory.empty()) filename << directory << "/";
  filename << name;
  if(parallel) filename <<".b"<< bitpit::utils::string::zeroPadNumber(4, block)    ;
  if(series)   filename <<"." << bitpit::utils::string::zeroPadNumber(4, counter)  ;
  filename <<"."<< appendix  ;
 
  return filename.str() ;
 
}
 
const std::string &  FileHandler::getDirectory() const {
 
  return directory;
}
 
const std::string &  FileHandler::getName() const {
 
  return name;
}
 
const std::string &  FileHandler::getAppendix() const {
 
  return appendix;
}
 
void    FileHandler::setDirectory(const std::string &d_){
    directory=d_;
    return;
}
 
void    FileHandler::setName(const std::string &n_){
    name=n_;
    return;
}
 
void    FileHandler::setAppendix(const std::string &a_){
    appendix=a_;
    return;
}
 
bool    FileHandler::isSeries() const {
    return series;
}
 
void    FileHandler::setSeries( bool s_){ 
    series=s_; 
    return;
}
 
int  FileHandler::getCounter() const {
  if (series) {
    return counter;
  } else {
    return INVALID_COUNTER;
  }
}
 
void    FileHandler::setCounter(int c_){ 
    counter=c_; 
    return; 
}
 
void    FileHandler::incrementCounter(){ 
    counter++; 
    return; 
}
 
bool    FileHandler::isParallel() const {
    return parallel;
}
 
void    FileHandler::setParallel( bool p_){
    parallel=p_;
    return;
}
 
int    FileHandler::getBlock( ) const {
    return block;
}
 
void    FileHandler::setBlock( int b_){
    block=b_;
    return;
}
 
}