TemplateContextImpl Class Reference

Internal class representing the implementation of a template context. More...

Inheritance diagram for TemplateContextImpl:

Public Member Functions
	TemplateContextImpl (const TemplateEngine *e)
virtual	~TemplateContextImpl ()
void	push ()
void	pop ()
void	set (const char *name, const TemplateVariant &v)
TemplateVariant	get (const QCString &name) const
const TemplateVariant *	getRef (const QCString &name) const
void	setOutputDirectory (const QCString &dir)
void	setEscapeIntf (const QCString &ext, TemplateEscapeIntf *intf)
void	selectEscapeIntf (const QCString &ext)
void	setActiveEscapeIntf (TemplateEscapeIntf *intf)
void	setSpacelessIntf (TemplateSpacelessIntf *intf)
TemplateBlockContext *	blockContext ()
TemplateVariant	getPrimary (const QCString &name) const
void	setLocation (const QCString &templateName, int line)
QCString	templateName () const
int	line () const
QCString	outputDirectory () const
TemplateEscapeIntf *	escapeIntf () const
TemplateSpacelessIntf *	spacelessIntf () const
void	enableSpaceless (bool b)
bool	spacelessEnabled () const
void	enableTabbing (bool b)
bool	tabbingEnabled () const
void	warn (const char *fileName, int line, const char *fmt,...) const
void	openSubIndex (const QCString &indexName)
void	closeSubIndex (const QCString &indexName)
void	addIndexEntry (const QCString &indexName, const QValueList< TemplateKeyValue > &arguments)
Public Member Functions inherited from TemplateContext
virtual	~TemplateContext ()

Private Attributes
const TemplateEngine *	m_engine
QCString	m_templateName
int	m_line
QCString	m_outputDir
QList< QDict< TemplateVariant > >	m_contextStack
TemplateBlockContext	m_blockContext
QDict< TemplateEscapeIntf * >	m_escapeIntfDict
TemplateEscapeIntf *	m_activeEscapeIntf
TemplateSpacelessIntf *	m_spacelessIntf
bool	m_spacelessEnabled
bool	m_tabbingEnabled
TemplateAutoRef< TemplateStruct >	m_indices
QDict< QStack< TemplateVariant > >	m_indexStacks

Detailed Description

Internal class representing the implementation of a template context.

Definition at line 511 of file template.cpp.

Constructor & Destructor Documentation

TemplateContextImpl::TemplateContextImpl

(

const TemplateEngine *

e

)

Definition at line 2299 of file template.cpp.

  : m_engine(e), m_templateName("<unknown>"), m_line(1), m_activeEscapeIntf(0),
    m_spacelessIntf(0), m_spacelessEnabled(FALSE), m_tabbingEnabled(FALSE), m_indices(TemplateStruct::alloc())
{
  m_indexStacks.setAutoDelete(TRUE);
  m_contextStack.setAutoDelete(TRUE);
  m_escapeIntfDict.setAutoDelete(TRUE);
  push();
  set("index",m_indices.get());
}

TemplateContextImpl::~TemplateContextImpl ( )

virtual

Definition at line 2310 of file template.cpp.

{
  pop();
}

Member Function Documentation

void TemplateContextImpl::addIndexEntry	(	const QCString &	indexName,
		const QValueList< TemplateKeyValue > &	arguments
	)

Definition at line 2507 of file template.cpp.

