biff.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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 STARK_FORMATS_BIFF_H
#define STARK_FORMATS_BIFF_H

#include "common/array.h"
#include "common/scummsys.h"

namespace Stark {

class ArchiveReadStream;

namespace Formats {

class BiffObject;

class BiffArchive {
public:
    typedef BiffObject *(*ObjectBuilder)(uint32 type);

    BiffArchive(ArchiveReadStream *stream, ObjectBuilder objectBuilder);
    ~BiffArchive();

    Common::Array<BiffObject *> listObjects();

    template<class T>
    Common::Array<T *> listObjectsRecursive();

private:
    void read(ArchiveReadStream *stream);
    BiffObject *readObject(ArchiveReadStream *stream, BiffObject *parent);

    ObjectBuilder _objectBuilder;
    uint32 _version;

    Common::Array<BiffObject *> _rootObjects;
};

class BiffObject {
public:
    BiffObject();
    virtual ~BiffObject();

    virtual void readData(ArchiveReadStream *stream, uint32 dataLength) = 0;

    uint32 getType() const;

    template<class T>
    Common::Array<T *> listChildrenRecursive();

    void addChild(BiffObject *child);

protected:
    uint32 _type;
    uint32 _u3;
    uint32 _version;

    BiffObject *_parent;
    Common::Array<BiffObject *> _children;

    friend class BiffArchive;
};

template<class T>
Common::Array<T *> BiffArchive::listObjectsRecursive() {
    Common::Array<BiffObject *> objects = listObjects();

    Common::Array<T *> array;
    for (uint i = 0; i < objects.size(); i++) {
        array.push_back(objects[i]->listChildrenRecursive<T>());
    }

    return array;
}

template<class T>
Common::Array<T *> BiffObject::listChildrenRecursive() {
    Common::Array<T *> list;

    for (uint i = 0; i < _children.size(); i++) {
        if (_children[i]->getType() == T::TYPE) {
            // Found a matching child
            list.push_back(static_cast<T *>(_children[i]));
        }

        // Look for matching resources in the child's children
        list.push_back(_children[i]->listChildrenRecursive<T>());
    }

    return list;
}

} // End of namespace Formats
} // End of namespace Stark

#endif // STARK_FORMATS_BIFF_H