---

dbf.cpp

Go to the documentation of this file.

//
// Copyright (C) 2000
// Ralf Westram
// (Coded@ReallySoft.de)
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  Ralf Westram makes no
// representations about the suitability of this software for any
// purpose.  It is provided "as is" without express or implied warranty.
//
// This code is part of my library.
// You may find a more recent version at http://www.reallysoft.de/
//

#include <functional>
#include <algorithm>

#include <Tools.h>

#include "dbf.h"

using namespace std;
using namespace rs;
using namespace rs::dbf;
using namespace rs::err;

#if defined(DEBUG)
#define DUMP_DBF_DEFINITION
#endif // DEBUG

//  ---------------------------------------------------------------------------------------------------------------------------------------
//      DBF_EntryDeclaration::DBF_EntryDeclaration(unsigned char firstChar, istream& in, unsigned& offset_in_record, unsigned& index_)
//  ---------------------------------------------------------------------------------------------------------------------------------------
DBF_EntryDeclaration::DBF_EntryDeclaration(unsigned char firstChar, istream& in, unsigned& offset_in_record, unsigned& index_) {
#if defined(DUMP_DBF_DEFINITION)
    cout << "pos=" << int(in.tellg())-1 << ' ';
#endif // DUMP_DBF_DEFINITION
    char buf[12];
    in.read(buf+1, 10);
    buf[0] = firstChar;
    buf[11] = 0;
    name = buf;

#if defined(DUMP_DBF_DEFINITION)
    cout << "buf='" << buf << "'\n";
#endif // DUMP_DBF_DEFINITION

    in.read(&type, 1);
    in.read(xtra, 4);
    in.read(reinterpret_cast<char*>(&fieldlen), 1);
    in.read(&right, 1);

    in.ignore(14);

    offset = offset_in_record;
    offset_in_record += fieldlen;
    index = index_++;

    if (!in.good()) throw IOError("while reading DBF structure");
}

// ------------------------------------------------------------
//      inline void get_us(istream& in, unsigned char& uc)
// ------------------------------------------------------------
inline void get_us(istream& in, unsigned char& uc) {
    char c;
    in.get(c);
    uc = c;
}

// --------------------------------------------------------------------------------
//     DBF_Reader::DBF_Reader(const string& filename_)
// --------------------------------------------------------------------------------
DBF_Reader::DBF_Reader(const string& filename_)
    : filename(filename_),
      in(filename.c_str(), ios::in | ios::binary)
{
    try {
        if (!in.good()) throw IOError(filename);

        unsigned char c;
        //         in.get(c_s);            // >> c;
        get_us(in, c);
        if (c!=3 && c!=83) throw Error("Wrong filetype (not DBASE)");


        get_us(in, c); created.tm_year = c; // creation date
        get_us(in, c); created.tm_mon = c;
        get_us(in, c); created.tm_mday = c;
        created.tm_hour = 0;
        created.tm_min = 0;
        created.tm_sec = 0;
        mktime(&created);

        get_us(in, c); no_of_records = c;
        get_us(in, c); no_of_records += c*256;
        get_us(in, c); no_of_records += c*256*256;
        get_us(in, c); no_of_records += c*256*256*256;
        //in.read((char*)&no_of_records, sizeof(no_of_records));

        get_us(in, c); length_of_header = c;
        get_us(in, c); length_of_header += c*256;
        //in.read((char*)&data_offset, sizeof(data_offset));

        get_us(in, c); record_size = c;
        get_us(in, c); record_size += c*256;
        //in.read((char*)&record_size, sizeof(record_size));

#if defined(DUMP_DBF_DEFINITION)
        cout << "no_of_records=" << no_of_records << "\n";
        cout << "length_of_header=" << length_of_header << "\n";
        cout << "record_size=" << record_size << "\n";
#endif // DUMP_DBF_DEFINITION

        if (no_of_records==0) throw Error("Database is empty");

        in.ignore(2); // reserved

        get_us(in, c); if (c) throw Error("Can't lock database");
        get_us(in, c); if (c) throw Error("Database is encrypted");

        in.ignore(16); // unused/reserved

        unsigned offset = 0;
        unsigned idx = 0;
        unsigned fields = 0;

        while (1) {
            get_us(in, c);
            if (c==0x0d) break; // end of field-declarations
            DBF_EntryDeclarationPtr decl(new DBF_EntryDeclaration(c, in, offset, idx));
            entryTypes[decl->Name()] = decl;
            ++fields;
        }

#if defined(DUMP_DBF_DEFINITION)
        cout << "fields=" << fields << "\n";
#endif // DUMP_DBF_DEFINITION

//        streampos db_start(length_of_header);
//         in.ignore(20);

//         int fields = (db_start-in.tellg())/32;

//         unsigned offset = 0;
//         unsigned idx = 0;
//         for (int f=0; f<fields; ++f) {
//             DBF_EntryDeclarationPtr decl(new DBF_EntryDeclaration(in, offset, idx));
//             entryTypes[decl->Name()] = decl;
//         }

// #if defined(DUMP_DBF_DEFINITION)
//         dumpEntryDefinition(cout);
//         cout << "sum of fieldlens=" << offset << "\n";
// #endif // DUMP_DBF_DEFINITION

        current_record_data = new char[record_size];
        current_record = -1U;
        read_record(0);
    }
    catch (Error& err) {
        throw Error(string("While opening DBF '")+filename+"': "+err.get_message());
    }
}

