// Thanks to Terry Jordan of SAIC at the National Energy 

// Thanks to Terry Jordan of SAIC at the National Energy

#include "vtkInformation.h"

#include "vtkCallbackCommand.h"

#include "vtkInformationVector.h"

#include "vtkErrorCode.h"

#include "vtkDataArraySelection.h"

#include "vtkStreamingDemandDrivenPipeline.h"

#include "vtkIntArray.h"

#include "vtkDirectory.h"

#include "vtkFloatArray.h"

#include "vtkPoints.h"

#include "vtkFloatArray.h"

#include "vtkCellData.h"

#include "vtkWedge.h"

#include "vtkInformation.h"

#include "vtkInformationVector.h"

#include "vtkIntArray.h"

#include "vtkMultiBlockDataSet.h"

#include "vtkObjectFactory.h"

#include "vtkPointData.h"

#include "vtkPoints.h"

#include "vtkPolyData.h"

#include "vtkPolygon.h"

#include "vtkVertex.h"

#include "vtkQuad.h"

#include "vtkSmartPointer.h"

#include "vtkSortDataArray.h"

#include "vtkStdString.h"

#include "vtkStreamingDemandDrivenPipeline.h"

#include "vtkStringArray.h"

#include "vtkMultiBlockDataSet.h"

#include "vtkVertex.h"

#include "vtkUnstructuredGridAlgorithm.h"

#include "vtkWedge.h"

#include "vtkObjectFactory.h"

#if PARAVIEW_VERSION_MAJOR >= 3 && PARAVIEW_VERSION_MINOR >= 3

#include "vtkDirectory.h"

#include "vtksys/DateStamp.h"

#endif

#include <ctype.h>

#include <sys/stat.h>

#ifdef VTK_USE_ANSI_STDLIB

#if !(defined(_WIN32) && !defined(__CYGWIN__) || defined(__LIBCATAMOUNT__))

#define VTK_IOS_NOCREATE

// for getpwnam() / getpwuid()

#else

#include <sys/types.h>

#define VTK_IOS_NOCREATE | ios::nocreate

#include <pwd.h>

// for getuid()

#include <unistd.h>

vtkCxxRevisionMacro(vtkOpenFOAMReader, "$Revision: 1.12 $");

vtkCxxRevisionMacro(vtkOpenFOAMReader, "$Revision: 1.7.2.2 $");

struct stdString

#if VTK_FOAMFILE_OMIT_CRCCHECK

uLong ZEXPORT crc32(uLong, const Bytef *, uInt)

{ return 0; }

#endif

template<typename T> class objectVector: public vtkstd::vector<T>

  vtkstd::string value;

  typedef vtkstd::vector<T> Superclass;

public:

  ~objectVector()

  {

    for(size_t arrayI = 0; arrayI < Superclass::size(); arrayI++)

      {

      if(Superclass::operator[](arrayI) != NULL)

        {

        Superclass::operator[](arrayI)->Delete();

        }

      }

  }

struct stringVector

class intArrayVector: public objectVector<vtkIntArray*> {};

class unstructuredGridVector: public objectVector<vtkUnstructuredGrid*> {};

typedef objectVector<vtkPolyData*> polyDataVector;

typedef objectVector<vtkStringArray*> stringArrayVector;

struct vtkOpenFOAMReader::intVectorVector

  vtkstd::vector< vtkstd::string > value;

private:

  vtkIntArray *body_, *indices_;

  int nElements_;

  void clear() { indices_->Delete(); body_->Delete(); }

  intVectorVector();

public:

  intVectorVector(const intVectorVector &ivv)

    : body_(vtkIntArray::New()), indices_(vtkIntArray::New()),

    nElements_(ivv.nElements_)

  {

    indices_->DeepCopy(ivv.indices_); // vtkDataArrays do not have ShallowCopy

    body_->DeepCopy(ivv.body_);

  }

  intVectorVector(const int nElements, const int bodyLength)

    : body_(vtkIntArray::New()), indices_(vtkIntArray::New()),

    nElements_(nElements)

  {

    indices_->SetNumberOfValues(nElements + 1);

    body_->SetNumberOfValues(bodyLength);

  }

  ~intVectorVector() { clear(); }

  // GetSize() returns all allocated size (Size) while GetDataSize()

  // returns actually used size (MaxId * nComponents)

  int bodySize() const { return body_->GetSize(); }

  // note that vtkIntArray::Resize() allocates (current size + new

  // size) bytes if current size < new size

  void resizeBody(const int bodyLength) { body_->Resize(bodyLength); }

  int *setIndex(const int i, const int bodyI)

    { return body_->GetPointer(*indices_->GetPointer(i) = bodyI); }

  void setValue(const int bodyI, int value) { body_->SetValue(bodyI, value); }

  const int *operator[](const int i) const

    { return body_->GetPointer(indices_->GetValue(i)); }

  int size(const int i) const

    { return indices_->GetValue(i + 1) - indices_->GetValue(i); }

  int nElements() const { return nElements_; }

struct intVector

struct vtkFoamBoundaryEntry

  vtkstd::vector< int > value;

  vtkStdString boundaryName;

  int nFaces, startFace, allBoundariesStartFace;

  bool isActive, isPhysicalBoundary;

struct intVectorVector

struct vtkOpenFOAMReader::vtkFoamBoundaryDict

  : public vtkstd::vector<vtkFoamBoundaryEntry>

  vtkstd::vector< vtkstd::vector< int > > value;

  // we need to keep the path to time directory where the current mesh

  // is read from, since boundaryDict may be accessed multiple times

  // at a timestep for patch selections

  vtkStdString timeDir;

struct faceVectorVector

//-----------------------------------------------------------------------------

// class vtkFoamError

// class for exception-carrying object

struct vtkOpenFOAMReader::vtkFoamError: public vtkStdString

  vtkstd::vector< vtkstd::vector< face > > value;

public:

  vtkFoamError(): vtkStdString() {}

  vtkFoamError(const vtkFoamError& e): vtkStdString(e) {}

  ~vtkFoamError() {}

  // a super-easy way to make use of operator<<()'s defined in

  // vtksys_ios::ostringstream class

  template <class T> vtkFoamError& operator<<(const T& t)

  { vtksys_ios::ostringstream os; os << t; operator+=(os.str()); return *this; }

vtkOpenFOAMReader::vtkOpenFOAMReader()

//-----------------------------------------------------------------------------

// class vtkFoamToken

// token class which also works as container for list types

// - a word token is treated as a string token for simplicity

// - handles only atomic types. Handling of list types are left to the

//   derived classes.

struct vtkOpenFOAMReader::vtkFoamToken

  vtkDebugMacro(<<"Constructor");

