ArgumentList Class Reference

This class represents an function or template argument list. More...

#include <arguments.h>

Inheritance diagram for ArgumentList:

Public Member Functions
	ArgumentList ()
	~ArgumentList ()
ArgumentList *	deepCopy () const
bool	hasDocumentation () const
Public Member Functions inherited from QList< Argument >
	QList ()
	QList (const QList< Argument > &l)
	~QList ()
QList< Argument > &	operator= (const QList< Argument > &l)
bool	operator== (const QList< Argument > &list) const
uint	count () const
bool	isEmpty () const
bool	insert (uint i, const Argument *d)
void	inSort (const Argument *d)
void	prepend (const Argument *d)
void	append (const Argument *d)
bool	remove (uint i)
bool	remove (const Argument *d)
bool	removeRef (const Argument *d)
bool	removeFirst ()
bool	removeLast ()
Argument *	take (uint i)
void	clear ()
void	sort ()
int	find (const Argument *d) const
int	findRef (const Argument *d) const
uint	contains (const Argument *d) const
uint	containsRef (const Argument *d) const
Argument *	at (uint i) const
Argument *	getFirst () const
Argument *	getLast () const
void	setAutoDelete (bool enable)

Static Public Member Functions
static ArgumentList *	unmarshal (StorageIntf *s)
static void	marshal (StorageIntf *s, ArgumentList *argList)

Public Attributes
bool	constSpecifier
bool	volatileSpecifier
bool	pureSpecifier
QCString	trailingReturnType
bool	isDeleted

Detailed Description

This class represents an function or template argument list.

This class also stores some information about member that is typically put after the argument list, such as whether the member is const, volatile or pure virtual.

Definition at line 82 of file arguments.h.

Constructor & Destructor Documentation

ArgumentList::ArgumentList ( )

inline

Creates an empty argument list

Definition at line 86 of file arguments.h.

                   : QList<Argument>(), 
                     constSpecifier(FALSE),
                     volatileSpecifier(FALSE),
                     pureSpecifier(FALSE),
                     isDeleted(FALSE)
                     { setAutoDelete(TRUE); }

ArgumentList::~ArgumentList ( )

inline

Destroys the argument list

Definition at line 93 of file arguments.h.

{}

Member Function Documentation

ArgumentList * ArgumentList::deepCopy

(

)

const

Makes a deep copy of this object

Definition at line 20 of file arguments.cpp.

{
  ArgumentList *argList = new ArgumentList;
  argList->setAutoDelete(TRUE);

  QListIterator<Argument> ali(*this);
  Argument *a;
  for (;(a=ali.current());++ali)
  {
    argList->append(new Argument(*a));
  }
  argList->constSpecifier     = constSpecifier;
  argList->volatileSpecifier  = volatileSpecifier;
  argList->pureSpecifier      = pureSpecifier;
  argList->trailingReturnType = trailingReturnType;
  argList->isDeleted          = isDeleted;

  return argList;
}

bool ArgumentList::hasDocumentation

(

)

const

Does any argument of this list have documentation?

the argument list is documented if one of its arguments is documented

Definition at line 8 of file arguments.cpp.

{
  bool hasDocs=FALSE;
  ArgumentListIterator ali(*this);
  Argument *a;
  for (ali.toFirst();!hasDocs && (a=ali.current());++ali)
  {
    hasDocs = a->hasDocumentation(); 
  }
  return hasDocs;
}

void ArgumentList::marshal ( StorageIntf *  s, ArgumentList *  argList  )

static

Definition at line 69 of file arguments.cpp.

{
  if (argList==0)
  {
    marshalUInt(s,NULL_LIST); // null pointer representation
  }
  else
  {
    marshalUInt(s,argList->count());
    if (argList->count()>0)
    {
      ArgumentListIterator ali(*argList);
      Argument *a;
      for (ali.toFirst();(a=ali.current());++ali)
      {
        marshalQCString(s,a->attrib);    
        marshalQCString(s,a->type);    
        marshalQCString(s,a->canType);    
        marshalQCString(s,a->name);    
        marshalQCString(s,a->array);    
        marshalQCString(s,a->defval);    
        marshalQCString(s,a->docs);    
        marshalQCString(s,a->typeConstraint);
      }
    }
    marshalBool(s,argList->constSpecifier);
    marshalBool(s,argList->volatileSpecifier);
    marshalBool(s,argList->pureSpecifier);
    marshalQCString(s,argList->trailingReturnType);
    marshalBool(s,argList->isDeleted);
  }
}

ArgumentList * ArgumentList::unmarshal ( StorageIntf *  s )

static

Definition at line 40 of file arguments.cpp.

{
  uint i;
  uint count = unmarshalUInt(s);
  if (count==NULL_LIST) return 0; // null list
  ArgumentList *result = new ArgumentList;
  assert(count<1000000);
  //printf("unmarshalArgumentList: %d\n",count);
  for (i=0;i<count;i++)
  {
    Argument *a = new Argument;
    a->attrib  = unmarshalQCString(s);
    a->type    = unmarshalQCString(s);
    a->canType = unmarshalQCString(s);
    a->name    = unmarshalQCString(s);
    a->array   = unmarshalQCString(s);
    a->defval  = unmarshalQCString(s);
    a->docs    = unmarshalQCString(s);
    a->typeConstraint = unmarshalQCString(s);
    result->append(a);
  }
  result->constSpecifier     = unmarshalBool(s);
  result->volatileSpecifier  = unmarshalBool(s);
  result->pureSpecifier      = unmarshalBool(s);
  result->trailingReturnType = unmarshalQCString(s);
  result->isDeleted          = unmarshalBool(s);
  return result;
}

Member Data Documentation

bool ArgumentList::constSpecifier

Does the member modify the state of the class? default: FALSE.

Definition at line 99 of file arguments.h.

bool ArgumentList::isDeleted

method with =delete

Definition at line 107 of file arguments.h.

bool ArgumentList::pureSpecifier

Is this a pure virtual member? default: FALSE

Definition at line 103 of file arguments.h.

QCString ArgumentList::trailingReturnType

C++11 style Trailing return type?

Definition at line 105 of file arguments.h.

bool ArgumentList::volatileSpecifier

Is the member volatile? default: FALSE.

Definition at line 101 of file arguments.h.

---

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

• doxygen-1.8.11/src/arguments.h
• doxygen-1.8.11/src/arguments.cpp