/home/pete/Work/TSE3.svn/tse3/src/tse3/file/XML.h

Go to the documentation of this file.

/*
 * @(#)file/XML.h 3.00 10 Aug 2001
 *
 * Copyright (c) 2001 Pete Goodliffe (pete@cthree.org)
 *
 * This file is part of TSE3 - the Trax Sequencer Engine version 3.00.
 *
 * This library is modifiable/redistributable under the terms of the GNU
 * General Public License.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING. If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifndef TSE3_FILE_XML_H
#define TSE3_FILE_XML_H

#include <iosfwd>
#include <iomanip>
#include <cstddef>
#include <string>
#include <map>
#include <strstream>

#include "tse3/Midi.h"

namespace TSE3
{
    class Song;
    class Progress;

    namespace File
    {

        struct XmlLoadInfo
        {
            int PPQN;

            Song *song;

            int major;

            int minor;

            bool unknownChunks;

            bool unknownData;

            size_t noChunks;

            Progress *progress;

            XmlLoadInfo();
        };


        /**********************************************************************
         * Writing XML files
         *********************************************************************/

        class XmlFileWriter
        {
            public:

                XmlFileWriter(std::ostream &out);
                ~XmlFileWriter();

                void openElement(const std::string &name);
                void closeElement();

                void element(const std::string &name, const std::string &value);
                void element(const std::string &name, const char        *value);
                void element(const std::string &name, int                value);
                void element(const std::string &name, unsigned int       value);
                void element(const std::string &name, bool               value);

                void comment(const std::string &comment);

                class AutoElement
                {
                    public:
                        AutoElement(TSE3::File::XmlFileWriter &writer,
                                    const std::string &name)
                        : _writer(writer)
                        {
                            _writer.openElement(name);
                        }
                        ~AutoElement()
                        {
                            _writer.closeElement();
                        }
                    private:
                        TSE3::File::XmlFileWriter &_writer;
                };

            private:

                void indent(std::ostream &out);

                std::ostream &out;
                int           indentLevel;

                class XmlFileWriterImpl *pimpl;
        };

        class XmlFileReader
        {
            public:

                XmlFileReader(std::istream &in);
                ~XmlFileReader();

                TSE3::Song *load();
            private:
                std::istream &in;
        };


        /**********************************************************************
         * Reading XML files
         *********************************************************************/

        class XmlElementParser;

        class XmlBlockParser
        {
            public:
                typedef void (block_handler_t)();

                XmlBlockParser();

                void add(const std::string &tag, XmlBlockParser &handler);
                void add(const std::string &tag, XmlElementParser &handler);
                void add(XmlElementParser &handler);

                void parse(std::istream &in, const std::string &tag,
                           XmlLoadInfo &info);

            private:

                void skipBlock(std::istream &in);

                std::map<std::string, XmlElementParser*>  elements;
                std::map<std::string, XmlBlockParser*>    blocks;
                XmlElementParser                         *catchAll;
        };


        class XmlElementParser
        {
            public:

                XmlElementParser() {}
                virtual ~XmlElementParser() = 0;

                virtual void parse(const std::string &data) = 0;

            private:

                XmlElementParser &operator=(const XmlElementParser &);
                XmlElementParser(const XmlElementParser &);
        };

        template<class T, class reason>
        class XmlElementParser_ReasonOnOff : public XmlElementParser
        {
            public:
                typedef void (T::*fn_t)(reason, bool);
                XmlElementParser_ReasonOnOff(T *obj, fn_t mfun, reason r)
                : obj(obj), r(r) , mfun(mfun){}
                void parse(const std::string &data)
                {
                    (obj->*mfun)(r, (data == "On" || data == "Yes"));
                }
            private:
                T      *obj;
                reason  r;
                fn_t    mfun;
        };

        template <class T>
        class XmlElementParser_Number : public XmlElementParser
        {
            public:
                typedef void (T::*fn_t)(int);
                XmlElementParser_Number(T *obj, fn_t mfun)
                : obj(obj), mfun(mfun) {}
                void parse(const std::string &data)
                {
                    int i;
                    std::istrstream si(data.c_str());
                    si >> i;
                    (obj->*mfun)(i);
                }
            private:
                T    *obj;
                fn_t  mfun;
        };

        template <class T>
        class XmlElementParser_Clock : public XmlElementParser
        {
            public:
                typedef void (T::*fn_t)(Clock);
                XmlElementParser_Clock(T *obj, fn_t mfun)
                : obj(obj), mfun(mfun) {}
                void parse(const std::string &data)
                {
                    int i;
                    std::istrstream si(data.c_str());
                    si >> i;
                    (obj->*mfun)(i);
                }
            private:
                T    *obj;
                fn_t  mfun;
        };

        template <class T>
        class XmlElementParser_String : public XmlElementParser
        {
            public:
                typedef void (T::*fn_t)(const std::string &);
                XmlElementParser_String(T *obj, fn_t mfun)
                : obj(obj), mfun(mfun) {}
                void parse(const std::string &data)
                {
                    (obj->*mfun)(data);
                }
            private:
                T    *obj;
                fn_t  mfun;
        };
    }
}

#endif

---