public:

  this->SetNumberOfInputPorts(0);

  enum tokenType

  {

  //INTIALIZE FILE NAME

    // undefined type

  this->FileName = NULL;

    UNDEFINED,

    // atomic types

  //VTK CLASSES

    PUNCTUATION, LABEL, SCALAR, STRING, IDENTIFIER,

  this->Points = vtkPoints::New();

    // vtkObject-derived list types

  this->CellDataArraySelection = vtkDataArraySelection::New();

    STRINGLIST, LABELLIST, SCALARLIST, VECTORLIST,

    // original list types

  //DATA COUNTS

    LABELLISTLIST, ENTRYVALUELIST, EMPTYLIST, DICTIONARY,

  this->NumFaces = 0;

    // exceptional state

  this->NumPoints = 0;

    UNIFORMLABELLIST, UNIFORMSCALARLIST,

  this->NumCells = 0;

    // error state

    ERROR

  this->TimeStepData = new stringVector;

  };

  this->Path = new stdString;

  this->PathPrefix = new stdString;

protected:

  this->PolyMeshPointsDir = new stringVector;

  tokenType type_;

  this->PolyMeshFacesDir = new stringVector;

  union

  this->BoundaryNames = new stringVector;

  {

  this->PointZoneNames = new stringVector;

    char char_;

  this->FaceZoneNames = new stringVector;

    int int_;

  this->CellZoneNames = new stringVector;

    double double_;

    vtkStdString* string_;

  this->FacePoints = new intVectorVector;

    vtkObjectBase *vtkObjectPtr_;

  this->FacesOwnerCell = new intVectorVector;

    // vtkObject-derived list types

  this->FacesNeighborCell = new intVectorVector;

    vtkIntArray *labelListPtr_;

  this->FacesOfCell = new faceVectorVector;

    vtkFloatArray *scalarListPtr_, *vectorListPtr_;

  this->SizeOfBoundary = new intVector;

    vtkStringArray *stringListPtr_;

    // original list types

  //DATA TIMES

    intVectorVector *labelListListPtr_;

  this->NumberOfTimeSteps = 0;

    vtkstd::vector<vtkFoamEntryValue*> *entryValuePtrs_;

  this->Steps = NULL;

    vtkFoamDict *dictPtr_;

  this->TimeStep = 0;

  };

  this->TimeStepRange[0] = 0;

  this->TimeStepRange[1] = 0;

  void clear()

  this->RequestInformationFlag = true;

  {

}

    if(type_ == STRING || type_ == IDENTIFIER)

      {

      delete string_;

      }

  }

  void assignData(const vtkFoamToken& value)

  {

    switch(value.type_)

      {

      case PUNCTUATION:

        char_ = value.char_;

        break;

      case LABEL:

        int_ = value.int_;

        break;

      case SCALAR:

        double_ = value.double_;

        break;

      case STRING: case IDENTIFIER:

        string_ = new vtkStdString(*value.string_);

      }

  }

public:

  vtkFoamToken(): type_(UNDEFINED) {}

  vtkFoamToken(const vtkFoamToken& value): type_(value.type_)

    { assignData(value); }

  ~vtkFoamToken() { clear(); }

  const tokenType type() const { return type_; }

  template<typename T> bool is() const;

  template<typename T> T to() const;

  const vtkStdString toString() const { return *string_; }

  const vtkStdString toIdentifier() const { return *string_; }

  void setBad() { clear(); type_ = ERROR; }

  void setIdentifier(const vtkStdString& idString)

  { operator=(idString); type_ = IDENTIFIER; }

  void operator=(const char value)

  { clear(); type_ = PUNCTUATION; char_ = value; }

  void operator=(const int value)

  { clear(); type_ = LABEL; int_ = value; }

  void operator=(const double value)

  { clear(); type_ = SCALAR; double_ = value; }

  void operator=(const char *value)

  { clear(); type_ = STRING; string_ = new vtkStdString(value); }

  void operator=(const vtkStdString& value)

  { clear(); type_ = STRING; string_ = new vtkStdString(value); }

  void operator=(const vtkFoamToken& value)

  { clear(); type_ = value.type_; assignData(value); }

  bool operator==(const char value) const

  { return type_ == PUNCTUATION && char_ == value; }

  bool operator==(const int value) const

  { return type_ == LABEL && int_ == value; }

  bool operator==(const vtkStdString& value) const

  { return type_ == STRING && *string_ == value; }

  bool operator!=(const vtkStdString& value) const

  { return type_ != STRING || *string_ != value; }

  bool operator!=(const char value) const { return !operator==(value); }

  friend vtksys_ios::ostringstream& operator<<(vtksys_ios::ostringstream& str,

    const vtkFoamToken& value)

  {

    switch(value.type())

      {

      case ERROR:

        str << "badToken (an unexpected EOF?)";

        break;

      case PUNCTUATION:

        str << value.char_;

        break;

      case LABEL:

        str << value.int_;

        break;

      case SCALAR:

        str << value.double_;

        break;

      case STRING: case IDENTIFIER:

        str << *value.string_;

        break;

      }

    return str;

  }

};

vtkOpenFOAMReader::~vtkOpenFOAMReader()

template<> inline bool vtkOpenFOAMReader::vtkFoamToken::is<int>() const

{ return type_ == LABEL; }

template<> inline bool vtkOpenFOAMReader::vtkFoamToken::is<float>() const

{ return type_ == LABEL || type_ == SCALAR; }

template<> inline bool vtkOpenFOAMReader::vtkFoamToken::is<double>() const

{ return type_ == SCALAR; }

template<> inline int vtkOpenFOAMReader::vtkFoamToken::to() const

{ return int_; }

template<> inline float vtkOpenFOAMReader::vtkFoamToken::to() const

{ return type_ == LABEL ? int_ : double_; }

template<> inline double vtkOpenFOAMReader::vtkFoamToken::to() const

{ return type_ == LABEL ? int_ : double_; }

//-----------------------------------------------------------------------------

// class vtkFoamFileStack

// list of variables that have to be saved when a file is included.

struct vtkOpenFOAMReader::vtkFoamFileStack

  vtkDebugMacro(<<"DeConstructor");

protected:

  this->Points->Delete();

  vtkStdString fileName_;

  this->CellDataArraySelection->Delete();

  FILE *file_;

  this->SetFileName(0);

  bool isCompressed_;

  delete [] this->Steps;

  z_stream z_;

  int zStatus_;

  int lineNumber_;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

  bool wasNewline_;

#endif

  delete this->TimeStepData;

  // buffer pointers. using raw pointers for performance reason.

  delete this->Path;

  unsigned char *inbuf_;

  delete this->PathPrefix;

  unsigned char *outbuf_;

  delete this->PolyMeshPointsDir;

  unsigned char *bufPtr_;

  delete this->PolyMeshFacesDir;

  unsigned char *bufEndPtr_;

  delete this->BoundaryNames;

  delete this->PointZoneNames;

  vtkFoamFileStack()

  delete this->FaceZoneNames;

    : fileName_(), file_(NULL), isCompressed_(false), zStatus_(Z_OK),

  delete this->CellZoneNames;

    lineNumber_(0),

  delete this->FacePoints;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

  delete this->FacesOwnerCell;

    wasNewline_(true),

  delete this->FacesNeighborCell;