{
  QValueListConstIterator<TemplateKeyValue> it = arguments.begin();
  //printf("TemplateContextImpl::addIndexEntry(%s)\n",indexName.data());
  //while (it!=arguments.end())
  //{
  //  printf("  key=%s value=%s\n",(*it).key.data(),(*it).value.toString().data());
  //  ++it;
  //}
  TemplateVariant parent(FALSE);
  QStack<TemplateVariant> *stack = m_indexStacks.find(indexName);
  if (!stack) // no stack yet, create it!
  {
    stack = new QStack<TemplateVariant>;
    stack->setAutoDelete(TRUE);
    m_indexStacks.insert(indexName,stack);
  }
  TemplateList *list  = 0;
  if (stack->isEmpty()) // first item, create empty list and add it to the index
  {
    list = TemplateList::alloc();
    stack->push(new TemplateVariant(list));
    m_indices->set(indexName,list); // make list available under index
  }
  else // stack not empty
  {
    if (stack->top()->type()==TemplateVariant::Struct) // already an entry in the list
    {
      // remove current entry from the stack
      delete stack->pop();
    }
    else // first entry after opensubindex
    {
      ASSERT(stack->top()->type()==TemplateVariant::List);
    }
    if (stack->count()>1)
    {
      TemplateVariant *tmp = stack->pop();
      // To prevent a cyclic dependency between parent and child which causes a memory
      // leak, we wrap the parent into a weak reference version.
      parent = new TemplateStructWeakRef(stack->top()->toStruct());
      stack->push(tmp);
      ASSERT(parent.type()==TemplateVariant::Struct);
    }
    // get list to add new item
    list = dynamic_cast<TemplateList*>(stack->top()->toList());
  }
  TemplateStruct *entry = TemplateStruct::alloc();
  // add user specified fields to the entry
  for (it=arguments.begin();it!=arguments.end();++it)
  {
    entry->set((*it).key,(*it).value);
  }
  if (list->count()>0)
  {
    TemplateStruct *lastEntry = dynamic_cast<TemplateStruct*>(list->at(list->count()-1).toStruct());
    lastEntry->set("last",false);
  }
  entry->set("is_leaf_node",true);
  entry->set("first",list->count()==0);
  entry->set("index",list->count());
  entry->set("parent",parent);
  entry->set("path",TemplateVariant::Delegate::fromFunction(entry,getPathFunc));
  entry->set("last",true);
  stack->push(new TemplateVariant(entry));
  list->append(entry);
}

TemplateBlockContext * TemplateContextImpl::blockContext

(

)

Definition at line 2426 of file template.cpp.

{
  return &m_blockContext;
}

void TemplateContextImpl::closeSubIndex

(

const QCString &

indexName

)

Definition at line 2461 of file template.cpp.

{
  printf("TemplateContextImpl::closeSubIndex(%s)\n",indexName.data());
  QStack<TemplateVariant> *stack = m_indexStacks.find(indexName);
  if (!stack || stack->count()<3)
  {
    warn(m_templateName,m_line,"closesubindex for index %s without matching open",indexName.data());
  }
  else // stack->count()>=2
  {
    if (stack->top()->type()==TemplateVariant::Struct)
    {
      delete stack->pop(); // pop struct
      delete stack->pop(); // pop list
    }
    else // empty list! correct "is_left_node" attribute of the parent entry
    {
      delete stack->pop(); // pop list
      TemplateStruct *entry = dynamic_cast<TemplateStruct*>(stack->top()->toStruct());
      if (entry)
      {
        entry->set("is_leaf_node",true);
      }
    }
  }
  //fprintf(stderr,"TemplateContextImpl::closeSubIndex(%s) end g_count=%d\n\n",indexName.data(),g_count);
}

void TemplateContextImpl::enableSpaceless ( bool  b )

inline

Definition at line 547 of file template.cpp.

                                                 { if (b && !m_spacelessEnabled) m_spacelessIntf->reset(); 
                                                   m_spacelessEnabled=b;
                                                 }

void TemplateContextImpl::enableTabbing ( bool  b )

inline

Definition at line 551 of file template.cpp.

                                                 { m_tabbingEnabled=b;
                                                   if (m_activeEscapeIntf) m_activeEscapeIntf->enableTabbing(b);
                                                 }

TemplateEscapeIntf* TemplateContextImpl::escapeIntf ( ) const

inline

Definition at line 545 of file template.cpp.

{ return m_activeEscapeIntf; }

TemplateVariant TemplateContextImpl::get ( const QCString &  name ) const

virtual

Gets the value for a given key

Parameters

[in]

name

The name of key.

Returns

The value, which can be an invalid variant in case the key was not found.

Implements TemplateContext.

Definition at line 2325 of file template.cpp.

