file.hpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2019  Erik Haenel et al.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
#ifndef NUMERE_FILE_HPP
#define NUMERE_FILE_HPP
 
#include <string>
#include <fstream>
#include <cmath>
#include <vector>
#include <utility>
 
#include "../utils/zip++.hpp"
#include "../utils/stringtools.hpp"
#include "../ui/error.hpp"
#include "../datamanagement/tablecolumn.hpp"
#include "filesystem.hpp"
 
namespace NumeRe
{
    struct FileHeaderInfo
    {
        std::string sFileExtension;
        std::string sFileName;
        std::string sTableName;
        std::string sComment;
        long long int nRows;
        long long int nCols;
        long int versionMajor;
        long int versionMinor;
        long int versionBuild;
        float fileVersion;
        __time64_t timeStamp;
 
        FileHeaderInfo() : sFileExtension(), sFileName(), sTableName(), sComment(), nRows(0), nCols(0), versionMajor(-1), versionMinor(-1), versionBuild(-1), timeStamp(0) {}
    };
 
 
    class GenericFile : public FileSystem
    {
        protected:
            std::fstream fFileStream;
            std::string sFileExtension;
            std::string sFileName;
            std::string sTableName;
            std::string sComment;
            long long int nRows;
            long long int nCols;
            unsigned short nPrecFields;
 
            // Flag for using external data, i.e. data, which won't be deleted
            // by this class upon calling "clearStorage()" or the destructor
            bool useExternalData;
            std::ios::openmode openMode;
 
            // The main data table
            TableColumnArray* fileData;
 
            void open(std::ios::openmode mode)
            {
                if (fFileStream.is_open())
                    fFileStream.close();
 
                fFileStream.open(sFileName.c_str(), mode);
 
                if (!fFileStream.good())
                    throw SyntaxError(SyntaxError::CANNOT_READ_FILE, sFileName, SyntaxError::invalid_position, sFileName);
 
                openMode = mode;
            }
 
            void stripTrailingSpaces(std::string& _sToStrip)
            {
                if (_sToStrip.find_first_not_of(" \t") != std::string::npos)
                    _sToStrip.erase(_sToStrip.find_last_not_of(" \t")+1);
            }
 
            void replaceDecimalSign(std::string& _sToReplace)
            {
                for (size_t i = 0; i < _sToReplace.length(); i++)
                {
                    if (_sToReplace[i] == ',')
                        _sToReplace[i] = '.';
                }
            }
 
            void replaceTabSign(std::string& _sToReplace, bool bAddPlaceholders = false)
            {
                bool bKeepColumns = false;
 
                // Determine, if columns shall be kept (automatic heuristics)
                if (!bAddPlaceholders && _sToReplace.find(' ') == std::string::npos)
                {
                    bKeepColumns = true;
 
                    if (_sToReplace[0] == '\t')
                        _sToReplace.insert(0, "---");
                }
 
                for (size_t i = 0; i < _sToReplace.length(); i++)
                {
                    if (_sToReplace[i] == '\t')
                    {
                        _sToReplace.replace(i, 1, "  ");
 
                        // Shall "empty cells" be added?
                        if (bAddPlaceholders)
                        {
                            // Insert underscores as empty cells
                            if (!i)
                                _sToReplace.insert(0, 1, '_');
                            else if (_sToReplace[i-1] == ' ')
                                _sToReplace.insert(i, 1, '_');
 
                            if (i+2 == _sToReplace.length())
                                _sToReplace += "_";
                        }
 
                        // Shall empty cells be kept (determined by heuristic)
                        if (bKeepColumns && (i+2 == _sToReplace.length() || _sToReplace[i+2] == '\t'))
                            _sToReplace.insert(i + 2, "---");
                    }
                }
 
                // Transform single whitespaces into special characters,
                // which will hide them from the tokenizer. Do this only,
                // if there are also locations with multiple whitespaces
                if (bAddPlaceholders && _sToReplace.find("  ") != std::string::npos)
                {
                    for (size_t i = 1+(_sToReplace.front() == '#'); i < _sToReplace.length()-1; i++)
                    {
                        if (_sToReplace[i] == ' ' && _sToReplace[i-1] != ' ' && _sToReplace[i+1] != ' ')
                            _sToReplace[i] = '\1';
                    }
                }
            }
 
