node.h

/*
  This file is part of the Cutelee 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 CUTELEE_NODE_H
#define CUTELEE_NODE_H
 
// krazy:excludeall=dpointer
 
#include "context.h"
#include "filterexpression.h"
#include "cutelee_templates_export.h"
#include "outputstream.h"
#include "safestring.h"
 
#include <QtCore/QStringList>
 
namespace Cutelee
{
 
class Engine;
class NodeList;
class TemplateImpl;
 
class NodePrivate;
 
 
class CUTELEE_TEMPLATES_EXPORT Node : public QObject
{
  Q_OBJECT
public:
  explicit Node(QObject *parent = {});
 
  ~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,
                            Cutelee::Context *c) const;
 
  TemplateImpl *containerTemplate() const;
 
private:
  Q_DECLARE_PRIVATE(Node)
  NodePrivate *const d_ptr;
};
 
 
class CUTELEE_TEMPLATES_EXPORT NodeList : public QList<Cutelee::Node *>
{
public:
  NodeList();
 
  NodeList(const NodeList &list);
 
  NodeList &operator=(const NodeList &list);
 
  /* implicit */ NodeList(const QList<Cutelee::Node *> &list);
 
  ~NodeList();
 
  void append(Cutelee::Node *node);
 
  void append(const QList<Cutelee::Node *> &nodeList);
 
  bool containsNonText() const;
 
  template <typename T> QList<T> findChildren()
  {
    QList<T> children;
    QList<Cutelee::Node *>::const_iterator it;
    const QList<Cutelee::Node *>::const_iterator first = constBegin();
    const QList<Cutelee::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 CUTELEE_TEMPLATES_EXPORT AbstractNodeFactory : public QObject
{
  Q_OBJECT
public:
  explicit AbstractNodeFactory(QObject *parent = {});
 
  ~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