{
  int i=name.find('.');
  if (i==-1) // simple name
  {
    return getPrimary(name);
  }
  else // obj.prop
  {
    QCString objName = name.left(i);
    TemplateVariant v = getPrimary(objName);
    QCString propName = name.mid(i+1);
    while (!propName.isEmpty())
    {
      //printf("getPrimary(%s) type=%d:%s\n",objName.data(),v.type(),v.toString().data());
      if (v.type()==TemplateVariant::Struct)
      {
        i = propName.find(".");
        int l = i==-1 ? propName.length() : i;
        v = v.toStruct()->get(propName.left(l));
        if (!v.isValid())
        {
          warn(m_templateName,m_line,"requesting non-existing property '%s' for object '%s'",propName.left(l).data(),objName.data());
        }
        if (i!=-1)
        {
          objName = propName.left(i);
          propName = propName.mid(i+1);
        }
        else
        {
          propName.resize(0);
        }
      }
      else if (v.type()==TemplateVariant::List)
      {
        i = propName.find(".");
        int l = i==-1 ? propName.length() : i;
        bool b;
        int index = propName.left(l).toInt(&b);
        if (b)
        {
          v = v.toList()->at(index);
        }
        else
        {
          warn(m_templateName,m_line,"list index '%s' is not valid",propName.data());
          break;
        }
        if (i!=-1)
        {
          propName = propName.mid(i+1);
        }
        else
        {
          propName.resize(0);
        }
      }
      else
      {
        warn(m_templateName,m_line,"using . on an object '%s' is not an struct or list",objName.data());
        return TemplateVariant();
      }
    }
    return v;
  }
}

TemplateVariant TemplateContextImpl::getPrimary

(

const QCString &

name

)

const

Definition at line 2405 of file template.cpp.

{
  const TemplateVariant *v = getRef(name);
  return v ? *v : TemplateVariant();
}

const TemplateVariant * TemplateContextImpl::getRef ( const QCString &  name ) const

virtual

Returns a pointer to the value corresponding to a given key.

Parameters

[in]

name

The name of key.

Returns

A pointer to the value, or 0 in case the key was not found.

Implements TemplateContext.

Definition at line 2393 of file template.cpp.

{
  QListIterator< QDict<TemplateVariant> > it(m_contextStack);
  QDict<TemplateVariant> *dict;
  for (it.toFirst();(dict=it.current());++it)
  {
    TemplateVariant *v = dict->find(name);
    if (v) return v;
  }
  return 0; // not found
}

int TemplateContextImpl::line ( ) const

inline

Definition at line 543 of file template.cpp.

{ return m_line; }

void TemplateContextImpl::openSubIndex

(

const QCString &

indexName

)

Definition at line 2440 of file template.cpp.

{
  printf("TemplateContextImpl::openSubIndex(%s)\n",indexName.data());
  QStack<TemplateVariant> *stack = m_indexStacks.find(indexName);
  if (!stack || stack->isEmpty() || stack->top()->type()==TemplateVariant::List) // error: no stack yet or no entry
  {
    warn(m_templateName,m_line,"opensubindex for index %s without preceding indexentry",indexName.data());
    return;
  }
  // get the parent entry to add the list to
  TemplateStruct *entry = dynamic_cast<TemplateStruct*>(stack->top()->toStruct());
  if (entry)
  {
    // add new list to the stack
    TemplateList *list = TemplateList::alloc();
    stack->push(new TemplateVariant(list));
    entry->set("children",list);
    entry->set("is_leaf_node",false);
  }
}

QCString TemplateContextImpl::outputDirectory ( ) const

inline

Definition at line 544 of file template.cpp.

{ return m_outputDir; }

void TemplateContextImpl::pop ( )

virtual

Pop the current scope from the stack.

Implements TemplateContext.

Definition at line 2418 of file template.cpp.

{
  if (!m_contextStack.removeFirst())
  {
    warn(m_templateName,m_line,"pop() called on empty context stack!\n");
  }
}

void TemplateContextImpl::push ( )

virtual

Push a new scope on the stack.

Implements TemplateContext.

Definition at line 2411 of file template.cpp.

{
  QDict<TemplateVariant> *dict = new QDict<TemplateVariant>;
  dict->setAutoDelete(TRUE);
  m_contextStack.prepend(dict);
}

void TemplateContextImpl::selectEscapeIntf ( const QCString &  ext )

inline

Definition at line 530 of file template.cpp.

    { TemplateEscapeIntf **ppIntf = m_escapeIntfDict.find(ext);
      m_activeEscapeIntf = ppIntf ? *ppIntf : 0;
    }

void TemplateContextImpl::set ( const char *  name, const TemplateVariant &  v  )

virtual

Sets a value in the current scope.

Parameters

[in]	name	The name of the value; the key in the dictionary.
[in]	v	The value associated with the key.

Note

When a given key is already present, its value will be replaced by v

Implements TemplateContext.

