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

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.

Referenced by deepCopy(), and unmarshal().

                   : 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.

References ArgumentList(), constSpecifier, isDeleted, pureSpecifier, trailingReturnType, and volatileSpecifier.

Referenced by copyArgumentLists(), MemberDef::createTemplateInstanceMember(), MemberDef::deepCopy(), Entry::Entry(), and MemberDefImpl::init().

{
  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.

References Argument::hasDocumentation().

Referenced by MemberDef::hasDocumentation(), MemberDef::isDetailedSectionLinkable(), MemberContext::Private::paramDocs(), and MemberDef::writeDocumentation().

{
  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.

References Argument::array, Argument::attrib, Argument::canType, constSpecifier, Argument::defval, Argument::docs, isDeleted, marshalBool(), marshalQCString(), marshalUInt(), Argument::name, NULL_LIST, pureSpecifier, trailingReturnType, Argument::type, Argument::typeConstraint, and volatileSpecifier.

Referenced by marshalArgumentList().

{
  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.

References ArgumentList(), Argument::array, Argument::attrib, Argument::canType, constSpecifier, Argument::defval, Argument::docs, isDeleted, Argument::name, NULL_LIST, pureSpecifier, trailingReturnType, Argument::type, Argument::typeConstraint, unmarshalBool(), unmarshalQCString(), unmarshalUInt(), and volatileSpecifier.

Referenced by unmarshalArgumentList().

{
  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;
}