templates/lib/node.h

/*
  This file is part of the Grantlee template system.

  Copyright (c) 2009,2010 Stephen Kelly <steveire@gmail.com>

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either version
  2.1 of the Licence, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef GRANTLEE_NODE_H
#define GRANTLEE_NODE_H

// krazy:excludeall=dpointer

#include "context.h"
#include "filterexpression.h"
#include "grantlee_templates_export.h"
#include "outputstream.h"
#include "safestring.h"

#include <QtCore/QStringList>

// Need these for inheriting from QList<T> to work
// http://lists.trolltech.com/qt-interest/2008-01/thread00578-0.html
#include <QtCore/QSet>
#include <QtCore/QVector>

namespace Grantlee
{

class Engine;
class NodeList;
class TemplateImpl;

class NodePrivate;


class GRANTLEE_TEMPLATES_EXPORT Node : public QObject
{
  Q_OBJECT
public:
  explicit Node(QObject *parent = 0);

  ~Node() override;

  virtual void render(OutputStream *stream, Context *c) const = 0;

#ifndef Q_QDOC

  virtual bool mustBeFirst()
  { // krazy:exclude:inline
    return false;
  }
#endif

protected:
  void streamValueInContext(OutputStream *stream, const QVariant &input,
                            Grantlee::Context *c) const;

  TemplateImpl *containerTemplate() const;

private:
  Q_DECLARE_PRIVATE(Node)
  NodePrivate *const d_ptr;
};


class GRANTLEE_TEMPLATES_EXPORT NodeList : public QList<Grantlee::Node *>
{
public:
  NodeList();

  NodeList(const NodeList &list);

  NodeList &operator=(const NodeList &list);

  /* implicit */ NodeList(const QList<Grantlee::Node *> &list);

  ~NodeList();

  void append(Grantlee::Node *node);

  void append(QList<Grantlee::Node *> nodeList);

  bool containsNonText() const;

  template <typename T> QList<T> findChildren()
  {
    QList<T> children;
    QList<Grantlee::Node *>::const_iterator it;
    const QList<Grantlee::Node *>::const_iterator first = constBegin();
    const QList<Grantlee::Node *>::const_iterator last = constEnd();
    for (it = first; it != last; ++it) {
      T object = qobject_cast<T>(*it);
      if (object) {
        children << object;
      }
      children << (*it)->findChildren<T>();
    }
    return children;
  }

  void render(OutputStream *stream, Context *c) const;

private:
  bool m_containsNonText;
};

class AbstractNodeFactoryPrivate;


class GRANTLEE_TEMPLATES_EXPORT AbstractNodeFactory : public QObject
{
  Q_OBJECT
public:
  explicit AbstractNodeFactory(QObject *parent = 0);

  ~AbstractNodeFactory() override;

  virtual Node *getNode(const QString &tagContent, Parser *p) const = 0;

#ifndef Q_QDOC

  virtual void setEngine(Engine *) {}
#endif

protected:
  Q_INVOKABLE QStringList smartSplit(const QString &str) const;

protected:
  QList<FilterExpression> getFilterExpressionList(const QStringList &list,
                                                  Parser *p) const;

private:
  Q_DECLARE_PRIVATE(AbstractNodeFactory)
  AbstractNodeFactoryPrivate *const d_ptr;
};
}

#endif