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_core_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_CORE_EXPORT Node : public QObject
{
  Q_OBJECT
public:
  explicit Node( QObject *parent = 0 );
 
  virtual ~Node();
 
  // This can't be const because CycleNode needs to change on each render.
  virtual void render( OutputStream *stream, Context *c ) = 0;
 
#ifndef Q_QDOC
 
  virtual bool mustBeFirst() { // krazy:exclude:inline
    return false;
  }
#endif
 
protected:
  void streamValueInContext( OutputStream *stream, const QVariant &input, Grantlee::Context *c );
 
  TemplateImpl* containerTemplate() const;
 
private:
  Q_DECLARE_PRIVATE( Node )
  NodePrivate * const d_ptr;
};
 
 
class GRANTLEE_CORE_EXPORT NodeList : public QList<Grantlee::Node*>
{
public:
  NodeList();
 
  NodeList( 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 );
 
private:
  bool m_containsNonText;
};
 
class AbstractNodeFactoryPrivate;
 
 
class GRANTLEE_CORE_EXPORT AbstractNodeFactory : public QObject
{
  Q_OBJECT
public:
  explicit AbstractNodeFactory( QObject* parent = 0 );
 
  virtual ~AbstractNodeFactory();
 
  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