            std::pair<size_t, size_t> calculateCellExtents(const std::string& sContents)
            {
                // Prepare the std::pair<> to contain the extents of the cell.
                // (One line is the minimal value)
                std::pair<size_t, size_t> pCellExtents(0u, 1u);
                size_t nLastLineBreak = 0;
 
                // Search for linebreak characters
                for (size_t i = 0; i < sContents.length(); i++)
                {
                    // Linebreak character found?
                    if (sContents[i] == '\n')
                    {
                        // Increment the number of lines
                        pCellExtents.second++;
 
                        // Use the maximal number of characters per line
                        // as the first column
                        if (i - nLastLineBreak > pCellExtents.first)
                            pCellExtents.first = i - nLastLineBreak;
 
                        nLastLineBreak = i;
                    }
                    /*else if (sContents.substr(i, 2) == "\\n")
                    {
                        // Increment the number of lines
                        pCellExtents.second++;
 
                        // Use the maximal number of characters per line
                        // as the first column
                        if (i - nLastLineBreak > pCellExtents.first)
                            pCellExtents.first = i - nLastLineBreak;
 
                        nLastLineBreak = i+1;
                    }*/
                }
 
                // Examine the last part of the string, which won't be
                // detected by the for loop
                if (sContents.length() - nLastLineBreak > pCellExtents.first)
                    pCellExtents.first = sContents.length() - nLastLineBreak;
 
                return pCellExtents;
            }
 
            std::string getLineFromHead(long long int nCol, size_t nLineNumber)
            {
                size_t nLastLineBreak = 0u;
 
                if (!fileData->at(nCol))
                {
                    if (!nLineNumber)
                        return TableColumn::getDefaultColumnHead(nCol);
 
                    return " ";
                }
 
                std::string sHeadLine = fileData->at(nCol)->m_sHeadLine;
 
                // Search the selected part
                for (size_t i = 0; i < sHeadLine.length(); i++)
                {
                    // Linebreak character found?
                    if (sHeadLine[i] == '\n')
                    {
                        // If this is the correct line number, return
                        // the corresponding substring
                        if (!nLineNumber)
                            return sHeadLine.substr(nLastLineBreak, i - nLastLineBreak);
 
                        // Decrement the line number and store the
                        // position of the current line break
                        nLineNumber--;
                        nLastLineBreak = i+1;
                    }
                    /*else if (sHeadLine.substr(i, 2) == "\\n")
                    {
                        // If this is the correct line number, return
                        // the corresponding substring
                        if (!nLineNumber)
                            return sHeadLine.substr(nLastLineBreak, i - nLastLineBreak);
 
                        // Decrement the line number and store the
                        // position of the current line break
                        nLineNumber--;
                        nLastLineBreak = i+2;
                    }*/
                }
 
                // Catch the last part of the string, which is not found by
                // the for loop
                if (!nLineNumber)
                    return sHeadLine.substr(nLastLineBreak);
 
                // Not enough lines in this string, return a whitespace character
                return " ";
            }
 
            template <typename T> T readNumField()
            {
                T num;
                fFileStream.read((char*)&num, sizeof(T));
                return num;
            }
 
            std::string readStringField()
            {
                // Get the length of the field
                size_t nLength = readNumField<size_t>();
 
                // If the length is zero, return an empty string
                if (!nLength)
                    return "";
 
                // Create a character buffer with the corresponding
                // length
                char* buffer = new char[nLength];
 
                // Read the contents into the buffer
                fFileStream.read(buffer, nLength);
 
                // Copy the buffer into a string and delete the buffer
                std::string sBuffer(buffer, nLength);
                delete[] buffer;
 
                return sBuffer;
            }
 
