template.h

/******************************************************************************
 *
 * Copyright (C) 1997-2015 by Dimitri van Heesch.
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation under the terms of the GNU General Public License is hereby
 * granted. No representations are made about the suitability of this software
 * for any purpose. It is provided "as is" without express or implied warranty.
 * See the GNU General Public License for more details.
 *
 * Documents produced by Doxygen are derivative works derived from the
 * input used in their production; they are not affected by this license.
 *
 */

#ifndef TEMPLATE_H
#define TEMPLATE_H

#include <qcstring.h>
#include <qvaluelist.h>

class FTextStream;

class TemplateListIntf;
class TemplateStructIntf;
class TemplateEngine;

class TemplateVariant
{
  public:
    class Delegate
    {
      public:
        typedef TemplateVariant (*StubType)(const void *obj, const QValueList<TemplateVariant> &args);

        Delegate() : m_objectPtr(0) , m_stubPtr(0) {}

        template <class T, TemplateVariant (T::*TMethod)(const QValueList<TemplateVariant> &) const>
        static Delegate fromMethod(const T* objectPtr)
        {
          Delegate d;
          d.m_objectPtr = objectPtr;
          d.m_stubPtr   = &methodStub<T, TMethod>;
          return d;
        }
        static Delegate fromFunction(const void *obj,StubType func)
        {
          Delegate d;
          d.m_objectPtr = obj;
          d.m_stubPtr = func;
          return d;
        }

        TemplateVariant operator()(const QValueList<TemplateVariant> &args) const
        {
          return (*m_stubPtr)(m_objectPtr, args);
        }

      private:
        const void* m_objectPtr;
        StubType    m_stubPtr;

        template <class T, TemplateVariant (T::*TMethod)(const QValueList<TemplateVariant> &) const>
        static TemplateVariant methodStub(const void* objectPtr, const QValueList<TemplateVariant> &args)
        {
          T* p = (T*)(objectPtr);
          return (p->*TMethod)(args);
        }
    };

    enum Type { None, Bool, Integer, String, Struct, List, Function };

    Type type() const { return m_type; }

    QCString typeAsString() const
    {
      switch (m_type)
      {
        case None:     return "none";
        case Bool:     return "bool";
        case Integer:  return "integer";
        case String:   return "string";
        case Struct:   return "struct";
        case List:     return "list";
        case Function: return "function";
      }
      return "invalid";
    }

    bool isValid() const { return m_type!=None; }

    TemplateVariant() : m_type(None), m_strukt(0), m_raw(FALSE) {}

    explicit TemplateVariant(bool b) : m_type(Bool), m_boolVal(b), m_raw(FALSE) {}

    TemplateVariant(int v) : m_type(Integer), m_intVal(v), m_raw(FALSE) {}

    TemplateVariant(const char *s,bool raw=FALSE) : m_type(String), m_strVal(s), m_strukt(0), m_raw(raw) {}

    TemplateVariant(const QCString &s,bool raw=FALSE) : m_type(String), m_strVal(s), m_strukt(0), m_raw(raw) {}

    TemplateVariant(TemplateStructIntf *s);

    TemplateVariant(TemplateListIntf *l);

    TemplateVariant(const Delegate &delegate) : m_type(Function), m_strukt(0), m_delegate(delegate), m_raw(FALSE) {}

    ~TemplateVariant();

    TemplateVariant(const TemplateVariant &v);

    TemplateVariant &operator=(const TemplateVariant &v);

    bool operator==(TemplateVariant &other)
    {
      if (m_type==None)
      {
        return FALSE;
      }
      if (m_type==TemplateVariant::List && other.m_type==TemplateVariant::List)
      {
        return m_list==other.m_list; // TODO: improve me
      }
      else if (m_type==TemplateVariant::Struct && other.m_type==TemplateVariant::Struct)
      {
        return m_strukt==other.m_strukt; // TODO: improve me
      }
      else
      {
        return toString()==other.toString();
      }
    }

    QCString toString() const
    {
      switch (m_type)
      {
        case None:     return QCString();
        case Bool:     return m_boolVal ? "true" : "false";
        case Integer:  return QCString().setNum(m_intVal);
        case String:   return m_strVal;
        case Struct:   return "[struct]";
        case List:     return "[list]";
        case Function: return "[function]";
      }
      return QCString();
    }

    bool toBool() const;

    int toInt() const;

    TemplateListIntf   *toList() const
    {
      return m_type==List ? m_list : 0;
    }

    TemplateStructIntf *toStruct() const
    {
      return m_type==Struct ? m_strukt : 0;
    }

    TemplateVariant call(const QValueList<TemplateVariant> &args)
    {
      if (m_type==Function) return m_delegate(args);
      return TemplateVariant();
    }