#endif

  delete this->FacesOfCell;

    inbuf_(NULL), outbuf_(NULL), bufPtr_(NULL), bufEndPtr_(NULL)

  delete this->SizeOfBoundary;

    { z_.zalloc = Z_NULL; z_.zfree = Z_NULL; z_.opaque = Z_NULL; }

}

int vtkOpenFOAMReader::RequestData(

  void reset()

  vtkInformation *vtkNotUsed(request),

  {

  vtkInformationVector **vtkNotUsed(inputVector),

    // path_ = "";

  vtkInformationVector *outputVector)

    file_ = NULL;

{

    isCompressed_ = false;

  vtkDebugMacro(<<"Request Data");

    // zStatus_ = Z_OK;

  vtkInformation* outInfo = outputVector->GetInformationObject(0);

    z_.zalloc = Z_NULL;

  vtkMultiBlockDataSet *output = vtkMultiBlockDataSet::SafeDownCast(

    z_.zfree = Z_NULL;

    outInfo->Get(vtkMultiBlockDataSet::DATA_OBJECT()));

    z_.opaque = Z_NULL;

  if(!this->FileName)

    // lineNumber_ = 0;

    {

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

    vtkErrorMacro("FileName has to be specified!");

    wasNewline_ = true;

    return 0;

#endif

    }

  this->CreateDataSet(output);

  return 1;

}

void vtkOpenFOAMReader::PrintSelf(ostream& os, vtkIndent indent)

    inbuf_ = NULL;

{

    outbuf_ = NULL;

  vtkDebugMacro(<<"Print Self");

    // bufPtr_ = NULL;

  this->Superclass::PrintSelf(os,indent);

    // bufEndPtr_ = NULL;

  os << indent << "File Name: "

  }

     << (this->FileName ? this->FileName : "(none)") << "\n";

  os << indent << "Number Of Nodes: " << this->NumPoints << "\n";

public:

  os << indent << "Number Of Cells: " << this->NumCells << "\n";

  const vtkStdString& fileName() const { return fileName_; }

  os << indent << "Number of Time Steps: " << this->NumberOfTimeSteps << endl;

  int lineNumber() const { return lineNumber_; }

  os << indent << "TimeStepRange: " 

};

     << this->TimeStepRange[0] << " - " << this->TimeStepRange[1]

     << endl;

  os << indent << "TimeStep: " << this->TimeStep << endl;

  return;

}

int vtkOpenFOAMReader::RequestInformation(

//-----------------------------------------------------------------------------

  vtkInformation *vtkNotUsed(request),

// class vtkFoamFile

  vtkInformationVector **vtkNotUsed(inputVector),

// read and tokenize the input.

  vtkInformationVector *outputVector)

struct vtkOpenFOAMReader::vtkFoamFile: public vtkFoamFileStack

  if(!this->FileName)

public:

    {

  // #inputMode values

    vtkErrorMacro("FileName has to be specified!");

  enum inputModes { INPUT_MODE_MERGE, INPUT_MODE_OVERWRITE, INPUT_MODE_ERROR };

    return 0;

    }

  vtkDebugMacro(<<"Request Info");

  if(RequestInformationFlag)

    {

    vtkDebugMacro(<<this->FileName);

    this->Path->value.append(this->FileName);

    this->ReadControlDict();

    this->TimeStepRange[0] = 0;

    this->TimeStepRange[1] = this->NumberOfTimeSteps-1;

    this->PopulatePolyMeshDirArrays();

    outputVector->GetInformationObject(0)->Set(

      vtkStreamingDemandDrivenPipeline::TIME_STEPS(), this->Steps,

      this->NumberOfTimeSteps);

    this->RequestInformationFlag = false;

    }

  //Add scalars and vectors to metadata

private:

  //create path to current time step

  bool is13Positions_;

  vtksys_ios::stringstream tempPath;

  inputModes inputMode_;

  tempPath << this->PathPrefix->value.c_str();

  tempPath << this->Steps[this->TimeStep];

  //open the directory and get num of files

  // inclusion handling

  int numSolvers;

  vtkFoamFileStack *stack_[VTK_FOAMFILE_INCLUDE_STACK_SIZE];

  vtkDirectory * directory = vtkDirectory::New();

  int stackI_;

  int opened = directory->Open(tempPath.str().c_str());

  vtkStdString casePath_;

  if(opened)

    {

    numSolvers = directory->GetNumberOfFiles();

    }

  else

    {

    numSolvers = -1; //no dir

    }

  //clear prior timestep data

  // declare and define as private

  this->TimeStepData->value.clear();

  vtkFoamFile();

  bool inflateNext(unsigned char *buf, int requestSize);

  int nextTokenHead();

  // hacks to keep exception throwing / recursive codes out-of-line to make

  // putBack(), getc() and readExpecting() inline expandable

  void throwDuplicatedPutBackException();

  void throwUnexpectedEOFException();

  void throwUnexpectedNondigitCharExecption(const int c);

  void throwUnexpectedTokenException(const char, const int c);

  int readNext();

  //loop over all files and locate

  void putBack(const int c)

  //volScalars and volVectors

  {

  for(int j = 0; j < numSolvers; j++)

    if(--bufPtr_ < outbuf_)

    {

    const char * tempSolver = directory->GetFile(j);

    if(tempSolver != (char *)"polyMesh")

      if(tempSolver != (char *)"." && tempSolver != (char *)"..")

      throwDuplicatedPutBackException();

        {

        vtkstd::string type(this->GetDataType(tempPath.str().c_str(),

                                              tempSolver));

        if(strcmp(type.c_str(), "Scalar") == 0)

        {

          this->TimeStepData->value.push_back(vtkstd::string(tempSolver));

          this->CellDataArraySelection->AddArray(tempSolver);

          }

        else if(strcmp(type.c_str(), "Vector") == 0)

          {

          this->TimeStepData->value.push_back(vtkstd::string(tempSolver));

          this->CellDataArraySelection->AddArray(tempSolver);

          }

        }

    }

    *bufPtr_ = c;

  }

  directory->Delete();

  return 1;

}

//

// CELL METHODS

//

int vtkOpenFOAMReader::GetNumberOfCellArrays()

{

  return this->CellDataArraySelection->GetNumberOfArrays();

}

const char* vtkOpenFOAMReader::GetCellArrayName(int index)

{

  return this->CellDataArraySelection->GetArrayName(index);

}

int vtkOpenFOAMReader::GetCellArrayStatus(const char* name)

{

  return this->CellDataArraySelection->ArrayIsEnabled(name);

}

