actions.h

/*
 *  actions.h
 *  
 *
 *  Created by Andreas Vox on 02.06.06.
 *  Copyright 2006 under GPL2. All rights reserved.
 *
 */


#ifndef ACTIONS_H
#define ACTIONS_H

#include <map>
#include <string>
#include "digester.h"

namespace desaxe {

class Action_body
{
protected:
    Action_body() :                     dig(NULL)  {}
    virtual ~Action_body()                         {}
    virtual void begin(const Xml_string&, Xml_attr) {} 
                                               
    virtual void end(const Xml_string&)             {}
    virtual void chars(const Xml_string&)           {}
    virtual void reset()                            {}

    Digester* dig;
private:
    int refs;
    friend class Action;
};



class Action
{
public:
    inline Digester* digester()                { return body->dig; }
    inline void setDigester(Digester* dig)     { body->dig = dig; }
    
    inline void begin(const Xml_string& tag, Xml_attr attr) 
                                               { body->begin(tag, attr); }
    inline void end(const Xml_string& tag)     { body->end(tag); }
    inline void chars(const Xml_string& data)  { body->chars(data); }

    // Handle stuff:
    Action(const Action& other)
    {
        body = other.body;
        body->refs++;
    }
    virtual ~Action()                          
    {
        if (--body->refs == 0)
            delete body;
    }
    Action& operator=(const Action& other)
    {
        if (body != other.body) {
            if (--body->refs == 0)
                delete body;
            body = other.body;
            ++body->refs;
        }
        return *this;
    }

    virtual void reset()
    {
        body->reset();
    }

protected:
    Action(Action_body* body_)
    {
        body = body_;
        body->refs = 1;
    }

    Action_body* body;

private:
    Action();  // not defined
};


class Dummy {};

template <class Body, class Arg1=Dummy, class Arg2=Dummy, class Arg3=Dummy, class Arg4=Dummy, class Arg5=Dummy>
struct MakeAction : public Action 
{
    MakeAction() : Action(new Body()) {}
    MakeAction(Arg1 a1) : Action(new Body(a1)) {}
    MakeAction(Arg1 a1, Arg2 a2) : Action(new Body(a1, a2)) {}
    MakeAction(Arg1 a1, Arg2 a2, Arg3 a3) : Action(new Body(a1, a2, a3)) {}
    MakeAction(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4) : Action(new Body(a1, a2, a3, a4)) {}
    MakeAction(Arg1 a1, Arg2 a2, Arg3 a3, Arg4 a4, Arg5 a5) : Action(new Body(a1, a2, a3, a4, a5)) {}
};



template<class Type>
class Generator_body : public Action_body
{
public:
    virtual Type* eval(Digester* dig_, const Xml_string& tag, Xml_attr attr)
    {
        dig = dig_;
        begin(tag, attr);
        Type* res;
        res = dig->template top<Type>();
        end(tag);
        return res;
    }
protected:
    virtual void end(const Xml_string& ) { dig->pop(); }
};



template<class Type>
class Generator : public Action
{
public:
    Type* eval(Digester* dig, const Xml_string& tag, Xml_attr attr)
    {
        return static_cast<Generator_body<Type>*>(body)->eval(dig, tag, attr);
    }

protected:
    Generator(Generator_body<Type>* body_) : Action(body_) {}
};


template <class Body, class Obj_Type, class Arg1=Dummy, class Arg2=Dummy, class Arg3=Dummy>
struct MakeGenerator : public Generator<Obj_Type> 
{
    MakeGenerator() : Generator<Obj_Type>(new Body()) {}
    MakeGenerator(Arg1 a) : Generator<Obj_Type>(new Body(a)) {}
    MakeGenerator(Arg1 a1, Arg2 a2) : Generator<Obj_Type>(new Body(a1, a2)) {}
    MakeGenerator(Arg1 a1, Arg2 a2, Arg3 a3) : Generator<Obj_Type>(new Body(a1, a2, a3)) {}
};

} // namespace

#endif