DBFParser.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#include <NDEVR/BaseValues.h>
#include <NDEVR/File.h>
#include <NDEVR/Buffer.h>
#include <fstream>
#include <vector>
namespace NDEVR
{
    /**----------------------------------------------------------------------------
    \brief Logic for reading or writing to a database file that uses the .dbf 
        file extension
    ----------------------------------------------------------------------------*/
    class NDEVR_BASE_API DBFParser
    {
    public:
        DBFParser(const File& file);
        void DumpAll(const char* szDestFileName);
        void DumpFields(const char* szDestFileName, const char** fields, size_t numFields);
        size_t recordCount() const { return stHeader.uNumRecords; }
        template<class t_type>
        Buffer<t_type> readColumn(const String& column)
        {
            uint04 index = Constant<uint04>::Invalid;
            uint04 row_skip_size = 0;
            uint04 final_offset = 0;
            for (uint04 i = 0; i < columns.size(); ++i)
            {
                if (columns[i].archName == column)
                {
                    index = i;
                    final_offset = szRowSize - (row_skip_size + columns[i].uLength);
                    break;
                }
                row_skip_size += columns[i].uLength;
            }
            Buffer<t_type> buff;
            if (IsInvalid(index))
                return buff;
            clFile.seekg(m_data_start, std::ios_base::beg);
            buff.ensureCapacity(stHeader.uNumRecords);
            size_t uNumRecords = 0;
            String s;
            while (uNumRecords < stHeader.uNumRecords)
            {
                char deleted;
                clFile.read(&deleted, 1);
                if (deleted == 0x2A)
                {
                    clFile.seekg(szRowSize, std::ios_base::cur);
                    continue;
                }
 
                if (row_skip_size > 0)
                {
                    clFile.seekg(row_skip_size, std::ios_base::cur);
                }
                ///
                s.setSize(columns[index].uLength);
                clFile.read(s.begin(), columns[index].uLength);
                buff.add(s.trimWhiteSpace().getAs<t_type>());
 
                ///
                if (final_offset > 0)
                    clFile.seekg(final_offset, std::ios_base::cur);
 
                ++uNumRecords;
            }
            return buff;
        }
 
    private:
        struct DbfHeader_s
        {
            uint8_t iType;
            char arcLastUpdate[3];
 
            uint04 uNumRecords;
 
            uint02 uFirstRecordOffset;
            uint02 uRecordSize;
 
            char uReserved[15];
            uint01 fFlags;
            uint01 uCodePageMark;
 
            char uReserved2[2];
        };
 
#pragma pack(push)
#pragma pack(1)
        struct DbfRecord_s
        {
            char archName[11];
            char chFieldType;
 
            uint04 uDisplacement;
            uint01 uLength;
            uint01 uDecimalPlaces;
            uint01 fFlags;
 
            uint04 uNextValue;
            uint01 uStepValue;
            char uReserved[8];
        };
        struct FieldInfo_s
        {
            const DbfRecord_s& rstRecord;
            size_t szSkipSize;
 
            FieldInfo_s(const DbfRecord_s& rec) :
                rstRecord(rec),
                szSkipSize(0)
            {
            }
        };
#pragma pack(pop)
        std::ifstream clFile;
        DbfHeader_s stHeader;
        Buffer<DbfRecord_s> columns;
        size_t m_data_start;
        size_t szRowSize;
        size_t szLargestFieldSize;
    };
}