            std::string getZipFileItem(const std::string& filename)
            {
                // Create a Zipfile class object
                Zipfile* _zip = new Zipfile();
 
                // Open the file in ZIP mode
                if (!_zip->open(sFileName))
                {
                    _zip->close();
                    delete _zip;
                    throw SyntaxError(SyntaxError::DATAFILE_NOT_EXIST, sFileName, SyntaxError::invalid_position, sFileName);
                }
 
                // Obtain the contents of the embedded file
                std::string sFileItem = _zip->getZipItem(filename);
 
                // Close the Zip file and delete the class instance
                _zip->close();
                delete _zip;
 
                return sFileItem;
            }
 
            template <typename T> T* readNumBlock(long long int& size)
            {
                // Get the number of values in the data block
                size = readNumField<long long int>();
 
                // If the size is zero, return a null pointer
                if (!size)
                    return nullptr;
 
                // Create new storage for the data
                T* data = new T[size];
 
                // Read the contents of the file into the created storager
                fFileStream.read((char*)data, sizeof(T)*size);
 
                return data;
            }
 
            template <typename T> T** readDataArray(long long int& rows, long long int& cols)
            {
                // Get the dimensions of the data block in memory
                rows = readNumField<long long int>();
                cols = readNumField<long long int>();
 
                // If one of the dimensions is zero, return a null pointer
                if (!rows || !cols)
                    return nullptr;
 
                // Prepare a new storage object for the contained data
                T** data = new T*[rows];
 
                // Create the storage for the columns during reading the
                // file and read the contents directly to memory
                for (long long int i = 0; i < rows; i++)
                {
                    data[i] = new T[cols];
                    fFileStream.read((char*)data[i], sizeof(T)*cols);
                }
 
                return data;
            }
 
            std::string* readStringBlock(long long int& size)
            {
                // Get the number of strings in the current block
                size = readNumField<long long int>();
 
                // If no strings are in the file, return a null pointer
                if (!size)
                    return nullptr;
 
                // Create an array of strings for the data in the file
                std::string* data = new std::string[size];
 
                // Read each string separately (because their length is
                // most probably independent on each other)
                for (long long int i = 0; i < size; i++)
                {
                    data[i] = readStringField();
                }
 
                return data;
            }
 
            std::vector<std::string> readTextFile(bool stripEmptyLines)
            {
                std::vector<std::string> vTextFile;
                std::string currentLine;
 
                // Read the whole file linewise
                while (!fFileStream.eof())
                {
                    std::getline(fFileStream, currentLine);
 
                    // If empty lines shall be stripped, strip
                    // trailing whitespaces first
                    if (stripEmptyLines)
                        stripTrailingSpaces(currentLine);
 
                    // If empty lines shall be stripped, store
                    // only non-empty lines
                    if (!stripEmptyLines || currentLine.length())
                        vTextFile.push_back(currentLine);
                }
 
                return vTextFile;
            }
 
            std::vector<std::string> tokenize(std::string sString, const std::string& sSeparators, bool skipEmptyTokens = false)
            {
                std::vector<std::string> vTokens;
 
                // As long as the string has a length
                while (sString.length())
                {
                    // Store the string until the first separator character
                    vTokens.push_back(sString.substr(0, sString.find_first_of(sSeparators)));
 
                    // If empty tokens shall not be stored, remove the last
                    // token again, if it is empty
                    if (skipEmptyTokens && !vTokens.back().length())
                        vTokens.pop_back();
 
                    // Erase the contents of the line including the first
                    // separator character
                    if (sString.find_first_of(sSeparators) != std::string::npos)
                        sString.erase(0, sString.find_first_of(sSeparators)+1);
                    else
                        break;
                }
 
                return vTokens;
            }
 
            template <typename T> void writeNumField(T num)
            {
                fFileStream.write((char*)&num, sizeof(T));
            }
 
            void writeStringField(const std::string& sString)
            {
                // Store the length of string as numeric value first
                writeNumField<size_t>(sString.length());
                fFileStream.write(sString.c_str(), sString.length());
            }
 
            template <typename T> void writeNumBlock(T* data, long long int size)
            {
                // Store the length of the data block first
                writeNumField<long long int>(size);
                fFileStream.write((char*)data, sizeof(T)*size);
            }
 
