TemplateNodeTree Class Reference

Class representing an 'tree' tag in a template. More...

Inheritance diagram for TemplateNodeTree:

Classes
struct	TreeContext

Public Member Functions
	TemplateNodeTree (TemplateParser *parser, TemplateNode *parent, int line, const QCString &data)
	~TemplateNodeTree ()
QCString	renderChildren (const TreeContext *ctx)
void	render (FTextStream &ts, TemplateContext *c)
Public Member Functions inherited from TemplateNodeCreator< TemplateNodeTree >
	TemplateNodeCreator (TemplateParser *parser, TemplateNode *parent, int line)
TemplateImpl *	getTemplate ()
Public Member Functions inherited from TemplateNode
	TemplateNode (TemplateNode *parent)
virtual	~TemplateNode ()
TemplateNode *	parent ()

Static Public Member Functions
static TemplateVariant	renderChildrenStub (const void *ctx, const QValueList< TemplateVariant > &)
Static Public Member Functions inherited from TemplateNodeCreator< TemplateNodeTree >
static TemplateNode *	createInstance (TemplateParser *parser, TemplateNode *parent, int line, const QCString &data)

Private Attributes
ExprAst *	m_treeExpr
TemplateNodeList	m_treeNodes

Additional Inherited Members
Protected Member Functions inherited from TemplateNodeCreator< TemplateNodeTree >
void	mkpath (TemplateContextImpl *ci, const QCString &fileName)
Protected Attributes inherited from TemplateNodeCreator< TemplateNodeTree >
QCString	m_templateName
int	m_line

Detailed Description

Class representing an 'tree' tag in a template.

Definition at line 3594 of file template.cpp.

Constructor & Destructor Documentation

TemplateNodeTree::TemplateNodeTree ( TemplateParser *  parser, TemplateNode *  parent, int  line, const QCString &  data  )

inline

Definition at line 3605 of file template.cpp.

      : TemplateNodeCreator<TemplateNodeTree>(parser,parent,line)
    {
      TRACE(("{TemplateNodeTree(%s)\n",data.data()));
      ExpressionParser ep(parser,line);
      if (data.isEmpty())
      {
        parser->warn(m_templateName,line,"recursetree tag is missing data argument");
      }
      m_treeExpr = ep.parse(data);
      QStrList stopAt;
      stopAt.append("endrecursetree");
      parser->parse(this,line,stopAt,m_treeNodes);
      parser->removeNextToken(); // skip over endrecursetree
      TRACE(("}TemplateNodeTree(%s)\n",data.data()));
    }

TemplateNodeTree::~TemplateNodeTree ( )

inline

Definition at line 3621 of file template.cpp.

    {
      delete m_treeExpr;
    }

Member Function Documentation

void TemplateNodeTree::render ( FTextStream &  ts, TemplateContext *  c  )

inlinevirtual

Implements TemplateNode.

Definition at line 3682 of file template.cpp.

    {
      //printf("TemplateNodeTree::render()\n");
      TemplateContextImpl* ci = dynamic_cast<TemplateContextImpl*>(c);
      if (ci==0) return; // should not happen
      ci->setLocation(m_templateName,m_line);
      TemplateVariant v = m_treeExpr->resolve(c);
      const TemplateListIntf *list = v.toList();
      if (list)
      {
        TreeContext ctx(this,list,c);
        ts << renderChildren(&ctx);
      }
      else
      {
        ci->warn(m_templateName,m_line,"recursetree's argument should be a list type");
      }
    }

QCString TemplateNodeTree::renderChildren ( const TreeContext *  ctx )

inline

Definition at line 3630 of file template.cpp.

    {
      //printf("TemplateNodeTree::renderChildren(%d)\n",ctx->list->count());
      // render all children of node to a string and return it
      TemplateContext *c = ctx->templateCtx;
      TemplateContextImpl* ci = dynamic_cast<TemplateContextImpl*>(c);
      if (ci==0) return QCString(); // should not happen
      QGString result;
      FTextStream ss(&result);
      c->push();
      TemplateVariant node;
      TemplateListIntf::ConstIterator *it = ctx->list->createIterator();
      for (it->toFirst();(it->current(node));it->toNext())
      {
        c->set("node",node);
        bool hasChildren=FALSE;
        const TemplateStructIntf *ns = node.toStruct();
        if (ns) // node is a struct
        {
          TemplateVariant v = ns->get("children");
          if (v.isValid()) // with a field 'children'
          {
            const TemplateListIntf *list = v.toList();
            if (list && list->count()>0) // non-empty list
            {
              TreeContext childCtx(this,list,ctx->templateCtx);
              TemplateVariant children(TemplateVariant::Delegate::fromFunction(&childCtx,renderChildrenStub));
              children.setRaw(TRUE);
              c->set("children",children);
              m_treeNodes.render(ss,c);
              hasChildren=TRUE;
            }
            else if (list==0)
            {
              ci->warn(m_templateName,m_line,"recursetree: children attribute has type '%s' instead of list\n",v.typeAsString().data());
            }
          }
          //else
          //{
          //  ci->warn(m_templateName,m_line,"recursetree: children attribute is not valid");
          //}
        }
        if (!hasChildren)
        {
          c->set("children",TemplateVariant("")); // provide default
          m_treeNodes.render(ss,c);
        }
      }
      c->pop();
      delete it;
      return result.data();
    }

static TemplateVariant TemplateNodeTree::renderChildrenStub ( const void *  ctx, const QValueList< TemplateVariant > &    )

inlinestatic

Definition at line 3625 of file template.cpp.

    {
      return TemplateVariant(((TreeContext*)ctx)->object->
                             renderChildren((const TreeContext*)ctx),TRUE);
    }

Member Data Documentation

ExprAst* TemplateNodeTree::m_treeExpr

private

Definition at line 3702 of file template.cpp.

TemplateNodeList TemplateNodeTree::m_treeNodes

private

Definition at line 3703 of file template.cpp.

---

The documentation for this class was generated from the following file:

• doxygen-1.8.11/src/template.cpp