arguments.h

/******************************************************************************
 *
 * 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 <vector>
#include "qcstring.h"

struct Argument
{
  bool hasDocumentation() const
  {
    return !name.isEmpty() && !docs.isEmpty();
  }

  QCString attrib;   
  QCString type;     
  QCString canType;  
  QCString name;     
  QCString array;    
  QCString defval;   
  QCString docs;     
  QCString typeConstraint;  
};

enum RefQualifierType
{
  RefQualifierNone,
  RefQualifierLValue,
  RefQualifierRValue
};

class ArgumentList
{
  public:
    using Vec = std::vector<Argument>;
    using iterator = typename Vec::iterator;
    using const_iterator = typename Vec::const_iterator;

    bool hasDocumentation() const;
    bool hasParameters() const
    {
      return !empty() || m_noParameters;
    }
    void reset()
    {
      clear();
      m_constSpecifier = FALSE;
      m_volatileSpecifier = FALSE;
      m_pureSpecifier = FALSE;
      m_trailingReturnType.resize(0);
      m_isDeleted = FALSE;
      m_refQualifier = RefQualifierNone;
      m_noParameters = FALSE;
    }

    // make vector accessible
    iterator begin()                      { return m_args.begin(); }
    iterator end()                        { return m_args.end();   }
    const_iterator begin() const          { return m_args.cbegin(); }
    const_iterator end() const            { return m_args.cend();   }
    const_iterator cbegin() const         { return m_args.cbegin(); }
    const_iterator cend() const           { return m_args.cend();   }
    bool empty() const                    { return m_args.empty(); }
    size_t size() const                   { return m_args.size();  }
    void clear()                          { m_args.clear(); }
    void push_back(const Argument &a)     { m_args.push_back(a); }
    Argument &back()                      { return m_args.back(); }
    const Argument &back() const          { return m_args.back(); }
    Argument &front()                     { return m_args.front(); }
    const Argument &front() const         { return m_args.front(); }
    Argument &at(size_t i)                { return m_args.at(i); }
    const Argument &at(size_t i) const    { return m_args.at(i); }

    // getters for list wide attributes
    bool constSpecifier() const           { return m_constSpecifier; }
    bool volatileSpecifier() const        { return m_volatileSpecifier; }
    bool pureSpecifier() const            { return m_pureSpecifier; }
    QCString trailingReturnType() const   { return m_trailingReturnType; }
    bool isDeleted() const                { return m_isDeleted; }
    RefQualifierType refQualifier() const { return m_refQualifier; }
    bool noParameters() const             { return m_noParameters; }

    void setConstSpecifier(bool b)        { m_constSpecifier = b; }
    void setVolatileSpecifier(bool b)     { m_volatileSpecifier = b; }
    void setPureSpecifier(bool b)         { m_pureSpecifier = b; }
    void setTrailingReturnType(const QCString &s) { m_trailingReturnType = s; }
    void setIsDeleted(bool b)             { m_isDeleted = b; }
    void setRefQualifier(RefQualifierType t) { m_refQualifier = t; }
    void setNoParameters(bool b)          { m_noParameters = b; }

  private:
    std::vector<Argument> m_args;
    bool m_constSpecifier = FALSE;
    bool m_volatileSpecifier = FALSE;
    bool m_pureSpecifier = FALSE;
    QCString m_trailingReturnType;
    bool m_isDeleted = FALSE;
    RefQualifierType m_refQualifier = RefQualifierNone;
    bool m_noParameters = FALSE;
};

using ArgumentLists = std::vector<ArgumentList>;

#endif