            template <typename T> void writeDataArray(T** data, long long int rows, long long int cols)
            {
                // Store the dimensions of the array first
                writeNumField<long long int>(rows);
                writeNumField<long long int>(cols);
 
                // Write the contents to the file in linewise fashion
                for (long long int i = 0; i < rows; i++)
                    fFileStream.write((char*)data[i], sizeof(T)*cols);
            }
 
            void writeStringBlock(std::string* data, long long int size)
            {
                // Store the number of fields first
                writeNumField<long long int>(size);
 
                // Write each field separately, because their length is
                // independent on each other
                for (long long int i = 0; i < size; i++)
                {
                    writeStringField(data[i]);
                }
            }
 
            void createStorage()
            {
                if (nCols > 0 && !fileData)
                {
                    fileData = new TableColumnArray;
                    fileData->resize(nCols);
                }
                else if (nRows < 0 || nCols < 0)
                    throw SyntaxError(SyntaxError::CANNOT_READ_FILE, sFileName, SyntaxError::invalid_position, sFileName);
            }
 
            void clearStorage()
            {
                // Only delete the storage, if it is internal data. Do
                // not delete the storage, if it is linked from an external
                // source
                if (!useExternalData && fileData)
                {
                    fileData->clear();
                    delete fileData;
                    fileData = nullptr;
                }
                else
                    fileData = nullptr;
 
                nRows = 0;
                nCols = 0;
            }
 
            template <typename T> void copyDataArray(T** from, T** to, long long int rows, long long int cols)
            {
                if (!from || !to || !rows || !cols)
                    return;
 
                for (long long int i = 0; i < rows; i++)
                {
                    for (long long int j = 0; j < cols; j++)
                        to[i][j] = from[i][j];
                }
            }
 
            void copyStringArray(std::string* from, std::string* to, long long int nElements)
            {
                if (!from || !to || !nElements)
                    return;
 
                for (long long int i = 0; i < nElements; i++)
                    to[i] = from[i];
            }
 
            template <typename T> void copyArray(T* from, T* to, long long int nElements)
            {
                if (!from || !to || !nElements)
                    return;
 
                for (long long int i = 0; i < nElements; i++)
                    to[i] = from[i];
            }
 
            bool isNumeric(const std::string& sString)
            {
                if (!sString.length())
                    return false;
 
                return isConvertible(sString, CONVTYPE_VALUE);
            }
 
            void assign(const GenericFile& file)
            {
                clearStorage();
 
                nRows = file.nRows;
                nCols = file.nCols;
                nPrecFields = file.nPrecFields;
                useExternalData = file.useExternalData;
                sFileName = file.sFileName;
                sFileExtension = file.sFileExtension;
                sTableName = file.sTableName;
                sComment = file.sComment;
 
                // Creates only the vector but leaves the
                // actual columns untouched
                createStorage();
 
                if (file.fileData && fileData)
                {
                    for (long long int col = 0; col < nCols; col++)
                        fileData->at(col).reset(file.fileData->at(col)->copy());
                }
            }
 
        public:
            // Constructor from filename
            GenericFile(const std::string& fileName) : FileSystem(), nRows(0), nCols(0), nPrecFields(7), useExternalData(false), fileData(nullptr)
            {
                // Initializes the file system from the kernel
                initializeFromKernel();
                sFileName = ValidFileName(fileName, "", false);
                sFileExtension = getFileParts(sFileName).back();
            }
 
            GenericFile(const GenericFile& file) : GenericFile(file.sFileName)
            {
                assign(file);
            }
 
            virtual ~GenericFile()
            {
                clearStorage();
 
                if (fFileStream.is_open())
                    fFileStream.close();
            }
 
            bool is_open()
            {
                return fFileStream.is_open();
            }
 
            void close()
            {
                fFileStream.close();
                clearStorage();
            }
 
            bool good()
            {
                return fFileStream.good();
            }
 
            size_t tellg()
            {
                return fFileStream.tellg();
            }
 
            size_t tellp()
            {
                return fFileStream.tellp();
            }
 