void vtkOpenFOAMReader::SetCellArrayStatus(const char* name, int status)

{

  if(status)

    {

    this->CellDataArraySelection->EnableArray(name);

    }

  else

    {

    this->CellDataArraySelection->DisableArray(name);

    }

  return;

}

void vtkOpenFOAMReader::DisableAllCellArrays()

  // get a character

{

  int getc() { return bufPtr_ == bufEndPtr_ ? readNext() : *bufPtr_++; }

  this->CellDataArraySelection->DisableAllArrays();

  return;

}

void vtkOpenFOAMReader::EnableAllCellArrays()

  vtkFoamError stackString()

{

  {

  this->CellDataArraySelection->EnableAllArrays();

    vtksys_ios::ostringstream os;

  return;

    if(stackI_ > 0)

}

      {

      os << "\n included";

// ****************************************************************************

      for(int stackI = stackI_ - 1; stackI >= 0; stackI--)

//  Method: vtkOpenFOAMReader::CombineOwnerNeigbor

        {

//

        os << " from line " << stack_[stackI]->lineNumber() << " of "

//  Purpose:

          << stack_[stackI]->fileName() << "\n";

//  add Owner faces to the faces of a cell and then add the neighor faces

        }

//

      os << ": ";

// ****************************************************************************

      }

void vtkOpenFOAMReader::CombineOwnerNeigbor()

    return vtkFoamError() << os.str();

{

  }

  vtkDebugMacro(<<"Combine owner & neighbor faces");

  //reintialize faces of the cells

  face tempFace;

  this->FacesOfCell->value.clear();

  this->FacesOfCell->value.resize(this->NumCells);

  //add owner faces to cell

  bool closeIncludedFile()

  for(int i = 0; i < (int)this->FacesOwnerCell->value.size(); i++)

  {

    {

    if(stackI_ == 0)

    for(int j = 0; j < (int)this->FacesOwnerCell->value[i].size(); j++)

      tempFace.faceIndex = this->FacesOwnerCell->value[i][j];

      return false;

      tempFace.neighborFace = false;

      this->FacesOfCell->value[i].push_back(tempFace);

    }

    clear();

    stackI_--;

    // use the default bitwise assignment operator

    vtkFoamFileStack::operator=(*stack_[stackI_]);

    delete stack_[stackI_];

    return true;

  }

  //add neighbor faces to cell

  void clear()

  for(int i = 0; i < (int)this->FacesNeighborCell->value.size(); i++)

  {

    {

    if(isCompressed_)

    for(int j = 0; j < (int)this->FacesNeighborCell->value[i].size(); j++)

      tempFace.faceIndex = this->FacesNeighborCell->value[i][j];

      inflateEnd(&z_);

      tempFace.neighborFace = true;

      this->FacesOfCell->value[i].push_back(tempFace);

// ****************************************************************************

    delete [] inbuf_;

//  Method: vtkOpenFOAMReader::MakeInternalMesh

    delete [] outbuf_;

//

    inbuf_ = outbuf_ = NULL;

//  Purpose:

//  derive cell types and create the internal mesh

//

// ****************************************************************************

vtkUnstructuredGrid * vtkOpenFOAMReader::MakeInternalMesh()

{

  vtkDebugMacro(<<"Make internal mesh");

  //initialize variables

  bool foundDup = false;

  vtkstd::vector< int > cellPoints;

  vtkstd::vector< int > tempFaces[2];

  vtkstd::vector< int > firstFace;

  int pivotPoint = 0;

  int i, j, k, l, pCount;

  int faceCount = 0;

  //Create Mesh

    if(file_ != NULL)

  vtkUnstructuredGrid *  internalMesh = vtkUnstructuredGrid::New();

      {

  //loop through each cell, derive type and insert it into the mesh

      fclose(file_);

  //hexahedron, prism, pyramid, tetrahedron, wedge&tetWedge

      file_ = NULL;

  for(i = 0; i < (int)this->FacesOfCell->value.size(); i++)  //each cell

      }

    {

    // don't reset the line number so that the last line number is

    // retained after close

    // lineNumber_ = 0;

  }

    //calculate the total points for the cell

  const vtkStdString extractPath(const vtkStdString& path) const

    //used to derive cell type

  {

    int totalPointCount = 0;

#if defined(_WIN32) && PARAVIEW_VERSION_MAJOR >= 3

    for(j = 0; j < (int)this->FacesOfCell->value[i].size(); j++)  //each face

    const vtkStdString pathFindSeparator = "/\\", pathSeparator = "\\";

#else

    const vtkStdString pathFindSeparator = "/", pathSeparator = "/";

#endif

    const size_t pos = path.find_last_of(pathFindSeparator);

    return pos == vtkStdString::npos ? vtkStdString(".") + pathSeparator

      : path.substr(0, pos + 1);

  }

public:

  vtkFoamFile(const vtkStdString& casePath)

    : vtkFoamFileStack(), is13Positions_(false), inputMode_(INPUT_MODE_ERROR),

      stackI_(0), casePath_(casePath)

    {}

  ~vtkFoamFile() { close(); }

  void setIs13Positions(const bool is13Positions)

    { is13Positions_ = is13Positions; }

  const bool getIs13Positions() const { return is13Positions_; }

  inputModes getInputMode() const { return inputMode_; }

  const vtkStdString casePath() const { return casePath_; }

  const vtkStdString filePath() const { return extractPath(fileName_); }

  vtkStdString expandPath(const vtkStdString& pathIn,

    const vtkStdString& defaultPath)

  {

    vtkStdString expandedPath;

    bool isExpanded = false, wasPathSeparator = true;

    const int nChars = pathIn.length();

    for(int charI = 0; charI < nChars;)

      {

      char c = pathIn[charI];

      switch(c)

        {

        case '$': // $-variable expansion

          {

          vtkStdString variable;

          while(++charI < nChars && (isalnum(pathIn[charI])

            || pathIn[charI] == '_'))

            {

            variable += pathIn[charI];

            }

          if(variable == "FOAM_CASE") // discard path until the variable

            {

            expandedPath = casePath_;

	    wasPathSeparator = true;

	    isExpanded = true;

            }

          else

            {

            const char *value = getenv(variable.c_str());

            if(value != NULL)

              {

              expandedPath += value;

              }

            const size_t len = expandedPath.length();

            if(len > 0)

              {

              const char c = expandedPath[len - 1];

              wasPathSeparator = (c == '/' || c == '\\');

              }

            else

              {

              wasPathSeparator = false;

              }

            }

          }

          break;

        case '~': // home directory expansion

	  // not using kwsys::SystemTools::ConvertToUnixSlashes() for

	  // a bit better handling of "~"

	  if(wasPathSeparator)

            {

            vtkStdString userName;

            while(++charI < nChars && (pathIn[charI] != '/'

              && pathIn[charI] != '\\') && pathIn[charI] != '$')

              {

              userName += pathIn[charI];

              }

            if(userName == "")

              {

	      const char *homePtr = getenv("HOME");

	      if(homePtr == NULL)

		{

#if defined(_WIN32) && !defined(__CYGWIN__) || defined(__LIBCATAMOUNT__)

		expandedPath = "";

#else

		const struct passwd *pwentry = getpwuid(getuid());

	        if(pwentry == NULL)

		  {

                  throw stackString() << "Home directory path not found";

		  }

                expandedPath = pwentry->pw_dir;

#endif

		}

	      else

		{

	        expandedPath = homePtr;

		}

              }

            else

              {

#if defined(_WIN32) && !defined(__CYGWIN__) || defined(__LIBCATAMOUNT__)

	      const char *homePtr = getenv("HOME");

              expandedPath = extractPath(homePtr ? homePtr : "") + userName;

#else

	      if(userName == "OpenFOAM")

		{

		// so far only "~/.OpenFOAM" expansion is supported

		const char *homePtr = getenv("HOME");

		if(homePtr == NULL)

		  {

		  expandedPath = "";

		  }

		else

		  {

		  expandedPath = vtkStdString(homePtr) + "/.OpenFOAM";

		  }

		}

	      else

		{

		const struct passwd *pwentry = getpwnam(userName.c_str());

	        if(pwentry == NULL)

		  {

		  throw stackString() << "Home directory for user "

                    << userName.c_str() << " not found";

		  }

                expandedPath = pwentry->pw_dir;

		}

#endif

              }

	    wasPathSeparator = false;

            isExpanded = true;

	    break;

            }

	  // fall through

        default:

	  wasPathSeparator = (c == '/' || c == '\\');

          expandedPath += c;

          charI++;

        }

      }

    if(isExpanded || expandedPath.substr(0, 1) == "/"

      || expandedPath.substr(0, 1) == "\\")

      {

      return expandedPath;

      }

    else

      totalPointCount += 

      return defaultPath + expandedPath;

        (int)this->FacePoints->

                 value[this->FacesOfCell->value[i][j].faceIndex].size();

    // using cell type - order points, create cell, & add to mesh

  void includeFile(const vtkStdString& includedFileName,

    //OFhex | vtkHexahedron

    const vtkStdString& defaultPath)

    if (totalPointCount == 24)

  {

    if(stackI_ >= VTK_FOAMFILE_INCLUDE_STACK_SIZE)

      {

      throw stackString() << "Exceeded maximum #include recursions of "

        << VTK_FOAMFILE_INCLUDE_STACK_SIZE;

      }

    // use the default bitwise copy constructor

    stack_[stackI_++] = new vtkFoamFileStack(*this);

    vtkFoamFileStack::reset();

    open(expandPath(includedFileName, defaultPath));

  }

  // the tokenizer

  // returns true if success, false if encountered EOF

  bool read(vtkFoamToken& token)

  {

    // expanded the outermost loop in nextTokenHead() for performance

    int c;

    while(isspace(c = getc())) // isspace() accepts -1 as EOF

      {

      if(c == '\n')

        {

        ++lineNumber_;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

        wasNewline_ = true;

#endif

        }

      }

    if(c == 47) // '/' == 47

      {

      putBack(c);

      c = nextTokenHead();

      }

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

    if(c != '#')

      faceCount = 0;

      wasNewline_ = false;

      }

#endif

      //get first face

    const int MAXLEN =  1024;

      for(j = 0; j <

    char buf[MAXLEN + 1];

        (int)this->FacePoints->

    int charI = 0;

                    value[this->FacesOfCell->value[i][0].faceIndex].size(); j++)

    switch(c)

        {

      {

        firstFace.push_back(this->FacePoints->value[

      case '(': case ')':

          this->FacesOfCell->value[i][0].faceIndex][j]);

        // high-priority punctuation token

        token = (char)c;

        return true;

      case '1': case '2': case '3': case '4': case '5': case '6': case '7':

      case '8': case '9': case '0': case '-':

        // undetermined number token

        do

          {

          buf[charI++] = c;

          } while(isdigit(c = getc()) && charI < MAXLEN);

        if(c != '.' && c != 'e' && c != 'E' && charI < MAXLEN && c != EOF)

          {

          // label token

          buf[charI] = '\0';

          token = static_cast<int>(strtol(buf, NULL, 10));

          putBack(c);

          return true;

          }

        // fall through

      case '.':

        // scalar token

        if(c == '.' && charI < MAXLEN)

          {

          // read decimal fraction part

          buf[charI++] = c;

          while(isdigit(c = getc()) && charI < MAXLEN)

            {

            buf[charI++] = c;

            }

          }

        if((c == 'e' || c == 'E') && charI < MAXLEN)

          {

          // read exponent part

          buf[charI++] = c;

          if(((c = getc()) == '+' || c == '-') && charI < MAXLEN)

            {

            buf[charI++] = c;

            c = getc();

            }

          while(isdigit(c) && charI < MAXLEN)

            {

            buf[charI++] = c;

            c = getc();

            }

          }

        if(charI == 1 && buf[0] == '-')

          {

          token = '-';

          putBack(c);

          return true;

          }

        buf[charI] = '\0';

        token = strtod(buf, NULL);

        putBack(c);

        break;

      case ';': case '{': case '}': case '[': case ']': case ':': case ',':

      case '=': case '+': case '*': case '/':

        // low-priority punctuation token

        token = (char)c;

        return true;

      case '"':

        {

        // string token

        bool wasEscape = false;

        while((c = getc()) != EOF && charI < MAXLEN)

          {

          if(c == '\\' && !wasEscape)

            {

            wasEscape = true;

            continue;

            }

          else if(c == '"' && !wasEscape)

            {

            break;

            }

          else if(c == '\n')

            {

            ++lineNumber_;

            if(!wasEscape)

              {

              throw stackString() << "Unescaped newline in string constant";

              }

            }

          buf[charI++] = c;

          wasEscape = false;

          }

        buf[charI] = '\0';

        token = buf;

        }

        break;

      case EOF:

        // end of file

        token.setBad();

        return false;

      case '$':

        {

        vtkFoamToken identifierToken;

        if(!read(identifierToken))

          {

          throw stackString() << "Unexpected EOF reading identifier";

          }

        if(identifierToken.type() != vtkFoamToken::STRING)

          {

          throw stackString() << "Expected a word, found " << identifierToken;

          }

        token.setIdentifier(identifierToken.toString());

        return true;

        }

      case '#':

        {

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

        // placing #-directives in the middle of a line looks like

        // valid for the genuine OF 1.5 parser

        if(!wasNewline_)

          {

          throw stackString()

            << "Encountered #-directive in the middle of a line";

          }

        wasNewline_ = false;

#endif

        // read directive

        vtkFoamToken directiveToken;

        if(!read(directiveToken))

          {

          throw stackString() << "Unexpected EOF reading directive";

          }

        if(directiveToken == "include")

          {

          vtkFoamToken fileNameToken;

          if(!read(fileNameToken))

            {

            throw stackString() << "Unexpected EOF reading filename";

            }

          includeFile(fileNameToken.toString(), extractPath(fileName_));

          }

        else if(directiveToken == "inputMode")

          {

          vtkFoamToken modeToken;

          if(!read(modeToken))

            {

            throw stackString() << "Unexpected EOF reading inputMode specifier";

            }

          if(modeToken == "merge")

            {

            inputMode_ = INPUT_MODE_MERGE;

            }

          else if(modeToken == "overwrite")

            {

            inputMode_ = INPUT_MODE_OVERWRITE;

            }

          else if(modeToken == "error" || modeToken == "default")

            {

            inputMode_ = INPUT_MODE_ERROR;

            }

          else

            {

            throw stackString() << "Expected one of inputMode specifiers "

              "(merge, overwrite, error, default), found " << modeToken;

            }

          }

        else

          {

          throw stackString() << "Unsupported directive " << directiveToken;

          }

        return read(token);

        }

      default:

        // parses as a word token, but gives the STRING type for simplicity

        int inBrace = 0;

        do

          {

          if(c == '(')

            {

            inBrace++;

            }

          else if(c == ')' && --inBrace == -1)

            {

            break;

            }

          buf[charI++] = c;

          // valid characters that constitutes a word

          // cf. src/OpenFOAM/primitives/strings/word/wordI.H

          } while((c = getc()) != EOF && !isspace(c) && c != '"' && c != '/'

          && c != ';' && c != '{' && c != '}' && charI < MAXLEN);

        buf[charI] = '\0';

        token = buf;

        putBack(c);

      }

    if(c == EOF)

      {

      throwUnexpectedEOFException();

      }

    if(charI == MAXLEN)

      {

      throw stackString() << "Exceeded maximum allowed length of " << MAXLEN

        << " chars";

      }

    return true;

  }

  void open(const vtkStdString& fileName)

  {

    // reset line number to indicate the beginning of the file when an

    // exception is thrown

    lineNumber_ = 0;

    fileName_ = fileName;

    if(file_ != NULL)

      {

      throw stackString() << "File already opened within this object";

      }

    if((file_ = fopen(fileName.c_str(), "rb")) == NULL)

      {

      throw stackString() << "Can't open";

      }

    unsigned char zMagic[2];

    if(fread(zMagic, 1, 2, file_) == 2

      && zMagic[0] == 0x1f && zMagic[1] == 0x8b)

      {

      // gzip-compressed format

      z_.avail_in = 0;

      z_.next_in = Z_NULL;

      // + 32 to automatically recognize gzip format

      if(inflateInit2(&z_, 15 + 32) == Z_OK)

        {

        isCompressed_ = true;

        inbuf_ = new unsigned char[VTK_FOAMFILE_INBUFSIZE];

        }

      else

        {

        fclose(file_);

        file_ = NULL;

        throw stackString() << "Can't init zstream " << (z_.msg ? z_.msg : "");

        }

      }

    else

      {

      // uncompressed format

      isCompressed_ = false;

      }

    rewind(file_);

    zStatus_ = Z_OK;

    outbuf_ = new unsigned char[VTK_FOAMFILE_OUTBUFSIZE + 1];

    bufPtr_ = outbuf_ + 1;

    bufEndPtr_ = bufPtr_;

    lineNumber_ = 1;

  }

  void close()

  {

    while(closeIncludedFile());

    clear();

  }

  // gzread with buffering handling

  int read(unsigned char *buf, const int len)

  {

    int readlen;

    const int buflen = bufEndPtr_ - bufPtr_;

    if(len > buflen)

      {

      memcpy(buf, bufPtr_, buflen);

      readlen = inflateNext(buf + buflen, len - buflen);

      if(readlen >= 0)

        {

        readlen += buflen;

        }

      else

        {

        if(buflen == 0) // return EOF

          {

          readlen = -1;

          }

        else

          {

          readlen = buflen;

          }

        }

      bufPtr_ = bufEndPtr_;

      }

    else

      {

      memcpy(buf, bufPtr_, len);

      bufPtr_ += len;

      readlen = len;

      }

    for(int i = 0; i < readlen; i++)

      {

      if(buf[i] == '\n')

        {

        lineNumber_++;

        }

      }

    return readlen;

  }

  void readExpecting(const char expected)

  {

    // skip prepending invalid chars

    // expanded the outermost loop in nextTokenHead() for performance

    int c;

    while(isspace(c = getc())) // isspace() accepts -1 as EOF

      {

      if(c == '\n')

        {

        ++lineNumber_;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

        wasNewline_ = true;

#endif

        }

      }

    if(c == 47) // '/' == 47

      {

      putBack(c);

      c = nextTokenHead();

      }

    if(c != expected)

      {

      throwUnexpectedTokenException(expected, c);

      }

  }

  void readExpecting(const char* str)

  {

    vtkFoamToken t;

    if(!read(t) || t != str)

      {

      throw stackString() << "Expected string \"" << str << "\", found " << t;

      }

  }

  template<class T> T readValue(); //{ return static_cast<T>(0); }

};

int vtkOpenFOAMReader::vtkFoamFile::readNext()

{

  if(!inflateNext(outbuf_ + 1, VTK_FOAMFILE_OUTBUFSIZE))

    {

    return closeIncludedFile() ? getc() : EOF;

    }

  return *bufPtr_++;

}

// specialized for reading an integer value.

// not using the standard strtol() for speed reason.

template<> int vtkOpenFOAMReader::vtkFoamFile::readValue()

{

  // skip prepending invalid chars

  // expanded the outermost loop in nextTokenHead() for performance

  int c;

  while(isspace(c = getc())) // isspace() accepts -1 as EOF

    {

    if(c == '\n')

      {

      ++lineNumber_;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

      wasNewline_ = true;

#endif

      }

    }

  if(c == 47) // '/' == 47

    {

    putBack(c);

    c = nextTokenHead();

    }

  int nonNegative = c - 45; // '-' == 45

  if(nonNegative == 0 || c == 43) // '+' == 43

    {

    c = getc();

    if(c == '\n')

      {

      ++lineNumber_;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

      wasNewline_ = true;

#endif

      }

    }

  if(!isdigit(c)) // isdigit() accepts -1 as EOF

    {

    if(c == EOF)

      {

      throwUnexpectedEOFException();

      }

    else

      {

      throwUnexpectedNondigitCharExecption(c);

      }

    }

  int num = c - 48; // '0' == 48

  while(isdigit(c = getc()))

    {

    num = 10 * num + c - 48;

    }

  if(c == EOF)

    {

    throwUnexpectedEOFException();

    }

  putBack(c);

  return nonNegative ? num : -num;

}

// extreamely simplified high-performing string to floating point

// conversion code based on

// ParaView3/VTK/Utilities/vtksqlite/vtk_sqlite3.c

template<> float vtkOpenFOAMReader::vtkFoamFile::readValue()

{

  // skip prepending invalid chars

  // expanded the outermost loop in nextTokenHead() for performance

  int c;

  while(isspace(c = getc())) // isspace() accepts -1 as EOF

    {

    if(c == '\n')

      {

      ++lineNumber_;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

      wasNewline_ = true;

#endif

      }

    }

  if(c == 47) // '/' == 47

    {

    putBack(c);

    c = nextTokenHead();

    }

  // determine sign

  int nonNegative = c - 45; // '-' == 45

  if(nonNegative == 0 || c == 43) // '+' == 43

    {

    c = getc();

    if(c == '\n')

      {

      ++lineNumber_;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

      wasNewline_ = true;

#endif

      }

    }

  if(!isdigit(c) && c != 46) // '.' == 46, isdigit() accepts EOF

    {

    throwUnexpectedNondigitCharExecption(c);

    }

  // read integer part

  double num = c - 48; // '0' == 48

  while(isdigit(c = getc()))

    {

    num = num * 10.0 + (c - 48);

    }

  // read decimal part

  if(c == 46) // '.'

    {

    double divisor = 1.0;

    while(isdigit(c = getc()))

      {

      num = num * 10.0 + (c - 48);

      divisor *= 10.0;

      }

    num /= divisor;

    }

  // read exponent part

  if(c == 69 || c == 101) // 'E' == 69, 'e' == 101

    {

    int esign = 1;

    int eval = 0;

    double scale = 1.0;

    c = getc();

    if(c == 45) // '-'

      {

      esign = -1;

      c = getc();

      }

    else if(c == 43) // '+'

      {

      c = getc();

      }

    while(isdigit(c))

      {

      eval = eval * 10 + (c - 48);

      c = getc();

      }

    // fast exponent multiplication!

    while(eval >= 64)

      {

      scale *= 1.0e+64;

      eval -= 64;

      }

    while(eval >= 16)

      {

      scale *= 1.0e+16;

      eval -= 16;

      }

    while(eval >= 4)

      {

      scale *= 1.0e+4;

      eval -= 4;

      }

    while(eval >= 1)

      {

      scale *= 1.0e+1;

      eval -= 1;

      }

    if(esign < 0)

      {

      num /= scale;

      }

    else

      {

      num *= scale;

      }

    }

  if(c == EOF)

    {

    throwUnexpectedEOFException();

    }

  putBack(c);

  return static_cast<float>(nonNegative ? num : -num);

}

// hacks to keep exception throwing code out-of-line to make

// putBack() and readExpecting() inline expandable

void vtkOpenFOAMReader::vtkFoamFile::throwUnexpectedEOFException()

{ throw stackString() << "Unexpected EOF"; }

void vtkOpenFOAMReader::vtkFoamFile::throwUnexpectedNondigitCharExecption(

  const int c)

{

  throw stackString() << "Expected a number, found a non-digit character "

    << static_cast<char>(c);

}

void vtkOpenFOAMReader::vtkFoamFile::throwUnexpectedTokenException(

  const char expected, const int c)

{

  vtkFoamError sstr;

  sstr << stackString() << "Expected punctuation token '" << expected

    << "', found ";

  if(c == EOF)

    {

    sstr << "EOF";

    }

  else

    {

    sstr << static_cast<char>(c);

    }

  throw sstr;

}

void vtkOpenFOAMReader::vtkFoamFile::throwDuplicatedPutBackException()

{ throw stackString() << "Attempted duplicated putBack()"; }

bool vtkOpenFOAMReader::vtkFoamFile::inflateNext(unsigned char *buf,

  int requestSize)

{

  int size;

  if(isCompressed_)

    {

    if(zStatus_ != Z_OK)

      {

      return false;

      }

    z_.next_out = buf;

    z_.avail_out = requestSize;

    do

      {

      if(z_.avail_in == 0)

        {

        z_.next_in = inbuf_;

        z_.avail_in = fread(inbuf_, 1, VTK_FOAMFILE_INBUFSIZE, file_);

        if(ferror(file_))

          {

          throw stackString() << "Fread failed";

          }

        }

      zStatus_ = inflate(&z_, Z_NO_FLUSH);

      if(zStatus_ == Z_STREAM_END

#if VTK_FOAMFILE_OMIT_CRCCHECK

        // the dummy CRC function causes data error when finalizing

        // so we have to proceed even when a data error is detected

        || zStatus_ == Z_DATA_ERROR

#endif

        )

        {

        break;

        }

      if(zStatus_ != Z_OK)

        {

        throw stackString() << "Inflation failed: " << (z_.msg ? z_.msg : "");

        }

      }

    while(z_.avail_out > 0);

    size = requestSize - z_.avail_out;

    }

  else

    {

    // not compressed

    size = fread(buf, 1, requestSize, file_);

    }

  if(size <= 0)

    {

    // retain the current location bufPtr_ to the end of the buffer so that

    // getc() returns EOF again when called next time

    return false;

    }

  // size > 0

  bufPtr_ = outbuf_ + 1; // reserve the first byte for getback char

  bufEndPtr_ = bufPtr_ + size;

  return true;

}

// get next semantically valid character

int vtkOpenFOAMReader::vtkFoamFile::nextTokenHead()

{

  for(;;)

    {

    int c;

    while(isspace(c = getc())) // isspace() accepts -1 as EOF

      {

      if(c == '\n')

        {

        ++lineNumber_;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

        wasNewline_ = true;

#endif

        }

      }

    if(c == '/')

      {

      if((c = getc()) == '/')

        {

        while((c = getc()) != EOF && c != '\n');

        if(c == EOF)

          {

          return c;

          }

        ++lineNumber_;

#if VTK_FOAMFILE_RECOGNIZE_LINEHEAD

        wasNewline_ = true;

#endif

        }

      else if(c == '*')

        {

        for(;;)

          {

          while((c = getc()) != EOF && c != '*')

            {

            if(c == '\n')

              {

              ++lineNumber_;

              }

            }

          if(c == EOF)

            {

            return c;

            }

          else if((c = getc()) == '/')

            {

            break;

            }

          putBack(c);

          }

        }

      else

        {

        putBack(c); // may be an EOF

        return '/';

        }

      }

    else // may be an EOF

      {

      return c;

      }

    }

}

//-----------------------------------------------------------------------------

// class vtkFoamIOobject

// holds file handle, file format, name of the object the file holds and

// type of the object.

struct vtkOpenFOAMReader::vtkFoamIOobject: public vtkFoamFile

{

public:

  enum fileFormat { UNDEFINED, ASCII, BINARY };

private:

  fileFormat format_;

  vtkStdString objectName_;

  vtkStdString headerClassName_;

  vtkFoamError e_;

  vtkFoamIOobject();

  void readHeader(); // defined later

public:

  vtkFoamIOobject(const vtkStdString& casePath)

    : vtkFoamFile(casePath), format_(UNDEFINED), e_() {}

  ~vtkFoamIOobject() { close(); }

  bool open(const vtkStdString& file)

  {

    try

      {

      vtkFoamFile::open(file);

      }

    catch(vtkFoamError& e)

      {

      e_ = e;

      return false;

      }

    try

      {

      readHeader();

      }

    catch(vtkFoamError& e)

      {

      vtkFoamFile::close();

      e_ = e;

      return false;

      }

    return true;

  }

  void close()

  {

    vtkFoamFile::close();

    format_ = UNDEFINED;

    objectName_.erase();

    headerClassName_.erase();

    e_.erase();

  }

  const fileFormat format() const { return format_; }

  const vtkStdString& className() const { return headerClassName_; }

  const vtkStdString& objectName() const { return objectName_; }

  const vtkFoamError& error() const { return e_; }

  void setError(const vtkFoamError& e) { e_ = e; }

};

//-----------------------------------------------------------------------------

// class vtkFoamEntryValue

// a class that represents a value of a dictionary entry that corresponds to

// its keyword. note that an entry can have more than one value.

struct vtkOpenFOAMReader::vtkFoamEntryValue: public vtkFoamToken

{

private:

  bool isUniform_;

  bool managed_;

  vtkFoamEntry *upperEntryPtr_;

  vtkFoamEntryValue();

  vtkObjectBase *toVTKObject() { return vtkObjectPtr_; }

  void clear();

  void readList(vtkFoamIOobject& io);

protected:

  // reads primitive int/float lists

  template <typename listT, typename primitiveT> class listTraits

  {

    listT *ptr_;

  public:

    listTraits(): ptr_(listT::New()) {}

    listT *ptr() { return ptr_; }

    void readUniformValues(vtkFoamIOobject& io, const int size)

    {

      primitiveT value = io.readValue<primitiveT>();

      for(int i = 0; i < size; i++)

	{

	ptr_->SetValue(i, value);

	}

    }

    void readAsciiList(vtkFoamIOobject& io, const int size)

    {

      for(int i = 0; i < size; i++)

        {

	ptr_->SetValue(i, io.readValue<primitiveT>());

        }

    }

    void readBinaryList(vtkFoamIOobject& io, const int size)

    {

      io.read(reinterpret_cast<unsigned char *>(ptr_->GetPointer(0)),

        size * sizeof(primitiveT));

    }

    void readValue(vtkFoamIOobject&, vtkFoamToken& currToken)

    {

      if(!currToken.is<primitiveT>())

        {

        throw vtkFoamError() << "Expected an integer or a (, found "

          << currToken;

        }

      ptr_->InsertNextValue(currToken.to<primitiveT>());

    }

  };

  // reads rank 1 lists of types vector, sphericalTensor, symmTensor

  // and tensor. if isPositions is true it reads Cloud type of data as

  // particle positions. cf. (the positions format)

  // src/lagrangian/basic/particle/particleIO.C

  template <typename listT, typename primitiveT,

    int nComponents, bool isPositions> class vectorListTraits

  {

    listT *ptr_;

  public:

    vectorListTraits(): ptr_(listT::New())

    { ptr_->SetNumberOfComponents(nComponents); }

    listT *ptr() { return ptr_; }

    void readUniformValues(vtkFoamIOobject& io, const int size)

    {

      io.readExpecting('(');

      primitiveT vectorValue[nComponents];

      for(int j = 0; j < nComponents; j++)

        {

	vectorValue[j] = io.readValue<primitiveT>();

        }

      for(int i = 0; i < size; i++)

        {

        ptr_->SetTuple(i, vectorValue);

        }

      io.readExpecting(')');

      if(isPositions)

        {

        // skip label celli

	io.readValue<int>();

        }

    }

    void readAsciiList(vtkFoamIOobject& io, const int size)

    {

      for(int i = 0; i < size; i++)

        {

        io.readExpecting('(');

        primitiveT *vectorTupleI = ptr_->GetPointer(nComponents * i);

        for(int j = 0; j < nComponents; j++)

          {

          vectorTupleI[j] = io.readValue<primitiveT>();

          }

        io.readExpecting(')');

        if(isPositions)

          {

          // skip label celli

	  io.readValue<int>();

          }

        }

    }

    void readBinaryList(vtkFoamIOobject& io, const int size)

    {

      if(isPositions) // lagrangian/positions (class Cloud)

        {

        // allocate space along with the larger 1.4 format since the

        // size must be determined at compile-time. we allocate on the

        // stack to avoid leak when an exception is thrown.

        unsigned char buffer[sizeof(double) * (nComponents + 1)

	  + 2 * sizeof(int)];

        const int nBytes = (io.getIs13Positions()

        // skip label celli

          ? sizeof(double) * nComponents + sizeof(int)

        // skip label celli, label facei and scalar stepFraction

          : sizeof(double) * (nComponents + 1) + 2 * sizeof(int));

        for(int i = 0; i < size; i++)

          {

          io.readExpecting('(');

          io.read(buffer, nBytes);

          ptr_->SetTuple(i, reinterpret_cast<double *>(buffer));

          io.readExpecting(')');

          }

	}

      else

	{

        for(int i = 0; i < size; i++)

          {

          double buffer[nComponents];

          io.read(reinterpret_cast<unsigned char *>(buffer),

	    sizeof(double) * nComponents);

          ptr_->SetTuple(i, buffer);

          }

	}

    }

    void readValue(vtkFoamIOobject& io, vtkFoamToken& currToken)

    {

      if(currToken != '(')

        {

        throw vtkFoamError() << "Expected '(', found " << currToken;

        }

      primitiveT v[nComponents];

      for(int j = 0; j < nComponents; j++)

        {

	v[j] = io.readValue<primitiveT>();

        }

      ptr_->InsertNextTuple(v);

      io.readExpecting(')');

    }

  };

public:

  vtkFoamEntryValue(vtkFoamEntry *upperEntryPtr)

    : vtkFoamToken(), isUniform_(false), managed_(true),

      upperEntryPtr_(upperEntryPtr) {}

  vtkFoamEntryValue(vtkFoamEntryValue&, vtkFoamEntry *);

  ~vtkFoamEntryValue() { clear(); }

  void setEmptyList() { clear(); isUniform_ = false; type_ = EMPTYLIST; }

  bool isUniform() const { return isUniform_; }

  void read(vtkFoamIOobject& io);

  void readDictionary(vtkFoamIOobject& io, const vtkFoamToken& firstKeyword);