G4tgrFileIn Class Reference

#include <G4tgrFileIn.hh>

Public Member Functions
void	Close ()
void	DumpException (const G4String &sent)
G4bool	EndOfFile ()
void	ErrorInLine ()
	G4tgrFileIn ()
const G4String &	GetName ()
G4int	GetWordsInLine (std::vector< G4String > &wl)
G4int	Nline ()
void	OpenNewFile (const char *filename)
	~G4tgrFileIn ()

Static Public Member Functions
static G4tgrFileIn &	GetInstance (const G4String &name)
static G4tgrFileIn &	GetInstanceOpened (const G4String &name)

Private Member Functions
	G4tgrFileIn (const G4String &name)

Private Attributes
G4int	theCurrentFile = -1
std::vector< std::ifstream * >	theFiles
std::vector< G4int >	theLineNo
G4String	theName = ""
std::vector< G4String >	theNames

Static Private Attributes
static G4ThreadLocal std::vector< G4tgrFileIn * > *	theInstances = nullptr

Detailed Description

Definition at line 41 of file G4tgrFileIn.hh.

Constructor & Destructor Documentation

G4tgrFileIn() [1/2]

G4tgrFileIn::G4tgrFileIn

(

)

Definition at line 45 of file G4tgrFileIn.cc.

{
  if(theInstances == nullptr)
  {
    theInstances = new std::vector<G4tgrFileIn*>;
  }
}

References theInstances.

Referenced by GetInstance().

~G4tgrFileIn()

G4tgrFileIn::~G4tgrFileIn

(

)

Definition at line 54 of file G4tgrFileIn.cc.

{
  delete theInstances;
  theInstances = nullptr;
  /*
    for( auto vfcite = theInstances->cbegin();
              vfcite != theInstances->cend(); ++vfcite)
    {
      delete *vfcite;
    }
  */
}

References theInstances.

G4tgrFileIn() [2/2]

G4tgrFileIn::G4tgrFileIn ( const G4String &  name )

inlineprivate

Definition at line 73 of file G4tgrFileIn.hh.

: theName(name) {}

Member Function Documentation

Close()

void G4tgrFileIn::Close

(

)

Definition at line 419 of file G4tgrFileIn.cc.

{
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 3)
  {
    G4cout << "G4tgrFileIn::Close() - " << theCurrentFile << ", size "
           << theFiles.size() << G4endl;
  }
#endif
 
  theFiles[theCurrentFile + 1]->close();
  theFiles.pop_back();
}

References G4cout, G4endl, G4tgrMessenger::GetVerboseLevel(), theCurrentFile, and theFiles.

Referenced by EndOfFile().

DumpException()

void G4tgrFileIn::DumpException

(

const G4String &

sent

)

Definition at line 434 of file G4tgrFileIn.cc.

{
  G4String Err1 = sent + " in file " + theName;
  G4String Err2 =
    " line No: " + G4UIcommand::ConvertToString(theLineNo[theCurrentFile]);
  G4String ErrMessage = Err1;
  G4Exception("G4tgrFileIn::DumpException()", "FileError", FatalException,
              ErrMessage);
}

References G4UIcommand::ConvertToString(), FatalException, G4Exception(), theCurrentFile, theLineNo, and theName.

Referenced by GetWordsInLine(), and G4tgrFileReader::ReadFiles().

EndOfFile()

G4bool G4tgrFileIn::EndOfFile

(

)

Definition at line 382 of file G4tgrFileIn.cc.

{
  G4bool isok = theFiles[theCurrentFile]->eof();
  if(isok)
  {
#ifdef G4VERBOSE
    if(G4tgrMessenger::GetVerboseLevel() >= 3)
    {
      G4cout << " G4tgrFileIn::EndOfFile() - EOF: " << theCurrentFile << G4endl;
    }
#endif
    --theCurrentFile;
    if(theCurrentFile != -1)  // Last file will be closed by the user
    {
      Close();
    }
  }
 
  // Only real closing if all files are closed
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 3)
  {
    G4cout << " G4tgrFileIn::EndOfFile() - EOF: " << isok << " "
           << theCurrentFile << G4endl;
  }
#endif
  if(theCurrentFile != -1)
  {
    return false;
  }
  else
  {
    return isok;
  }
}