            void seekg(size_t pos)
            {
                fFileStream.seekg(pos, std::ios::beg);
            }
 
            void seekp(size_t pos)
            {
                fFileStream.seekp(pos, std::ios::beg);
            }
 
            std::string getExtension()
            {
                return sFileExtension;
            }
 
            std::string getFileName()
            {
                return sFileName;
            }
 
            std::string getTableName()
            {
                // Has the table name not been defined yet
                if (!sTableName.length())
                {
                    // Get the file name (not the whole path)
                    sTableName = getFileParts(sFileName)[2];
 
                    // Replace all non-alnum characters with underscores
                    for (size_t i = 0; i < sTableName.length(); i++)
                    {
                        if (sTableName[i] != '_' && !isalnum(sTableName[i]))
                            sTableName[i] = '_';
                    }
 
                    // If the first character is a digit, prepend an
                    // underscore
                    if (isdigit(sTableName.front()))
                        sTableName.insert(0, 1, '_');
                }
 
                return sTableName;
            }
 
            std::string getComment()
            {
                return sComment;
            }
 
            void setComment(const std::string& comment)
            {
                sComment = comment;
            }
 
            long long int getRows()
            {
                return nRows;
            }
 
            long long int getCols()
            {
                return nCols;
            }
 
            virtual FileHeaderInfo getFileHeaderInformation()
            {
                FileHeaderInfo info;
 
                info.nCols = nCols;
                info.nRows = nRows;
                info.sFileExtension = sFileExtension;
                info.sFileName = sFileName;
                info.sTableName = getTableName();
                info.sComment = sComment;
 
                return info;
            }
 
            virtual bool read() = 0;
 
            virtual bool write() = 0;
 
            GenericFile& operator=(const GenericFile& file)
            {
                assign(file);
                return *this;
            }
 
            void getData(TableColumnArray* data)
            {
                if (data && fileData)
                {
                    for (long long int col = 0; col < nCols; col++)
                    {
                        if (fileData->at(col))
                            data->at(col).reset(fileData->at(col)->copy());
                    }
                }
            }
 
            TableColumnArray* getData(long long int& rows, long long int& cols)
            {
                rows = nRows;
                cols = nCols;
 
                return fileData;
            }
 
            void setDimensions(long long int rows, long long int cols)
            {
                clearStorage();
 
                nRows = rows;
                nCols = cols;
            }
 
            void setTableName(const std::string& name)
            {
                sTableName = name;
            }
 
            void setTextfilePrecision(unsigned short nPrecision)
            {
                nPrecFields = nPrecision;
            }
 
            void addData(TableColumnArray* data, long long int rows, long long int cols)
            {
                if (!nRows && !nCols)
                {
                    nRows = rows;
                    nCols = cols;
                }
 
                createStorage();
 
                if (fileData && data)
                {
                    for (long long int col = 0; col < nCols; col++)
                       fileData->at(col).reset(data->at(col)->copy());
                }
            }
 
            void setData(TableColumnArray* data, long long int rows, long long int cols)
            {
                useExternalData = true;
 
                fileData = data;
                nRows = rows;
                nCols = cols;
            }
    };
 
 
    GenericFile* getFileByType(const std::string& filename);
 
 
    class GenericFileView
    {
        private:
            GenericFile* m_file;
 
        public:
            GenericFileView() : m_file(nullptr) {}
 
            GenericFileView(GenericFile* _file) : m_file(_file) {}
 
            void attach(GenericFile* _file)
            {
                m_file = _file;
            }
 
            GenericFile* getPtr()
            {
                return m_file;
            }
 
            long long int getCols() const
            {
                if (m_file)
                    return m_file->getCols();
 
                return 0;
            }
 
            long long int getRows() const
            {
                if (m_file)
                    return m_file->getRows();
 
                return 0;
            }
 
            mu::value_type getElement(long long int row, long long int col) const
            {
                if (m_file)
                {
                    if (row >= m_file->getRows() || col >= m_file->getCols())
                        return 0;
 
                    // dummy variable
                    long long int r,c;
                    TableColumnArray* arr = m_file->getData(r,c);
 
                    if (arr->at(col))
                        return arr->at(col)->getValue(row);
                }
 
                return mu::value_type();
            }
 
