---

dbf.h

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/
//

#ifndef DBF_H
#define DBF_H

#ifndef __CTIME__
#include <ctime>
#endif
#ifndef __FSTREAM__
#include <fstream>
#endif
#ifndef __MAP__
#include <map>
#endif


#ifndef ERR_H
#include "Err.h"
#endif
#ifndef SMARTPTR_H
#include "smartptr.h"
#endif


namespace rs {

    namespace dbf {

        // --------------------------------------------------------------------------------
        //     class DBF_EntryDeclaration
        // --------------------------------------------------------------------------------

        class DBF_EntryDeclaration {
        private:
            std::string name;
            char type;
            char xtra[4];
            unsigned char fieldlen;
            char right;
            unsigned offset; // in record
            unsigned index; // index of field in record

        public:
            DBF_EntryDeclaration(unsigned char firstChar, std::istream& in, unsigned& offset_in_record, unsigned& index_);
            virtual ~DBF_EntryDeclaration() {}

            const std::string& Name() const { return name; }
            unsigned Fieldlen() const { return fieldlen; }
            unsigned Offset() const { return offset; }
            unsigned Index() const { return index; }

            bool is_numeric() const { return type=='N'; }
            bool is_string() const { return type=='C'; }

            void dump(std::ostream& out) const;
            DECLARE_STREAM_OP(DBF_EntryDeclaration);

            bool operator<(const DBF_EntryDeclaration& other) const { return name<other.name; }
        };

        typedef SmartPtr<DBF_EntryDeclaration> DBF_EntryDeclarationPtr;
        typedef std::map<std::string, DBF_EntryDeclarationPtr> DBF_EntryDeclarationList;

        // --------------------------------------------------
        //      class DBF_Reader : rs_boost::noncopyable
        // --------------------------------------------------
        class DBF_Reader : rs_boost::noncopyable {
        private:
            std::string filename;
            std::ifstream in;

            struct tm created;
            unsigned no_of_records;
            unsigned length_of_header;
            unsigned record_size;

            DBF_EntryDeclarationList entryTypes;

            unsigned current_record;
            char *current_record_data;

            void read_record(unsigned record_number) {
                if (record_number!=current_record) {
                    in.seekg(length_of_header+record_number*record_size+1);
                    in.read(current_record_data, record_size);
                    current_record = record_number;
                }
            }

        public:
            DBF_Reader(const std::string& filename_);
            virtual ~DBF_Reader() { delete current_record_data; }

            void dumpEntryDefinition(std::ostream& out) const;

            unsigned Fields() const { return entryTypes.size(); }

            const std::string& FieldName(unsigned num) const;

            unsigned Records() const { return no_of_records; }

            bool nextRecord() {
                if (current_record==no_of_records-1) return false;
                read_record(current_record+1);
                return true;
            }

            bool gotoRecord(unsigned index) {
                if (index>=no_of_records) return false;
                read_record(index);
                return true;
            }

            std::string FieldContent(const std::string& fieldName, bool crop=true) const;
        };
    };
};

#else
#error dbf.h included twice
#endif // DBF_H

---

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

(C) 2000-2002