References Close(), G4cout, G4endl, G4tgrMessenger::GetVerboseLevel(), theCurrentFile, and theFiles.

Referenced by GetWordsInLine().

ErrorInLine()

void G4tgrFileIn::ErrorInLine

(

)

Definition at line 375 of file G4tgrFileIn.cc.

{
  G4cerr << "!! EXITING: ERROR IN LINE No " << theLineNo[theCurrentFile]
         << " file: " << theNames[theCurrentFile] << " : ";
}

References G4cerr, theCurrentFile, theLineNo, and theNames.

Referenced by GetWordsInLine().

GetInstance()

G4tgrFileIn & G4tgrFileIn::GetInstance ( const G4String &  name )

static

Definition at line 68 of file G4tgrFileIn.cc.

{
  if(theInstances == nullptr)
  {
    theInstances = new std::vector<G4tgrFileIn*>;
  }
 
  std::vector<G4tgrFileIn*>::const_iterator vfcite;
  for(vfcite = theInstances->cbegin(); vfcite != theInstances->cend(); ++vfcite)
  {
    if((*vfcite)->GetName() == filename)
    {
      return *(*vfcite);
    }
  }
 
  G4tgrFileIn* instance = nullptr;
  if(vfcite == theInstances->cend())
  {
    instance = new G4tgrFileIn(filename);
 
    instance->theCurrentFile = -1;
    instance->OpenNewFile(filename.c_str());
 
    theInstances->push_back(instance);
  }
 
  return *instance;
}

References G4tgrFileIn(), OpenNewFile(), theCurrentFile, and theInstances.

Referenced by GetInstanceOpened(), and G4tgrFileReader::ReadFiles().

GetInstanceOpened()

G4tgrFileIn & G4tgrFileIn::GetInstanceOpened ( const G4String &  name )

static

Definition at line 120 of file G4tgrFileIn.cc.

{
  G4tgrFileIn& filein = G4tgrFileIn::GetInstance(filename);
  if(filein.GetName() != filename)
  {
    G4String ErrMessage = "File not opened yet: " + filename;
    G4Exception("G4tgrFileIn::GetInstanceOpened()", "InvalidInput",
                FatalException, ErrMessage);
  }
  else
  {
    return filein;
  }
  return filein;  // to avoid compilation warnings
}

References FatalException, G4Exception(), GetInstance(), and GetName().

GetName()

const G4String & G4tgrFileIn::GetName ( )

inline

Definition at line 64 of file G4tgrFileIn.hh.

{ return theName; }

References theName.

Referenced by GetInstanceOpened().

GetWordsInLine()

G4int G4tgrFileIn::GetWordsInLine

(

std::vector< G4String > &

wl

)

Definition at line 137 of file G4tgrFileIn.cc.

