G4tgrFileIn Class Reference

#include <G4tgrFileIn.hh>

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

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

Detailed Description

Definition at line 46 of file G4tgrFileIn.hh.

Constructor & Destructor Documentation

G4tgrFileIn::G4tgrFileIn

(

)

Definition at line 50 of file G4tgrFileIn.cc.

Referenced by GetInstance().

  : theCurrentFile(-1), theName("")
{
  if (!theInstances)  { theInstances = new std::vector<G4tgrFileIn*>; }
}

G4tgrFileIn::~G4tgrFileIn

(

)

Definition at line 58 of file G4tgrFileIn.cc.

{
  delete theInstances; theInstances=0;
/*
  std::vector<G4tgrFileIn*>::const_iterator vfcite;
  for( vfcite = theInstances->begin(); vfcite != theInstances->end(); vfcite++)
  {
    delete *vfcite;
  }
*/
}

Member Function Documentation

void G4tgrFileIn::Close

(

)

Definition at line 416 of file G4tgrFileIn.cc.

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

Referenced by EndOfFile().

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

  theFiles[theCurrentFile+1]->close();
  theFiles.pop_back();
}

void G4tgrFileIn::DumpException

(

const G4String &

sent

)

Definition at line 432 of file G4tgrFileIn.cc.

References G4UIcommand::ConvertToString(), FatalException, and G4Exception().

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

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

G4bool G4tgrFileIn::EndOfFile

(

)

Definition at line 377 of file G4tgrFileIn.cc.

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

Referenced by GetWordsInLine().

{
  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 0;
  }
  else
  {
    return isok;
  }
}

void G4tgrFileIn::ErrorInLine

(

)

Definition at line 368 of file G4tgrFileIn.cc.

References G4cerr.

Referenced by GetWordsInLine().

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

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

static

Definition at line 72 of file G4tgrFileIn.cc.

References G4tgrFileIn(), and OpenNewFile().

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

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

  std::vector<G4tgrFileIn*>::const_iterator vfcite;
  for( vfcite = theInstances->begin(); vfcite != theInstances->end(); vfcite++)
  {
    if( (*vfcite)->GetName() == filename)
    {
      return *(*vfcite);
    }
  }

  G4tgrFileIn* instance = 0;
  if( vfcite == theInstances->end() )
  {
    instance = new G4tgrFileIn( filename );
    
    instance->theCurrentFile = -1;
    instance->OpenNewFile( filename.c_str() );

    theInstances->push_back( instance );
  }

  return *instance;
}

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

static

Definition at line 123 of file G4tgrFileIn.cc.

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

{
  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
}

const G4String& G4tgrFileIn::GetName ( void  )

inline

Definition at line 69 of file G4tgrFileIn.hh.

Referenced by GetInstanceOpened().

{ return theName; }

G4int G4tgrFileIn::GetWordsInLine

(

std::vector< G4String > &

wl

)

Definition at line 141 of file G4tgrFileIn.cc.

References G4String::append(), DumpException(), EndOfFile(), ErrorInLine(), FatalException, G4cout, G4endl, G4Exception(), G4tgrMessenger::GetVerboseLevel(), and OpenNewFile().

Referenced by G4tgrFileReader::ReadFiles().

{
  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( 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;
}

G4int G4tgrFileIn::Nline ( )

inline

Definition at line 67 of file G4tgrFileIn.hh.

{ return theLineNo[theCurrentFile]; }

void G4tgrFileIn::OpenNewFile

(

const char *

filename

)

Definition at line 101 of file G4tgrFileIn.cc.

References FatalException, and G4Exception().

Referenced by GetInstance(), and GetWordsInLine().

{
  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
}

---

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

• G4tgrFileIn.hh
• G4tgrFileIn.cc