DBFParser.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/BaseValues.h>
#include <NDEVR/File.h>
#include <NDEVR/Buffer.h>
#include <fstream>
#include <vector>
namespace NDEVR
{
    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);
        uint04 recordCount() const { return stHeader.uNumRecords; }
        template<class t_type>
        Buffer<t_type> readColumn(const StringView& column)
        {
            uint04 index = Constant<uint04>::Invalid;
            uint04 row_skip_size = 0;
            uint04 final_offset = 0;
            for (uint04 i = 0; i < columns.size(); ++i)
            {
                if (column == columns[i].archName)
                {
                    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; 
        uint04 m_data_start; 
        uint04 szRowSize; 
        uint04 szLargestFieldSize; 
    };
}