{
  G4int isok = 1;
 
  //---------- Read a line of file:
  //           NOTE: cannot be read with a istream_iterator,
  //           because it uses G4cout, and then doesn't read '\n'
  //----- Clear wordlist
  G4int wsiz = wordlist.size();
  G4int ii;
  for(ii = 0; ii < wsiz; ++ii)
  {
    wordlist.pop_back();
  }
 
  //---------- Loop lines while there is an ending '\' or line is blank
  const G4int NMAXLIN = 1000;
  char ltemp[NMAXLIN];  // there won't be lines longer than NMAXLIN characters
  for(;;)
  {
    (theLineNo[theCurrentFile])++;
    for(ii = 0; ii < NMAXLIN; ++ii)
    {
      ltemp[ii] = ' ';
    }
    theFiles[theCurrentFile]->getline(ltemp, NMAXLIN);
 
    //---------- Check for lines longer than NMAXLIN character
    for(ii = 0; ii < NMAXLIN; ++ii)
    {
      if(ltemp[ii] == '\0')
      {
        break;
      }
    }
    if(ii == NMAXLIN - 1)
    {
      ErrorInLine();
      G4String ErrMessage = "Too long line. Please split it " +
                            G4String("putting a '\\' at the end!");
      G4Exception("G4tgrFileIn::GetWordsInLine()", "InvalidInput",
                  FatalException, ErrMessage);
    }
 
    //---------- End of file
    if(EndOfFile())
    {
      return 0;
    }
 
    //---------- Convert line read to istrstream to split it in words
    std::istringstream istr_line(ltemp);
 
    //--------- Count how many words are there in ltemp
    //          this shouln't be needed, but SUN compiler has problems...
    G4int NoWords = 0;
    char* tt      = ltemp;
 
    G4String stemp(ltemp);
    do
    {
      if(*tt != ' ' && *(tt) != '\0')
      {
        if(tt == ltemp)
        {
          ++NoWords;
#ifdef G4VERBOSE
          if(G4tgrMessenger::GetVerboseLevel() >= 3)
          {
            G4cout << "G4tgrFileIn::GetWordsInLine() - NoWords" << NoWords
                   << ltemp << G4endl;
          }
#endif
        }
        else if(*(tt - 1) == ' ' || *(tt - 1) == '\015' || *(tt - 1) == '\t')
        {
          ++NoWords;
#ifdef G4VERBOSE
          if(G4tgrMessenger::GetVerboseLevel() >= 3)
          {
            G4cout << "G4tgrFileIn::GetWordsInLine() - NoWords" << NoWords
                   << ltemp << G4endl;
          }
#endif
        }
      }
      ++tt;
    } while((*tt != '\0') && (stemp.length() != 0));
 
    if(stemp.length() == 0)
    {
      NoWords = 0;
    }
 
    //--------- Read words from istr_line and write them into wordlist
    for(ii = 0; ii < NoWords; ++ii)
    {
      stemp = "";
      istr_line >> stemp;
      if(stemp.length() == 0)
      {
        break;
      }
      G4int comment = stemp.find(G4String("//"));
#ifdef G4VERBOSE
      if(G4tgrMessenger::GetVerboseLevel() >= 3)
      {
        G4cout << "!!!COMMENT" << comment << stemp.c_str() << G4endl;
      }
#endif
      if(comment == 0)
      {
        break;
      }
      else if(comment > 0)
      {
        stemp = stemp.substr(0, comment);
        wordlist.push_back(stemp);
        break;
      }
      wordlist.push_back(stemp);
    }
 
    // These two algorithms should be the more STL-like way, but they don't
    // work for files whose lines end without '\015'=TAB (STL problem: doesn't
    // find end of string??):
    // istream_iterator<G4String, ptrdiff_t> G4String_iter(istr_line);
    // istream_iterator<G4String, ptrdiff_t> eosl;
    // copy(G4String_iter, eosl, back_inserter(wordlist));
    // typedef istream_iterator<G4String, ptrdiff_t> G4String_iter;
    // copy(G4String_iter(istr_line), G4String_iter(), back_inserter(wordlist));
 
    if(wordlist.size() != 0)
    {
      if((*(wordlist.end() - 1)).compare("\\") == 0)  // use '\' to mark
      {                                               // continuing line
        wordlist.pop_back();
      }
      else
      {
        break;
      }
    }
  }
 
  //--------- A pair of double quotes delimits a word, therefore, look for the
  //          case where there is more than one word between two double quotes
  std::vector<G4String> wordlist2;
  G4String wordq      = "";
  unsigned int imerge = 0;
  for(std::size_t jj = 0; jj < wordlist.size(); ++jj)
  {
    if(wordlist[jj].substr(0, 1) == "\"")
    {
      imerge = 1;
    }
    if(wordlist[jj][wordlist[jj].size() - 1] == '\"')
    {
      if(imerge != 1)
      {
        G4String err1 = " word with trailing '\"' while there is no";
        G4String err2 = " previous word with leading '\"' in line ";
        G4String err  = err1 + err2;
        DumpException(err);
      }
      imerge = 2;
    }
    if(imerge == 0)
    {
      wordlist2.push_back(wordlist[jj]);
    }
    else if(imerge == 1)
    {
      if(wordq == "")
      {
        wordq.append(wordlist[jj].substr(1, wordlist[jj].size()));
      }
      else
      {
        wordq.append(wordlist[jj].substr(0, wordlist[jj].size()));
      }
      wordq.append(" ");
    }
    else if(imerge == 2)
    {
      if(wordq == "")
      {
        wordq.append(wordlist[jj].substr(1, wordlist[jj].size() - 2));
      }
      else
      {
        wordq.append(wordlist[jj].substr(0, wordlist[jj].size() - 1));
      }
      wordlist2.push_back(wordq);
      wordq  = "";
      imerge = 0;
    }
  }
  if(imerge == 1)
  {
    G4String err1 = " word with leading '\"' in line while there is no";
    G4String err2 = " later word with trailing '\"' in line ";
    G4String err  = err1 + err2;
    DumpException(err);
  }
 
  wordlist = wordlist2;
 
  // Or why not like this (?):
  // typedef std::istream_iterator<G4String, ptrdiff_t> string_iter;
  // std::copy(string_iter(istr_line), string_iter(), back_inserter(wordlist));
 
  // check if including a new file
  if(wordlist[0] == "#include")
  {
    if(wordlist.size() != 2)
    {
      ErrorInLine();
      G4String ErrMessage =
        "'#include' should have as second argument, the filename !";
      G4Exception("G4tgrFileIn::GetWordsInLine()", "InvalidInput",
                  FatalException, ErrMessage);
    }
 
#ifdef G4VERBOSE
    if(G4tgrMessenger::GetVerboseLevel() >= 3)
    {
      G4cout << " G4tgrFileIn::GetWordsInLine() - Include found !" << G4endl;
    }
#endif
    OpenNewFile(wordlist[1].c_str());
    isok = GetWordsInLine(wordlist);
  }
 
  return isok;
}