// --------------------------------------------------------------------------------
//     void DBF_Reader::dumpEntryDefinition(ostream& out) const
// --------------------------------------------------------------------------------
void DBF_Reader::dumpEntryDefinition(ostream& out) const {
    out << "Database defines " << entryTypes.size() << " fields:\n";
    for (DBF_EntryDeclarationList::const_iterator e=entryTypes.begin(); e!=entryTypes.end(); ++e) {
        out << *(e->second);
    }
}

// --------------------------------------------------------------------------------
//     struct hasIndex
// -------------------------------------------------c-------------------------------
struct hasIndex {
    unsigned num;
    hasIndex(unsigned num_) : num(num_) {}
    bool operator()(const pair<string, DBF_EntryDeclarationPtr>& decl) { return decl.second->Index()==num; }
};

// --------------------------------------------------------------------------------
//     const string& DBF_Reader::FieldName(int num) const
// --------------------------------------------------------------------------------
const string& DBF_Reader::FieldName(unsigned num) const {
    DBF_EntryDeclarationList::const_iterator found =
        find_if(entryTypes.begin(), entryTypes.end(), hasIndex(num));

    if (found==entryTypes.end()) throw Error("Field index out of range");
    return found->second->Name();
}

// --------------------------------------------------------------------------------
//     string DBF_Reader::FieldContent(const string& fieldName, bool crop) const
// --------------------------------------------------------------------------------
string DBF_Reader::FieldContent(const string& fieldName, bool crop) const {
    DBF_EntryDeclarationList::const_iterator field = entryTypes.find(fieldName);

    if (field==entryTypes.end()) throw Error(string("Database has no field '")+fieldName+'\'');

    string result = string(current_record_data+field->second->Offset(),
                           field->second->Fieldlen());
    return crop ? str::cropString(result) : result;
}

// start of implementation of class DBF_EntryDeclaration:

// -----------------------------------------------------------------
//      void DBF_EntryDeclaration::dump(std::ostream& out) const
// -----------------------------------------------------------------
void DBF_EntryDeclaration::dump(std::ostream& out) const
{
    out << name << std::string(12-name.length(), ' ') << type
        << " size=" << Fieldlen()
        << " offset=" << Offset()
        << "\n";
}

// -end- of implementation of class DBF_EntryDeclaration.

---

Contact me in case of errors or questions. This documentation is powered by .

(C) 2000-2002