/******************************************************************************

 *

 * Copyright (C) 1997-2015 by Dimitri van Heesch.

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation under the terms of the GNU General Public License is hereby 

 * granted. No representations are made about the suitability of this software 

 * for any purpose. It is provided "as is" without express or implied warranty.

 * See the GNU General Public License for more details.

 *

 * Documents produced by Doxygen are derivative works derived from the

 * input used in their production; they are not affected by this license.

 *

 */

#ifndef ARGUMENTS_H

#define ARGUMENTS_H

#include <qlist.h>

#include <qcstring.h>

class StorageIntf;

/*! \brief This class contains the information about the argument of a

 *         function or template

 *

 */

struct Argument

{

  /*! Construct a new argument. */

  Argument() {}

  /*! Copy an argument (does a deep copy of all strings). */

  Argument(const Argument &a)

  {

    attrib=a.attrib;

    type=a.type;

    name=a.name;

    array=a.array;

    defval=a.defval;

    docs=a.docs;

    typeConstraint=a.typeConstraint;

  }

  /*! Assignment of an argument (does a deep copy of all strings). */

  Argument &operator=(const Argument &a)

  {

    if (this!=&a)

    {

      attrib=a.attrib;

      type=a.type;

      name=a.name;

      array=a.array;

      defval=a.defval;

      docs=a.docs;

      typeConstraint=a.typeConstraint;

    }

    return *this;

  }

  /*! return TRUE if this argument is documentation and the argument has a

   *  non empty name.

   */

  bool hasDocumentation() const

  {

    return !name.isEmpty() && !docs.isEmpty();

  }

  QCString attrib;   /*!< Argument's attribute (IDL only) */

  QCString type;     /*!< Argument's type */

  QCString canType;  /*!< Cached value of canonical type (after type resolution). Empty initially. */

  QCString name;     /*!< Argument's name (may be empty) */

  QCString array;    /*!< Argument's array specifier (may be empty) */

  QCString defval;   /*!< Argument's default value (may be empty) */

  QCString docs;     /*!< Argument's documentation (may be empty) */

  QCString typeConstraint;  /*!< Used for Java generics: \<T extends C\> */

};

enum RefQualifierType

{

  RefQualifierNone,

  RefQualifierLValue,

  RefQualifierRValue

};

/*! \brief 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.

 */

class ArgumentList : public QList<Argument> 

{

  public:

    /*! Creates an empty argument list */

    ArgumentList() : QList<Argument>(), 

                     constSpecifier(FALSE),

                     volatileSpecifier(FALSE),

                     pureSpecifier(FALSE),

                     isDeleted(FALSE),

                     refQualifier(RefQualifierNone)

                     { setAutoDelete(TRUE); }

    /*! Destroys the argument list */

   ~ArgumentList() {}

    /*! Makes a deep copy of this object */

    ArgumentList *deepCopy() const;

    /*! Does any argument of this list have documentation? */

    bool hasDocumentation() const;

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

    bool constSpecifier;

    /*! Is the member volatile? default: FALSE. */

    bool volatileSpecifier;

    /*! Is this a pure virtual member? default: FALSE */

    bool pureSpecifier;

    /*! C++11 style Trailing return type? */

    QCString trailingReturnType;

    /*! method with =delete */

    bool isDeleted;

    /*! C++11 ref qualifier */

    RefQualifierType refQualifier;

    static ArgumentList *unmarshal(StorageIntf *s);

    static void marshal(StorageIntf *s,ArgumentList *argList);

};

typedef QListIterator<Argument> ArgumentListIterator;

#endif