G4OrderedTable Class Reference

#include <G4OrderedTable.hh>

Inheritance diagram for G4OrderedTable:

Public Member Functions
	G4OrderedTable ()
	G4OrderedTable (size_t cap)
virtual	~G4OrderedTable ()
void	clearAndDestroy ()
G4bool	Store (const G4String &filename, G4bool ascii=false)
G4bool	Retrieve (const G4String &filename, G4bool ascii=false)

Friends
std::ostream &	operator<< (std::ostream &out, G4OrderedTable &table)

Detailed Description

Definition at line 57 of file G4OrderedTable.hh.

Constructor & Destructor Documentation

G4OrderedTable() [1/2]

G4OrderedTable::G4OrderedTable

(

)

Definition at line 43 of file G4OrderedTable.cc.

  : std::vector<G4DataVector*>()
{
}

G4OrderedTable() [2/2]

G4OrderedTable::G4OrderedTable ( size_t  cap )

explicit

Definition at line 48 of file G4OrderedTable.cc.

  : std::vector<G4DataVector*>(cap, (G4DataVector*)(0) )
{
}

~G4OrderedTable()

G4OrderedTable::~G4OrderedTable ( )

virtual

Definition at line 53 of file G4OrderedTable.cc.

{
}

Member Function Documentation

clearAndDestroy()

void G4OrderedTable::clearAndDestroy ( )

inline

Definition at line 90 of file G4OrderedTable.hh.

{
  G4DataVector* a = 0;
  while (size()>0)
  {
    a = back();
    pop_back();
    for (iterator i=begin(); i!=end(); i++)
    {
      if (*i==a)
      {
    erase(i);
    i--;
      }
    } 
    if ( a ) { delete a; }
  } 
}

Referenced by Retrieve(), and G4SandiaTable::~G4SandiaTable().

Retrieve()

G4bool G4OrderedTable::Retrieve	(	const G4String &	filename,
		G4bool	ascii = false
	)

Definition at line 110 of file G4OrderedTable.cc.

{
  std::ifstream fIn;  
  // open input file //
  if (ascii)
    { fIn.open(fileName,std::ios::in|std::ios::binary); }
  else
    { fIn.open(fileName,std::ios::in); }
 
  // check if the file has been opened successfully 
  if (!fIn)
  {
#ifdef G4VERBOSE  
    G4cerr << "G4OrderedTable::Retrieve():";
    G4cerr << " Cannot open file: " << fileName << G4endl;
#endif
    fIn.close();
    return false;
  }
 
  // clear 
  clearAndDestroy();
  
  // Number of elements
  G4int tableSize=0; 
  if (!ascii)
  {
    fIn.read((char*)(&tableSize), sizeof tableSize); 
  }
  else
  {
    fIn >> tableSize;
  }
  if (tableSize<=0)
  {
#ifdef G4VERBOSE  
    G4cerr << "G4OrderedTable::Retrieve():";
    G4cerr << " Invalid table size: " << tableSize << G4endl;
#endif
    return false;
  }
  reserve(tableSize); 
 
  // Physics Vector
  for (G4int idx=0; idx<tableSize; ++idx)
  {
    G4int vType=0;
    if (!ascii)
    {
      fIn.read( (char*)(&vType), sizeof vType); 
    }
    else
    {
      fIn >>  vType;
    }
    if (vType != G4DataVector::T_G4DataVector)
    {
#ifdef G4VERBOSE  
      G4cerr << "G4OrderedTable::Retrieve():";
      G4cerr << " Illegal Data Vector type: " << vType << " in  ";
      G4cerr << fileName << G4endl;
#endif          
      fIn.close();
      return false;
    }
 
    G4DataVector* pVec = new G4DataVector;
 
    if (! (pVec->Retrieve(fIn,ascii)) )
    {
#ifdef G4VERBOSE  
      G4cerr << "G4OrderedTable::Retrieve(): ";
      G4cerr << " Rrror in retreiving " << idx
             << "-th Physics Vector from file: ";
      G4cerr << fileName << G4endl;
#endif          
      fIn.close();
      delete pVec;
      return false;
    }
 
    // add a PhysicsVector to this OrderedTable
    push_back(pVec);
  } 
  fIn.close();
  return true;
}

Store()

G4bool G4OrderedTable::Store	(	const G4String &	filename,
		G4bool	ascii = false
	)

Definition at line 57 of file G4OrderedTable.cc.

{
  std::ofstream fOut;  
  
  // open output file //
  if (!ascii)
    { fOut.open(fileName, std::ios::out|std::ios::binary); }
  else
    { fOut.open(fileName, std::ios::out); }
 
  // check if the file has been opened successfully 
  if (!fOut)
  {
#ifdef G4VERBOSE  
    G4cerr << "G4OrderedTable::::Store():";
    G4cerr << " Cannot open file: " << fileName << G4endl;
#endif
    fOut.close();
    return false;
  }
 
 // Number of elements
  size_t tableSize = size(); 
  if (!ascii)
  {
    fOut.write( (char*)(&tableSize), sizeof tableSize); 
  }
  else
  {
    fOut << tableSize << G4endl;
  }
 
  // Data Vector
  G4int vType = G4DataVector::T_G4DataVector;
  for (G4OrderedTableIterator itr=begin(); itr!=end(); ++itr)
  {
    if (!ascii)
    {
      fOut.write( (char*)(&vType), sizeof vType); 
    }
    else
    {
      fOut << vType << G4endl;
    }
    (*itr)->Store(fOut,ascii);
  }
  fOut.close();
  return true;
}

Friends And Related Function Documentation

operator<<

std::ostream & operator<< ( std::ostream &  out, G4OrderedTable &  table  )

friend

Definition at line 199 of file G4OrderedTable.cc.

{
  // Printout Data Vector
  size_t i=0;
  for (G4OrderedTableIterator itr=right.begin(); itr!=right.end(); ++itr)
  {
    out << std::setw(8) << i << "-th Vector   ";
    out << ": Type    " << G4DataVector::T_G4DataVector << G4endl;
    out << *(*itr);
    i +=1;
  }
  out << G4endl;
  return out; 
}

---

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

• G4OrderedTable.hh
• G4OrderedTable.cc