FileReader.cpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS 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 General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include "common/toolbox/FileReader.hpp"
#include "common/core/CepsMemory.hpp"
#include "common/core/CepsIoMacros.hpp"
#include "common/toolbox/CepsString.hpp"
 
FileReader::FileReader()
{
}
 
FileReader::FileReader(const CepsString &fileName) :
  m_fileName(fileName)
{
}
 
FileReader::FileReader(const FileReader &that) :
  m_fileName(that.m_fileName)
{
}
 
FileReader&
FileReader::operator=(const FileReader &that)
{
  if (ceps::isDifferentPtr(this, &that))
    m_fileName = that.m_fileName;
  return *this;
}
 
FileReader::~FileReader()
{
  this->close();
}
 
void FileReader::setFileName(const CepsString &fileName)
{
  m_fileName = fileName;
  return;
}
 
CepsBool 
FileReader::open()
{
  m_file.open(m_fileName.c_str(), std::ifstream::in);
 
  if (! m_file.good())
  {
    CEPS_WARNS("Could not open file " << m_fileName);
    return false;
  }
 
  return true;
}
 
void 
FileReader::close()
{
  if (m_file.is_open())
    m_file.close();
  return;
}
 
CepsBool
FileReader::good()
{
  return m_file.good();
}
 
void
FileReader::reset()
{
  // m_file.seekg(0, std::ios::beg); Does not work if EOF has been hit
  this->close();
  this->open();
  return;
}
 
CepsBool 
FileReader::findNext(const CepsString &pattern)
{
  CepsString keyword;
  if (m_file.good())
  {
    m_file >> keyword;
    while (! m_file.eof() && (keyword.compare(pattern) != 0))
      m_file >> keyword;
 
    // Check that we did not end because of eof
    if (checkEOF())
    {
      CEPS_WARNS("No more keyword: " << pattern << " in file " << m_fileName);
      return false;
    }
 
    // pattern has been found
    return true;
  }
  CEPS_WARNS("Unexpected EOF. Keyword " << pattern << " not found in file" << m_fileName);
  return false;
}
 
CepsUInt
FileReader::find(const CepsString &pattern)
{
  // close and reopen the file
  close();
  if (open())
  {
    CepsString keyword;
    do
      m_file >> keyword;
    while (keyword.compare (pattern) != 0 && ! m_file.eof ());
 
    // Check that we did not end because of eof
    if (checkEOF())
      return 0U;
 
    // pattern has been found
    return 1U;
  }
  
  return 0U;
}
 
CepsUInt
FileReader::findNextOf(const CepsVector<CepsString> &keywords)
{
  CepsString line;
  CepsUInt   i, size = keywords.size ();
  while (m_file.good ())
  {
    m_file >> line;
    for (i = 0; i < size; i++)
      if (line == keywords[i])
        return 1;
  }
 
  m_file.close ();
  m_file.open (m_fileName.c_str (), std::ifstream::in);
 
  return 0;
}
 
CepsString
FileReader::getFileName()
{
  return m_fileName;
}
 
CepsUInt
FileReader::skipLines(CepsUInt lines)
{
  CepsString dummy;
  CepsUInt   i = 0;
  if (! lines)
    return 0;
 
  while (m_file.good() && i < lines)
  {
    dummy.clear();
    std::getline(m_file, dummy);
    i++;
  }
 
  if (! m_file.good())
  {
    CEPS_WARNS("Could not skip " << lines << " lines in file " << m_fileName);
    return 1;
  }
  return 0;
}
 
void
FileReader::oneLine(CepsString &line)
{
  std::getline(m_file, line);
  return;
}
 
CepsInt
FileReader::lineIndex(const CepsString &word)
{
  CepsInt    lineIndex = 0;
  CepsString line;
  while (std::getline(m_file, line))
  {
    // std::getline appends at end of CepsString, so it must be cleaned
    if (line.find(word) != CepsString::npos)
      return lineIndex;
    lineIndex++;
    line.clear ();
  }
  // not found
  this->close ();
  this->open ();
  return -1;
}
 
CepsUInt
FileReader::checkEOF()
{
  if (m_file.eof())
  {
    CEPS_WARNS("End of file " << m_fileName << " reached.");
    return 1;
  }
  return 0;
}