dbcfile.h

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef DBCFILE_H
#define DBCFILE_H
 
#include <cassert>
#include <string>
 
class DBCFile
{
public:
    DBCFile(const std::string &filename);
    ~DBCFile();
 
    // Open database. It must be openened before it can be used.
    bool open();
 
    // TODO: Add a close function?
 
    // Database exceptions
    class Exception
    {
    public:
        Exception(const std::string &message): message(message)
        { }
        virtual ~Exception()
        { }
        const std::string &getMessage() {return message;}
    private:
        std::string message;
    };
 
    //
    class NotFound: public Exception
    {
    public:
        NotFound(): Exception("Key was not found")
        { }
    };
 
    // Iteration over database
    class Iterator;
    class Record
    {
    public:
        Record& operator= (Record const& r)
        {
            file = r.file;
            offset = r.offset;
            return *this;
        }
        float getFloat(size_t field) const
        {
            assert(field < file.fieldCount);
            return *reinterpret_cast<float*>(offset + field * 4);
        }
        unsigned int getUInt(size_t field) const
        {
            assert(field < file.fieldCount);
            return *reinterpret_cast<unsigned int*>(offset + (field * 4));
        }
        int getInt(size_t field) const
        {
            assert(field < file.fieldCount);
            return *reinterpret_cast<int*>(offset + field * 4);
        }
        unsigned char getByte(size_t ofs) const
        {
            assert(ofs < file.recordSize);
            return *reinterpret_cast<unsigned char*>(offset + ofs);
        }
        char const *getString(size_t field) const
        {
            assert(field < file.fieldCount);
            size_t stringOffset = getUInt(field);
            assert(stringOffset < file.stringSize);
            //char * tmp = (char*)file.stringTable + stringOffset;
            //unsigned char * tmp2 = file.stringTable + stringOffset;
            return reinterpret_cast<char*>(file.stringTable + stringOffset);
        }
    private:
        Record(DBCFile& file, unsigned char* offset) : file(file), offset(offset) { }
        DBCFile& file;
        unsigned char* offset;
 
        friend class DBCFile;
        friend class Iterator;
    };
 
    /* Iterator that iterates over records */
    class Iterator
    {
    public:
        Iterator(DBCFile &file, unsigned char *offset):
            record(file, offset) {}
        Iterator& operator++() {
            record.offset += record.file.recordSize;
            return *this;
        }
        Record const& operator*() const { return record; }
        Record const* operator->() const {
            return &record;
        }
        bool operator==(Iterator const& b) const
        {
            return record.offset == b.record.offset;
        }
 
    private:
        Record record;
    };
 
    // Get record by id
    Record getRecord(size_t id);
    Iterator begin();
    Iterator end();
    size_t getRecordCount() const { return recordCount;}
    size_t getFieldCount() const { return fieldCount; }
 
private:
    std::string filename;
    size_t recordSize;
    size_t recordCount;
    size_t fieldCount;
    size_t stringSize;
    unsigned char *data;
    unsigned char *stringTable;
};
 
#endif