            std::string getStringElement(long long int row, long long int col) const
            {
                if (m_file)
                {
                    if (row >= m_file->getRows() || col >= m_file->getCols())
                        return 0;
 
                    // dummy variable
                    long long int r,c;
                    TableColumnArray* arr = m_file->getData(r,c);
 
                    if (arr->at(col))
                        return arr->at(col)->getValueAsInternalString(row);
                }
 
                return "";
            }
 
            std::string getColumnHead(long long int col) const
            {
                if (m_file)
                {
                    if (col >= m_file->getCols())
                        return "";
 
                    // dummy variable
                    long long int r,c;
                    TableColumnArray* arr = m_file->getData(r,c);
 
                    if (arr->at(col))
                        return arr->at(col)->m_sHeadLine;
                }
 
                return "";
            }
    };
 
 
    typedef GenericFileView FileView;
 
 
    class TextDataFile : public GenericFile
    {
        private:
            void readFile();
            void writeFile();
            void writeHeader();
            void writeTableHeads(const std::vector<size_t>& vColumnWidth, size_t nNumberOfLines);
            void writeTableContents(const std::vector<size_t>& vColumnWidth);
            void addSeparator(const std::vector<size_t>& vColumnWidth);
 
            void decodeTableHeads(std::vector<std::string>& vFileContents, long long int nComment);
            std::vector<size_t> calculateColumnWidths(size_t& nNumberOfLines);
 