Definition at line 2315 of file template.cpp.

{
  TemplateVariant *pv = m_contextStack.getFirst()->find(name);
  if (pv)
  {
    m_contextStack.getFirst()->remove(name);
  }
  m_contextStack.getFirst()->insert(name,new TemplateVariant(v));
}

void TemplateContextImpl::setActiveEscapeIntf ( TemplateEscapeIntf *  intf )

inline

Definition at line 534 of file template.cpp.

{ m_activeEscapeIntf = intf; }

void TemplateContextImpl::setEscapeIntf ( const QCString &  extension, TemplateEscapeIntf *  intf  )

inlinevirtual

Sets the interface that will be used for escaping the result of variable expansion before writing it to the output.

Implements TemplateContext.

Definition at line 525 of file template.cpp.

    {
      int i=(!ext.isEmpty() && ext.at(0)=='.') ? 1 : 0;
      m_escapeIntfDict.insert(ext.mid(i),new TemplateEscapeIntf*(intf));
    }

void TemplateContextImpl::setLocation ( const QCString &  templateName, int  line  )

inline

Definition at line 540 of file template.cpp.

    { m_templateName=templateName; m_line=line; }

void TemplateContextImpl::setOutputDirectory ( const QCString &  dir )

inlinevirtual

When files are created (i.e. by {% create ... %}) they written to the directory dir.

Implements TemplateContext.

Definition at line 523 of file template.cpp.

    { m_outputDir = dir; }

void TemplateContextImpl::setSpacelessIntf ( TemplateSpacelessIntf *  intf )

inlinevirtual

Sets the interface that will be used inside a spaceless block to remove any redundant whitespace.

Implements TemplateContext.

Definition at line 535 of file template.cpp.

{ m_spacelessIntf = intf; }

bool TemplateContextImpl::spacelessEnabled ( ) const

inline

Definition at line 550 of file template.cpp.

{ return m_spacelessEnabled && m_spacelessIntf; }

TemplateSpacelessIntf* TemplateContextImpl::spacelessIntf ( ) const

inline

Definition at line 546 of file template.cpp.

{ return m_spacelessIntf; }

bool TemplateContextImpl::tabbingEnabled ( ) const

inline

Definition at line 554 of file template.cpp.

{ return m_tabbingEnabled; }

QCString TemplateContextImpl::templateName ( ) const

inline

Definition at line 542 of file template.cpp.

{ return m_templateName; }

void TemplateContextImpl::warn	(	const char *	fileName,
		int	line,
		const char *	fmt,
			...
	)		const

Definition at line 2431 of file template.cpp.

{
  va_list args;
  va_start(args,fmt);
  va_warn(fileName,line,fmt,args);
  va_end(args);
  m_engine->printIncludeContext(fileName,line);
}

Member Data Documentation

TemplateEscapeIntf* TemplateContextImpl::m_activeEscapeIntf

private

Definition at line 570 of file template.cpp.

TemplateBlockContext TemplateContextImpl::m_blockContext

private

Definition at line 568 of file template.cpp.

QList< QDict<TemplateVariant> > TemplateContextImpl::m_contextStack

private

Definition at line 567 of file template.cpp.

const TemplateEngine* TemplateContextImpl::m_engine

private

Definition at line 563 of file template.cpp.

QDict<TemplateEscapeIntf*> TemplateContextImpl::m_escapeIntfDict

private

Definition at line 569 of file template.cpp.

QDict< QStack<TemplateVariant> > TemplateContextImpl::m_indexStacks

private

Definition at line 575 of file template.cpp.

TemplateAutoRef<TemplateStruct> TemplateContextImpl::m_indices

private

Definition at line 574 of file template.cpp.

int TemplateContextImpl::m_line

private

Definition at line 565 of file template.cpp.

QCString TemplateContextImpl::m_outputDir

private

Definition at line 566 of file template.cpp.

bool TemplateContextImpl::m_spacelessEnabled

private

Definition at line 572 of file template.cpp.

TemplateSpacelessIntf* TemplateContextImpl::m_spacelessIntf

private

Definition at line 571 of file template.cpp.

bool TemplateContextImpl::m_tabbingEnabled

private

Definition at line 573 of file template.cpp.

QCString TemplateContextImpl::m_templateName

private

Definition at line 564 of file template.cpp.

---

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

• doxygen-1.8.11/src/template.cpp