    void setRaw(bool b) { m_raw = b; }

    bool raw() const { return m_raw; }

  private:
    Type                  m_type;
    QCString              m_strVal;
    union
    {
      int                 m_intVal;
      bool                m_boolVal;
      TemplateStructIntf *m_strukt;
      TemplateListIntf   *m_list;
    };
    Delegate              m_delegate;
    bool                  m_raw;
};

//------------------------------------------------------------------------

template<class T> class TemplateAutoRef
{
  public:
    TemplateAutoRef(T *obj) : m_obj(obj)
    {
      m_obj->addRef();
    }
   ~TemplateAutoRef()
    {
      m_obj->release();
    }
    T &operator*() const { return *m_obj; }
    T *operator->() const { return m_obj; }
    T *get() const { return m_obj; }

  private:
   T *m_obj;
};

//------------------------------------------------------------------------

class TemplateListIntf
{
  public:
    class ConstIterator
    {
      public:
        virtual ~ConstIterator() {}
        virtual void toFirst() = 0;
        virtual void toLast() = 0;
        virtual void toNext() = 0;
        virtual void toPrev() = 0;
        /* Returns TRUE if the iterator points to a valid element
         * in the list, or FALSE otherwise.
         * If TRUE is returned, the value pointed to be the
         * iterator is assigned to \a v.
         */
        virtual bool current(TemplateVariant &v) const = 0;
    };

    virtual ~TemplateListIntf() {}

    virtual int count() const = 0;

    virtual TemplateVariant  at(int index) const = 0;

    virtual TemplateListIntf::ConstIterator *createIterator() const = 0;

    virtual int addRef() = 0;

    virtual int release() = 0;
};

class TemplateList : public TemplateListIntf
{
  public:
    // TemplateListIntf methods
    virtual int  count() const;
    virtual TemplateVariant at(int index) const;
    virtual TemplateListIntf::ConstIterator *createIterator() const;
    virtual int addRef();
    virtual int release();

    static TemplateList *alloc();

    virtual void append(const TemplateVariant &v);

  private:
    TemplateList();
   ~TemplateList();

    friend class TemplateListConstIterator;
    class Private;
    Private *p;
};

//------------------------------------------------------------------------

class TemplateStructIntf
{
  public:
    virtual ~TemplateStructIntf() {}

    virtual TemplateVariant get(const char *name) const = 0;

    virtual int addRef() = 0;

    virtual int release() = 0;
};


class TemplateStruct : public TemplateStructIntf
{
  public:
    // TemplateStructIntf methods
    virtual TemplateVariant get(const char *name) const;
    virtual int addRef();
    virtual int release();

    static TemplateStruct *alloc();

    virtual void set(const char *name,const TemplateVariant &v);


  private:
    TemplateStruct();
    virtual ~TemplateStruct();

    class Private;
    Private *p;
};

//------------------------------------------------------------------------

class TemplateEscapeIntf
{
  public:
    virtual QCString escape(const QCString &input) = 0;
    virtual void enableTabbing(bool b) = 0;
};

//------------------------------------------------------------------------

class TemplateSpacelessIntf
{
  public:
    virtual QCString remove(const QCString &input) = 0;
    virtual void reset() = 0;
};

//------------------------------------------------------------------------

class TemplateContext
{
  public:
    virtual ~TemplateContext() {}

    virtual void push() = 0;

    virtual void pop() = 0;

    virtual void set(const char *name,const TemplateVariant &v) = 0;

    virtual TemplateVariant get(const QCString &name) const = 0;

    virtual const TemplateVariant *getRef(const QCString &name) const = 0;

    virtual void setOutputDirectory(const QCString &dir) = 0;

    virtual void setEscapeIntf(const QCString &extension, TemplateEscapeIntf *intf) = 0;

    virtual void setSpacelessIntf(TemplateSpacelessIntf *intf) = 0;
};

//------------------------------------------------------------------------

class Template
{
  public:
    virtual ~Template() {}

    virtual void render(FTextStream &ts,TemplateContext *c) = 0;
};

//------------------------------------------------------------------------

class TemplateEngine
{
  public:
    TemplateEngine();

   ~TemplateEngine();

    TemplateContext *createContext() const;

    void destroyContext(TemplateContext *ctx);

    Template *loadByName(const QCString &fileName,int fromLine);

    void unload(Template *t);

    void printIncludeContext(const char *fileName,int line) const;

    void setTemplateDir(const char *dirName);

  private:
    friend class TemplateNodeBlock;
    friend class TemplateNodeCreate;

    void enterBlock(const QCString &fileName,const QCString &blockName,int line);
    void leaveBlock();

    void setOutputExtension(const char *extension);

    QCString outputExtension() const;

    class Private;
    Private *p;
};

#endif