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
{
    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];
    };
#pragma pack(pop)
 
    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>::NaN;
            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 (isNaN(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:
        std::ifstream clFile;
 
        DbfHeader_s stHeader;
        Buffer<DbfRecord_s> columns;
        size_t m_data_start;
        size_t szRowSize;
        size_t szLargestFieldSize;
    };
}