        public:
            TextDataFile(const std::string& filename);
            virtual ~TextDataFile();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                writeFile();
                return true;
            }
    };
 
 
    class NumeReDataFile : public GenericFile
    {
        protected:
            bool isLegacy;
            __time64_t timeStamp;
            long int versionMajor;
            long int versionMinor;
            long int versionBuild;
            const short fileSpecVersionMajor = 4;
            const short fileSpecVersionMinor = 0;
            float fileVersionRead;
            size_t checkPos;
            size_t checkStart;
 
            void writeHeader();
            void writeDummyHeader();
            void writeFile();
            void writeColumn(const TblColPtr& col);
            void readHeader();
            void skipDummyHeader();
            void readFile();
            void readColumn(TblColPtr& col);
            void readColumnV4(TblColPtr& col);
            void readLegacyFormat();
            void* readGenericField(std::string& type, long long int& size);
            void deleteGenericData(void* data, const std::string& type);
 
        public:
            NumeReDataFile(const std::string& filename);
            NumeReDataFile(const NumeReDataFile& file);
            virtual ~NumeReDataFile();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                writeFile();
                return true;
            }
 
            NumeReDataFile& operator=(NumeReDataFile& file);
 
            void readFileInformation()
            {
                open(std::ios::in | std::ios::binary);
                readHeader();
            }
 
            __time64_t getTimeStamp()
            {
                return timeStamp;
            }
 
            virtual FileHeaderInfo getFileHeaderInformation() override
            {
                FileHeaderInfo info;
 
                info.nCols = nCols;
                info.nRows = nRows;
                info.sFileExtension = sFileExtension;
                info.sFileName = sFileName;
                info.sTableName = getTableName();
                info.sComment = sComment;
                info.versionMajor = versionMajor;
                info.versionMinor = versionMinor;
                info.versionBuild = versionBuild;
                info.fileVersion = fileVersionRead;
                info.timeStamp = timeStamp;
 
                return info;
            }
 
            std::string getVersionString();
    };
 
 
    class CacheFile : public NumeReDataFile
    {
        private:
            std::vector<size_t> vFileIndex;
            size_t nIndexPos;
 
            void reset();
            void readSome();
            void writeSome();
 
 
        public:
            CacheFile(const std::string& filename);
            virtual ~CacheFile();
 
            virtual bool read() override
            {
                readSome();
                return true;
            }
 
            virtual bool write() override
            {
                writeSome();
                return true;
            }
 
            void readCacheHeader();
            void writeCacheHeader();
 
            size_t getNumberOfTables()
            {
                return vFileIndex.size();
            }
 
            void setNumberOfTables(size_t nTables)
            {
                vFileIndex = std::vector<size_t>(nTables, 0u);
            }
 
            size_t getPosition(size_t nthTable)
            {
                if (nthTable < vFileIndex.size())
                    return vFileIndex[nthTable];
 
                return -1;
            }
    };
 
 
    class CassyLabx : public GenericFile
    {
        private:
            void readFile();
            double extractValueFromTag(const std::string& sTag);
 
        public:
            CassyLabx(const std::string& filename);
            virtual ~CassyLabx();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                // do nothing here
                return false;
            }
    };
 
 
    class CommaSeparatedValues : public GenericFile
    {
        private:
            void readFile();
            void writeFile();
            char findSeparator(const std::vector<std::string>& vTextData);
            void countColumns(const std::vector<std::string>& vTextData, char& cSep);
 
        public:
            CommaSeparatedValues(const std::string& filename);
            virtual ~CommaSeparatedValues();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                writeFile();
                return true;
            }
    };
 
 
    class LaTeXTable : public GenericFile
    {
        private:
            void writeFile();
            void writeHeader();
            void writeTableHeads();
            size_t countHeadLines();
            std::string replaceNonASCII(const std::string& sText);
            std::string formatNumber(const mu::value_type& number);
 
        public:
            LaTeXTable(const std::string& filename);
            virtual ~LaTeXTable();
 
            virtual bool read() override
            {
                // do nothing here
                return false;
            }
 
            virtual bool write() override
            {
                writeFile();
                return true;
            }
    };
 
 
    class JcampDX : public GenericFile
    {
        private:
            struct MetaData;
 
            void readFile();
            size_t readTable(std::vector<std::string>& vFileContents, size_t nTableStart, MetaData);
            void parseLabel(std::string& sLine);
            std::vector<double> parseLine(const std::string& sLine);
 
        public:
            JcampDX(const std::string& filename);
            virtual ~JcampDX();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                // do nothing
                return false;
            }
    };
 
 
    class OpenDocumentSpreadSheet : public GenericFile
    {
        private:
            void readFile();
            std::string expandLine(const std::string& sLine);
 
        public:
            OpenDocumentSpreadSheet(const std::string& filename);
            virtual ~OpenDocumentSpreadSheet();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                // do nothing
                return false;
            }
    };
 
 
    class XLSSpreadSheet : public GenericFile
    {
        private:
            void readFile();
            void writeFile();
 
        public:
            XLSSpreadSheet(const std::string& filename);
            virtual ~XLSSpreadSheet();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                writeFile();
                return true;
            }
    };
 
 
    class XLSXSpreadSheet : public GenericFile
    {
        private:
            void readFile();
            void evalIndices(const std::string& sIndices, int& nLine, int& nCol);
 
        public:
            XLSXSpreadSheet(const std::string& filename);
            virtual ~XLSXSpreadSheet();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                // do nothing
                return false;
            }
    };
 
 
    class IgorBinaryWave : public GenericFile
    {
        private:
            bool bXZSlice;
 
            void readFile();
 
        public:
            IgorBinaryWave(const std::string& filename);
            IgorBinaryWave(const IgorBinaryWave& file);
            virtual ~IgorBinaryWave();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                // do nothing
                return false;
            }
 
            IgorBinaryWave& operator=(const IgorBinaryWave& file);
 
            void useXZSlicing()
            {
                bXZSlice = true;
            }
    };
 
 
    class ZygoDat : public GenericFile
    {
        private:
            void readFile();
 
        public:
            ZygoDat(const std::string& filename);
            ZygoDat(const ZygoDat& file);
            virtual ~ZygoDat();
 
            virtual bool read() override
            {
                readFile();
                return true;
            }
 
            virtual bool write() override
            {
                return false;
            }
 
            ZygoDat& operator=(const ZygoDat& file);
        };
}
 
 
 
#endif // NUMERE_FILE_HPP