IndexFile.h

Go to the documentation of this file.

/*
   IndexFile Class
     Given an IndexFile name, provide access to the data via std::vectors.

     Index files contain lists of uint32 atom indices and are used to
     convey subset membership.

     Format is:
     byte 0 : version 1
     byte 1-4 : count of elements as binary unsigned int
     element 0 .. N
     elements : unsigned int (4 bytes) atom index counting from 0

     Version 0 was just the elements and can heuristically be
     distinguished by the initial byte being 0.  As the handful of
     index files made in that format were all placing indices in order
     with a relatively small starting value.

     The IndexFile class holds only the ifstream, filename, element
     count and version.

     Expected usage is constructor, getAllElements, destructor.

     IndexFile is a header only class, implemented via ifstream
     because that should allow portability per the standard, unlike
     the older file APIs where we have to painstakingly debug corner
     cases demarcated with ifdefs for windows and other aberrations.
*/

#ifndef INDEXFILE_H
#define INDEXFILE_H
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>

#ifdef MEM_OPT_VERSION
static_assert (sizeof(off_t) >= sizeof(uint64_t), "off_t less than 64bits not supported in MEM_OPT_VERSION");
#endif
class IndexFile {
 private:
  std::string filename;
  std::ifstream fileStream;
  unsigned int numElements;
  unsigned short version;
  bool networkEndian;
 public:
 IndexFile(std::string _filename): filename(_filename){
   version=0;
    open();
    if(fileStream.fail())
      NAMD_die("error in IndexFile::IndexFile");
  }

  ~IndexFile(){close();}
  unsigned int size(){ return numElements;}
  unsigned int getNumElements(){ return numElements;}
  std::vector<unsigned int> getAllElements()
    {
      std::vector<unsigned int> index;
      index.resize(numElements);
      fileStream.read(reinterpret_cast<char*>(&index[0]), index.size()* sizeof(unsigned int));
      //      auto print = [] (const int &n){ std::cout << n << "\n";};
      //      std::for_each(index.begin(), index.end(), print);
      if(networkEndian)
          std::for_each(index.begin(), index.end(), [] (unsigned int &n) { n = ntohl(n);});
      if(fileStream.good())
        return index;
      else
        NAMD_die("error in IndexFile::getAllElements");
    }

  void seek(off_t pos) {fileStream.seekg(pos);}

  std::vector<unsigned int> getNElements(off_t offset, size_t numElementsRange)
    {
      std::vector<unsigned int> index;
      index.resize(numElementsRange);
      seek(offset);
      fileStream.read(reinterpret_cast<char*>(&index[0]), index.size()* sizeof(unsigned int));
      if(networkEndian)
          std::for_each(index.begin(), index.end(), [] (unsigned int &n) { n = ntohl(n);});
      if(fileStream.good())
        return index;
      else
        NAMD_die("error in IndexFile::getNElements");
    }

  std::vector<unsigned int> getNElements(size_t numElements){
    return getNElements(0, numElements);
  }

  std::vector<unsigned int> getElements()
    {
      return getAllElements();
    }

  bool open()
  {
    fileStream.open(filename.c_str(), std::ios::in | std::ifstream::binary);
    // ifstream portable way to get file size
    fileStream.read(reinterpret_cast<char*>(&version), sizeof(unsigned short int));
    fileStream.seekg(0, fileStream.end);
    unsigned int lengthCheck = fileStream.tellg();
    unsigned int countedLength =0;
    fileStream.seekg(0, fileStream.beg);
    unsigned short beVersion=ntohs(version);
    if(version>=256)
      {
        if(ntohs(version)==1)
          {
            networkEndian = true;
            version = beVersion;

          }
      }
    switch (version) {
    case 0:
      numElements = lengthCheck/sizeof(unsigned int);
      break;
    case 1:
      fileStream.seekg(2, fileStream.beg); // need to seek past the version
      fileStream.read(reinterpret_cast<char*>(&numElements), sizeof(unsigned int));
      numElements = (networkEndian) ? ntohl(numElements) : numElements;     
      countedLength = (lengthCheck-sizeof(char)-sizeof(unsigned int))/sizeof(unsigned int);
      if(numElements!= countedLength)
        {
          std::string e="error in IndexFile::open mismatch in element count";
          e+=" file reports "+std::to_string(numElements)+ " counted  "+std::to_string(countedLength);
          NAMD_die(e.c_str());
        }
      break;
    default:
      NAMD_die("error in IndexFile::open unsupported version");
      break;
    }
    return(fileStream.is_open());
  }

  void close(){fileStream.close();}

};
#endif // Index