References DumpException(), EndOfFile(), ErrorInLine(), FatalException, G4cout, G4endl, G4Exception(), G4tgrMessenger::GetVerboseLevel(), GetWordsInLine(), OpenNewFile(), theCurrentFile, theFiles, and theLineNo.

Referenced by GetWordsInLine(), and G4tgrFileReader::ReadFiles().

Nline()

G4int G4tgrFileIn::Nline ( )

inline

Definition at line 62 of file G4tgrFileIn.hh.

{ return theLineNo[theCurrentFile]; }

References theCurrentFile, and theLineNo.

OpenNewFile()

void G4tgrFileIn::OpenNewFile

(

const char *

filename

)

Definition at line 99 of file G4tgrFileIn.cc.

{
  ++theCurrentFile;
  std::ifstream* fin = new std::ifstream(filename);
  theFiles.push_back(fin);
 
  theLineNo.push_back(0);
 
  theNames.push_back(filename);
 
#ifndef OS_SUN_4_2
  if(!fin->is_open())
  {
    G4String ErrMessage = "Input file does not exist: " + G4String(filename);
    G4Exception("G4tgrFileIn::OpenNewFile()", "InvalidInput", FatalException,
                ErrMessage);
  }
#endif
}

References FatalException, G4Exception(), theCurrentFile, theFiles, theLineNo, and theNames.

Referenced by GetInstance(), and GetWordsInLine().

Field Documentation

theCurrentFile

G4int G4tgrFileIn::theCurrentFile = -1

private

Definition at line 84 of file G4tgrFileIn.hh.

Referenced by Close(), DumpException(), EndOfFile(), ErrorInLine(), GetInstance(), GetWordsInLine(), Nline(), and OpenNewFile().

theFiles

std::vector<std::ifstream*> G4tgrFileIn::theFiles

private

Definition at line 77 of file G4tgrFileIn.hh.

Referenced by Close(), EndOfFile(), GetWordsInLine(), and OpenNewFile().

theInstances

G4ThreadLocal std::vector< G4tgrFileIn * > * G4tgrFileIn::theInstances = nullptr

staticprivate

Definition at line 87 of file G4tgrFileIn.hh.

Referenced by G4tgrFileIn(), GetInstance(), and ~G4tgrFileIn().

theLineNo

std::vector<G4int> G4tgrFileIn::theLineNo

private

Definition at line 79 of file G4tgrFileIn.hh.

Referenced by DumpException(), ErrorInLine(), GetWordsInLine(), Nline(), and OpenNewFile().

theName

G4String G4tgrFileIn::theName = ""

private

Definition at line 90 of file G4tgrFileIn.hh.

Referenced by DumpException(), and GetName().

theNames

std::vector<G4String> G4tgrFileIn::theNames

private

Definition at line 82 of file G4tgrFileIn.hh.

Referenced by ErrorInLine(), and OpenNewFile().

---

The documentation for this class was generated from the following files:

• source/persistency/ascii/include/G4tgrFileIn.hh
• source/persistency/ascii/src/G4tgrFileIn.cc