Doc: Move the doc artifacts outside of the submodule directory

The qdocconf now lives in 'src/doc' because the documentation
project defined by it covers the whole Qt 3D module. This change
enables qmake to use 'qt3d' as the output directory for doc make
targets. The new 'doc' directory also includes the relevant images,
snippets, and the qdoc files.

Change-Id: Ibc6d0912f8b1e665767e97630b3e5509e10c5710
Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@theqtcompany.com>
Reviewed-by: Topi Reiniö <topi.reinio@digia.com>

1 files changed, 1588 insertions, 0 deletions

diff --git a/src/doc/src/qcircularbuffer.qdoc b/src/doc/src/qcircularbuffer.qdoc
new file mode 100644
index 000000000..080eeab98
--- /dev/null
+++ b/src/doc/src/qcircularbuffer.qdoc
@@ -0,0 +1,1588 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \class Qt3D::QCircularBuffer
+    \inmodule Qt3DCore
+    \brief A template class providing a dynamic circular array.
+
+    \ingroup tools
+    \ingroup shared
+
+    \reentrant
+
+    QCircularBuffer\<T\> is one of Qt's generic \l{container classes}. It
+    stores its items in adjacent memory locations and provides fast
+    index-based access.
+
+    QCircularBuffer\<T\> provides similar functionality as QVector\<T\> and QList\<T\>,
+    but behaves differently when adding items to a full QCircularBuffer. Whereas
+    QVector\<T\> and QList\<T\> will both grow to accommodate the new items,
+    QCircularBuffer\<T\> will overwrite the oldest items. This provides circular
+    behavior to the container, and also means that it can maintain a flat memory
+    profile.
+
+    QCircularBuffer\<T\> also offers performance gains over the other container classes when
+    doing lots of appending or prepending to the buffer, such as in data logging
+    applications. This is because appending (or prepending) an item does not require any
+    extra memory to be allocated, unlike, for example, QVector\<T\> or QList\<T\>.
+    Appending and prepending items to a QCircularBuffer\<T\> is an O(1) operation.
+
+    As with QVector\<T\>, items in QCircularBuffer\<T\> occupy adjacent positions in memory.
+    However, the items may not be located in order in a single array. At times, the internal
+    indices used to store the positions of the first and last items may wrap around as the
+    QCircularBuffer\<T\> is modified. If the index of the last item is greater than the
+    index of the first item, then the buffer is said to be non-linearized.
+
+    Here's an example of a QCircularBuffer that stores integers and a QCircularBuffer
+    that stores QString values:
+
+    \snippet code/src_core_qcircularbuffer.cpp 0
+
+    The above examples create QCircularBuffer objects with a capacity of 0. The capacity
+    is the number of items that can be stored in a QCircularBuffer. The size of a
+    QCircularBuffer object is the number of items that actually are stored in it. Here's
+    an example of creating a QCircularBuffer with a capacity for 200 elements and a size of 0:
+
+    \snippet code/src_core_qcircularbuffer.cpp 1
+
+    By default the QCircularBuffer is empty. If you want to create a circular buffer with
+    unused capacity, pass a size argument to the constructor.
+
+    \snippet code/src_core_qcircularbuffer.cpp 2
+
+    If you wish to fill a subset of the QCircularBuffer with a default value, then you
+    should also pass a size argument to the constructor. The following example creates
+    a QCircularBuffer with a capacity for 200 QString items, and initializes the first 50
+    of them to the value "Qt":
+
+    \snippet code/src_core_qcircularbuffer.cpp 3
+
+    You can also call fill() at any time to fill the QCircularBuffer with a value.
+
+    QCircularBuffer uses 0-based indexes, just like C++ arrays. To access the
+    item at a particular index position, you can use \l{operator[]()}{operator[]}. On
+    non-const buffers, \l{operator[]()}{operator[]} returns a reference to the item
+    that can be used on the left side of an assignment:
+
+    \snippet code/src_core_qcircularbuffer.cpp 4
+
+    For read-only access, an alternative syntax is to use at():
+
+    \snippet code/src_core_qcircularbuffer.cpp 5
+
+    at() can be faster than \l{operator[]()}{operator[]}, because it never causes
+    a \l{deep copy} to occur.
+
+    Another way to access the data stored in a QCircularBuffer is to call data(),
+    or dataOne() and dataTwo() depending on if the buffer is linearized or not.
+    See the discussion in isLinearised() for more information. The data() function
+    returns a Qt3D::QCircularBuffer::array_range object describing the array of items stored
+    in the QCircularBuffer. You can use the pointer in the array_range to
+    directly access and modify the elements stored in the circular buffer. The pointer is also
+    useful if you need to pass a QCircularBuffer to a function that accepts a plain
+    C++ array.
+
+    If the circular buffer is non-linearized, the data() function will
+    linearize it before returning. This can be an expensive operation for large buffers.
+    To avoid this cost, QCircularBuffer also provides alternative methods called
+    dataOne() and dataTwo() that return pointers to the two contiguous arrays used
+    to represent the buffer. dataOne() returns a pointer to the earlier (or oldest)
+    items, and dataTwo() returns a pointer to the later (or newer) items. The dataOne()
+    and dataTwo() functions never cause the circular buffer to be linearized.
+
+    If you wish to pass a C++ array to a function and that function is expensive to call,
+    then you may wish to use the data() method so that you only need to call your
+    expensive function once. If your function is cheap and you have a large circular
+    buffer (so that linearizing it is expensive), then you may wish to use dataOne() and
+    dataTwo() and call your function twice.
+
+    Here is a simple example that shows the semantics of how QCircularBuffer operates:
+
+    \snippet code/src_core_qcircularbuffer.cpp 6
+
+    Notice how appending items to a full buffer overwrites the earliest items.
+
+    If you want to find all occurrences of a particular value in a
+    circular buffer, use indexOf() or lastIndexOf(). The former searches
+    forward starting from a given index position, the latter searches
+    backward. Both return the index of the matching item if they found
+    one; otherwise, they return -1. For example:
+
+    \snippet code/src_core_qcircularbuffer.cpp 7
+
+    If you simply want to check whether a circular buffer contains a
+    particular value, use contains(). If you want to find out how
+    many times a particular value occurs in the circular buffer, use count().
+
+    QCircularBuffer provides these basic functions to add, move, and remove
+    items: insert(), replace(), remove(), prepend(), append(). The insert() and
+    remove() functions can be slow (\l{linear time}) for large circular buffers,
+    because they require moving many items in the circular buffer by one or more positions
+    in memory. The implementation does however take care to minimize the number of
+    items that need to be moved. In the extreme worst case for insert() and remove(),
+    half of the items will be moved in memory. QCircularBuffer also takes care
+    to move items around using the best method available for the type being stored.
+    If your type is movable, then it is best to tell Qt about this by using the
+    Q_DECLARE_TYPEINFO() macro. In such cases memory moves are performed using
+    memmove() rather than calling the copy constructor for each item. If you want
+    a container class that always provides fast insertion/removal in the middle,
+    use QList or QLinkedList instead.
+
+    Unlike plain C++ arrays, QCircularBuffers can be resized at any time by
+    calling resize() or setCapacity(). The resize() function can only allocate
+    items up to the number specified by capacity(). If you wish to alter the
+    capacity of the CircularBuffer, then use setCapacity(). This can be slow as
+    new memory needs to be allocated. It is most common to specify the capacity
+    of the circular buffer in the constructor or immediately after construction,
+    and then simply keep appending to the buffer. If you wish to reclaim any
+    unused memory from the circular buffer, then call squeeze(). This is
+    equivalent to calling setCapacity( size() ).
+
+    Note that using non-const operators and functions can cause
+    QCircularBuffer to do a deep copy of the data. This is due to
+    \l{implicit sharing}.
+
+    QCircularBuffer's value type must be an \l{assignable data type}. This
+    covers most data types that are commonly used, but the compiler
+    won't let you, for example, store a QWidget as a value; instead,
+    store a QWidget *. Some functions have additional requirements;
+    for example, indexOf() and lastIndexOf() expect the value type to
+    support \c operator==().  These requirements are documented on a
+    per-function basis.
+
+    QCircularBuffer provides \l{STL-Style Iterators} (\l {Qt3D::QCircularBuffer::}{const_iterator})
+    and \l {Qt3D::QCircularBuffer::}{iterator}). In practice, these are rarely used,
+    because you can use indexes into the QCircularBuffer.
+
+    QCircularBuffer does \e not support inserting, prepending, appending, or
+    replacing with references to its own values. Doing so will cause your
+    application to abort with an error message.
+
+    \sa Qt3D::QCircularBuffer::iterator, Qt3D::QCircularBuffer::const_iterator,
+    QVector, QList, QLinkedList
+*/
+
+/*! \fn Qt3D::QCircularBuffer::QCircularBuffer()
+
+    Constructs an empty circular buffer with zero capacity.
+
+    \sa resize(), setCapacity()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::QCircularBuffer(int capacity)
+
+    Constructs an empty circular buffer with an initial capacity of \a capacity
+    elements.
+
+    \sa resize(), setCapacity()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::QCircularBuffer(int capacity, const T &value)
+
+    Constructs a circular buffer with an initial capacity and size of
+    \a capacity elements.
+
+    The elements are initialized to \a value.
+
+    \sa resize(), setCapacity(), fill()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::QCircularBuffer(int capacity, int size, const T &value)
+
+    Constructs a circular buffer with an initial capacity of \a capacity
+    elements and initial size of \a size elements.
+
+    The first \a size elements are initialized to \a value.
+
+    \sa resize(), setCapacity(), fill()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::QCircularBuffer(const QCircularBuffer<T> &other)
+
+    Constructs a copy of \a other.
+
+    This operation takes \l{constant time}, because QCircularBuffer is
+    \l{implicitly shared}. This makes returning a QCircularBuffer from a
+    function very fast. If a shared instance is modified, it will be
+    copied (copy-on-write), and that takes \l{linear time}.
+
+    \sa operator=()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::~QCircularBuffer()
+
+    Destroys the circular buffer.
+*/
+
+/*! \fn QCircularBuffer &Qt3D::QCircularBuffer::operator=(const QCircularBuffer<T> &other)
+
+    Assigns \a other to this circular buffer and returns a reference to this
+    circular buffer.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::begin()
+
+    Returns an \l{STL-Style iterators}{STL-style iterator} pointing to the first item in
+    the circular buffer.
+
+    \sa constBegin(), end()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator Qt3D::QCircularBuffer::begin() const
+
+    \overload
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator Qt3D::QCircularBuffer::constBegin() const
+
+    Returns a const \l{STL-Style Iterators}{STL-style iterator} pointing to the first item in
+    the circular buffer.
+
+    \sa begin(), constEnd()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::end()
+
+    Returns an \l {STL-Style Iterators} {STL-style iterator} pointing to the imaginary item
+    after the last item in the circular buffer.
+
+    \sa begin(), constEnd()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator Qt3D::QCircularBuffer::end() const
+
+    \overload
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator Qt3D::QCircularBuffer::constEnd() const
+
+    Returns a const \l{STL-Style Iterators} {STL-style iterator} pointing to the imaginary item
+    after the last item in the circular buffer.
+
+    \sa constBegin(), end()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::erase(const_iterator pos)
+
+    Removes the item pointed to by the iterator \a pos from the
+    circular buffer, and returns an iterator to the next item in the circular
+    buffer (which may be end()).
+
+    \sa insert(), remove()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::erase(const_iterator begin, const_iterator end)
+
+    \overload
+
+    Removes all the items from \a begin up to (but not including) \a
+    end. Returns an iterator to the same item that \a end referred to
+    before the call.
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::push_back(const T &value)
+
+    This function is provided for STL compatibility. It is equivalent
+    to append(\a value).
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::push_front(const T &value)
+
+    This function is provided for STL compatibility. It is equivalent
+    to prepend(\a value).
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::pop_back()
+
+    This function is provided for STL compatibility. It is equivalent
+    to erase(end() - 1).
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::pop_front()
+
+    This function is provided for STL compatibility. It is equivalent
+    to erase(begin()).
+*/
+
+/*! \fn bool Qt3D::QCircularBuffer::empty() const
+
+    This function is provided for STL compatibility. It is equivalent
+    to isEmpty(), returning true if the circular buffer is empty; otherwise
+    returns false.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::reference Qt3D::QCircularBuffer::front()
+
+    This function is provided for STL compatibility. It is equivalent
+    to first().
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_reference Qt3D::QCircularBuffer::front() const
+
+    \overload
+*/
+
+/*! \fn Qt3D::QCircularBuffer::reference Qt3D::QCircularBuffer::back()
+
+    This function is provided for STL compatibility. It is equivalent
+    to last().
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_reference Qt3D::QCircularBuffer::back() const
+
+    \overload
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::refCount() const
+
+    Returns the number of shallow copies that exist of this circular buffer.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::append(const T &value)
+
+    Inserts \a value at the end of the circular buffer. If the circular buffer
+    is full, then the oldest element is overwritten.
+
+    Example:
+    \snippet code/src_core_qcircularbuffer.cpp 8
+
+    This operation is very fast, because QCircularBuffer never allocates
+    memory in this function.
+
+    \sa operator<<(), operator+=(), prepend(), insert()
+*/
+
+/*! \fn const T &Qt3D::QCircularBuffer::at(int i) const
+
+    Returns the item at index position \a i in the circular buffer.
+
+    \a i must be a valid index position in the circular buffer
+    (i.e., 0 <= \a i < size()).
+
+    \sa value(), operator[]()
+*/
+
+/*! \fn T &Qt3D::QCircularBuffer::operator[](int i)
+
+    Returns the item at index position \a i as a modifiable reference.
+
+    \a i must be a valid index position in the circular buffer (i.e., 0 <= \a i
+    < size()).
+
+    Note that using non-const operators can cause QCircularBuffer to do a deep
+    copy.
+
+    \sa at(), value()
+*/
+
+/*! \fn const T &Qt3D::QCircularBuffer::operator[](int i) const
+
+    \overload
+
+    Same as at(\a i).
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::capacity() const
+
+    Returns the maximum number of elements that can be stored in
+    the circular buffer.
+
+    \sa setCapacity(), size()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::clear()
+
+    Removes all elements from the circular buffer so that the size is
+    zero. The capacity is unchanged.
+
+    \sa isEmpty()
+*/
+
+/*! \fn bool Qt3D::QCircularBuffer::contains(const T &value) const
+
+    Returns true if the circular buffer contains an occurrence of \a value;
+    otherwise returns false.
+
+    This function requires the value type to have an implementation of
+    \c operator==().
+
+    \sa indexOf(), count()
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::count(const T &value) const
+
+    Returns the number of occurrences of \a value in the circular buffer.
+
+    This function requires the value type to have an implementation of
+    \c operator==().
+
+    \sa contains(), indexOf()
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::count() const
+
+    \overload
+
+    Same as size().
+*/
+
+/*! \fn Qt3D::QCircularBuffer::array_range Qt3D::QCircularBuffer::data()
+
+    Returns a Qt3D::QCircularBuffer::array_range describing the internal array of data. If
+    the circular buffer is non-linearized, then this function causes it to be
+    linearized. If the cost of linearisation is too high for your use case, then
+    you should consider using the dataOne() and dataTwo() functions instead.
+
+    If the circular buffer is empty then the pointer and array size returned
+    will both be 0.
+
+    \sa constData(), dataOne(), dataTwo(), isLinearised()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_array_range Qt3D::QCircularBuffer::data() const
+
+    \overload
+
+    If the circular buffer is non-linearized then the pointer and array size
+    returned will both be 0 since linearising the circular buffer would break
+    constness.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_array_range Qt3D::QCircularBuffer::constData() const
+
+    Returns a Qt3D::QCircularBuffer::const_array_range describing the internal array of
+    data.
+
+    If the circular buffer is non-linearized then the pointer and array size
+    returned will both be 0 since linearising the circular buffer would break
+    constness.
+
+    If the circular buffer is empty then the pointer and array size returned
+    will both be 0.
+
+    \sa data(), constDataOne(), constDataTwo(), isLinearised()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::array_range Qt3D::QCircularBuffer::dataOne()
+
+    Returns a Qt3D::QCircularBuffer::array_range describing the first internal array of
+    contiguous data. If the circular buffer is linearized, then this function is
+    equivalent to calling data(). If the circular buffer is non-linearized then
+    the returned array range will describe a subset of the data contained in the
+    circular buffer. This subset will consist of the earliest (lowest index) items
+    in the buffer. To obtain a Qt3D::QCircularBuffer::array_range for the remainder
+    of the data, use the dataTwo() function.
+
+    If the circular buffer is empty, then the pointer and array size returned
+    will both be 0.
+
+    \sa constDataOne(), dataTwo(), data(), isLinearised()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_array_range Qt3D::QCircularBuffer::dataOne() const
+
+    \overload
+
+    Unlike data() this function always returns a valid Qt3D::QCircularBuffer::const_array_range
+    (unless the circular buffer is empty).
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_array_range Qt3D::QCircularBuffer::constDataOne() const
+
+    Returns a Qt3D::QCircularBuffer::const_array_range describing the first internal array of
+    contiguous data. If the circular buffer is linearized, then this function is
+    equivalent to calling constData(). If the circular buffer is non-linearized, then
+    the returned array range will describe a subset of the data contained in the
+    circular buffer. This subset will consist of the earliest (lowest index) items
+    in the buffer. To obtain a Qt3D::QCircularBuffer::const_array_range for the remainder
+    of the data, use the constDataTwo() function.
+
+    If the circular buffer is empty, then the pointer and array size returned
+    will both be 0.
+
+    \sa dataOne(), constDataTwo(), constData(), isLinearised()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::array_range Qt3D::QCircularBuffer::dataTwo()
+
+    Returns a Qt3D::QCircularBuffer::array_range describing the first internal array of
+    contiguous data. If the circular buffer is linearized, then the pointer and array size
+    returned will both be 0 since all the data will be contained in the array
+    described by calling the dataOne() function.
+
+    \sa dataOne(), constDataTwo(), data(), isLinearised()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_array_range Qt3D::QCircularBuffer::dataTwo() const
+
+    \overload
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_array_range Qt3D::QCircularBuffer::constDataTwo() const
+
+    Returns a Qt3D::QCircularBuffer::const_array_range describing the first internal array of
+    contiguous data. If the circular buffer is linearized, then the pointer and array size
+    returned will both be 0 since all the data will be contained in the array
+    described by calling the dataOne() function.
+
+    \sa constDataOne(), dataTwo(), constData(), isLinearised()
+*/
+
+/*! \fn bool Qt3D::QCircularBuffer::endsWith(const T &value) const
+
+    Returns true if this circular buffer is not empty and its last
+    item is equal to \a value; otherwise returns false.
+
+    \sa isEmpty(), last(), startsWith()
+*/
+
+/*! \fn QCircularBuffer<T>& Qt3D::QCircularBuffer::fill(const T &value, int size = -1)
+
+    Assigns \a value to all items in the circular buffer. If \a size is
+    different from -1 (the default), the circular buffer is resized to size \a
+    size beforehand (size must be less than or equal to the capacity).
+
+    This function also linearizes the circular buffer.
+
+    Example:
+    \snippet code/src_core_qcircularbuffer.cpp 14
+
+    \sa resize()
+*/
+
+/*! \fn T &Qt3D::QCircularBuffer::first()
+
+    Returns a reference to the first item in the circular buffer. This
+    function assumes that the circular buffer isn't empty.
+
+    \sa last(), isEmpty()
+*/
+
+/*! \fn const T &Qt3D::QCircularBuffer::first() const
+
+    \overload
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::freeSize() const
+
+    Returns the number of items that can be added to the circular buffer
+    without causing the earliest item to be overwritten. It is equivalent
+    to (capacity() - size()).
+
+    \sa sizeAvailable(), capacity(), isEmpty(), isFull(), size()
+*/
+
+/*! \fn static QCircularBuffer<T> Qt3D::QCircularBuffer::fromList(const QList<T>& list)
+
+    Returns a QCircularBuffer object with the data contained in \a list. The
+    capacity and size of the circular buffer will be equal to the size of
+    \a list.
+
+    Example:
+    \snippet code/src_core_qcircularbuffer.cpp 18
+
+    \sa fromVector(), toList(), toVector()
+*/
+
+/*! \fn static QCircularBuffer<T> Qt3D::QCircularBuffer::fromVector(const QVector<T>& vector)
+
+    Returns a QCircularBuffer object with the data contained in \a vector. The
+    capacity and size of the circular buffer will be equal to the size of
+    \a vector.
+
+    \sa fromList(), toVector(), toList()
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::indexOf(const T &value, int from = 0) const
+
+    Returns the index position of the first occurrence of \a value in
+    the circular buffer, searching forward from index position \a from.
+    Returns -1 if no item matched.
+
+    Example:
+    \snippet code/src_core_qcircularbuffer.cpp 15
+
+    This function requires the value type to have an implementation of
+    \c operator==().
+
+    \sa lastIndexOf(), contains()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::insert(int i, const T &value)
+
+    Inserts \a value at index position \a i in the circular buffer.
+    If \a i is 0, the value is prepended to the circular buffer. If \a i
+    is size(), the value is appended to the circular buffer. The capacity
+    of the circular buffer is not changed.
+
+    Example:
+    \snippet code/src_core_qcircularbuffer.cpp 11
+
+    Using this function is equivalent to calling insert(i, 1, value). See the
+    discussion there for more information.
+
+    Items at indexes i and higher are shifted along by one. If the circular
+    buffer is full then the earliest item will be overwritten. Note that this
+    has the non-obvious behavior that calling insert(0,value) on a circular
+    buffer that is already full will effectively do nothing since the newly
+    prepended item will immediately be overwritten by the highest item as it
+    is shifted along one position.
+
+    For large circular buffers, this operation can be slow (\l{linear time}),
+    because it requires moving all the items at indexes \a i and
+    above (or all items below index i depending upon where in the circular buffer
+    the new item is inserted) by one position in memory. If you
+    want a container class that provides a fast insert() function, use
+    QLinkedList instead.
+
+    If the capacity() is zero, then nothing will be inserted.
+
+    \sa append(), prepend(), remove()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::insert(int i, int count, const T &value)
+
+    \overload
+
+    Inserts \a value at index position \a i in the circular buffer.
+    If \a i is 0, the value is prepended to the circular buffer. If \a i
+    is size(), the value is appended to the circular buffer. The capacity
+    of the circular buffer is not changed.
+
+    Items at indexes i and higher are shifted along by one. If the circular
+    buffer has freeSize() < \a count, then the earliest items will be overwritten.
+
+    The actual number of items that get inserted may not always be equal to
+    \a count since this function preserves the capacity of the circular buffer,
+    and since items at indexes i and higher are shifted along by one.
+    The actual number of items inserted is min(\a count, \a i + freeSize()).
+
+    For the same reasons, the number of items that get overwritten at the
+    start of the circular buffer is min(\a i, max(0, \a count - freeSize())).
+
+    Example:
+    \snippet code/src_core_qcircularbuffer.cpp 12
+
+    For large circular buffers, this operation can be slow (\l{linear time}),
+    because it requires moving all the items at indexes \a i and
+    above (or all items below index i depending upon where in the circular buffer
+    the new item is inserted) in memory. If you want a container class that
+    provides a fast insert() function, use QLinkedList instead.
+
+    If the capacity() is zero, then nothing will be inserted.
+
+    \sa append(), prepend(), remove()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::insert(const_iterator before, int count, const T &value)
+
+    \overload
+
+    Inserts up to \a count items with value \a value in front of the item
+    pointed to by the iterator \a before in the circular buffer. Returns an
+    iterator pointing at the first of the inserted items.
+
+    \sa append(), prepend(), remove()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::insert(const_iterator before, const T &value)
+
+    \overload
+
+    Inserts \a value in front of the item pointed to by the iterator \a before.
+    Returns an iterator pointing at the inserted item.
+
+    \sa append(), prepend(), remove()
+*/
+
+/*! \fn bool Qt3D::QCircularBuffer::isEmpty() const
+
+    Returns true if the circular buffer has size 0; otherwise returns false.
+
+    \sa capacity(), resize(), setCapacity(), size()
+*/
+
+/*! \fn bool Qt3D::QCircularBuffer::isFull() const
+
+    Returns true if the circular buffer is full ie if size() == capacity(); otherwise returns false.
+
+    \sa capacity(), resize(), setCapacity(), size()
+*/
+
+/*! \fn bool Qt3D::QCircularBuffer::isLinearised() const
+
+    Returns true if the circular buffer is linearized; otherwise returns false.
+
+    A circular buffer is said to be linearized if the position of the first
+    item in the internal array occurs before the position of the last item. A
+    little more explanation is provided for clarification.
+
+    Internally, QCircularBuffer stores the items in a plain C++ array.
+    Additionally, the positions in the array of the first and last items of
+    the circular buffer are also stored (along with the capacity and size).
+
+    Imagine a circular buffer of capacity 6 created and populated with the
+    following code:
+
+    \snippet code/src_core_qcircularbuffer.cpp 19
+
+    After executing the above code, the internal state of the circular buffer
+    would look like this:
+
+    \img circularbuffer-1.png
+
+    As you can see, the internal array has been populated from the beginning.
+    The first item is located as position 0 in the array and the last item
+    is located at position 4 in the array. The circular buffer is linearized
+    because the last item occurs later in the array than the first item.
+
+    If we now append another item to the circular buffer with:
+
+    \snippet code/src_core_qcircularbuffer.cpp 20
+
+    the internal representation then becomes:
+
+    \img circularbuffer-2.png
+
+    The circular buffer is still linearized, but it is now full. Appending
+    further items will cause the oldest item to be overwritten. For example,
+
+    \snippet code/src_core_qcircularbuffer.cpp 21
+
+    causes the internal representation to become:
+
+    \img circularbuffer-3.png
+
+    We see that the oldest item (1) has been overwritten by the newest item
+    (7), and that the first and last indexes have been adjusted accordingly.
+    The circular buffer is now said to be non-linearized because the position
+    of the last item is before the position of the first item.
+
+    The circular buffer can always be linearized by calling the linearise()
+    function. This can be an expensive operation (\l{linear time}) for large
+    circular buffers since new memory has to be allocated, the items copied across,
+    and the original memory deallocated.
+
+    If you need to directly access the items stored in a circular buffer,
+    (perhaps for a plain C++ function call) then you can use the data()
+    function. If the circular buffer is non-linearized, then the data()
+    function will linearize it for you before returning a
+    Qt3D::QCircularBuffer::array_range describing the array.
+
+    To prevent the cost of the linearisation process, you can instead
+    call the dataOne() and dataTwo() functions to obtain the two arrays
+    used to represent a non-linearized circular buffer. After running the
+    above sample code, calling the dataOne() function would return an
+    array_range object describing the values 2-6, and the dataTwo() function
+    would return an array_range object describing the value 7. Sometimes,
+    accessing the items via the two arrays described by dataOne() and dataTwo(),
+    can be quicker than calling data() and having the circular buffer
+    linearized. The dataOne() and dataTwo() functions do not trigger a
+    linearization.
+
+    \sa linearise(), data(), dataOne(), dataTwo()
+*/
+
+/*! \fn T &Qt3D::QCircularBuffer::last()
+
+    Returns a reference to the last item in the circular buffer. This
+    function assumes that the circular buffer isn't empty.
+
+    \sa first(), isEmpty()
+*/
+
+/*! \fn const T &Qt3D::QCircularBuffer::last() const
+
+    \overload
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::lastIndexOf(const T &value, int from = -1) const
+
+    Returns the index position of the last occurrence of the value \a
+    value in the circular buffer, searching backward from index position \a
+    from. If \a from is -1 (the default), the search starts at the
+    last item. Returns -1 if no item is matched.
+
+    Example:
+    \snippet code/src_core_qcircularbuffer.cpp 16
+
+    This function requires the value type to have an implementation of
+    \c operator==().
+
+    \sa indexOf()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::linearise()
+
+    Linearizes the internal representation of the circular buffer such that
+    all items are stored in a single contiguous array.
+
+    This function can be expensive for large circular buffers (\l{linear time}).
+
+    \sa isLinearised()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::prepend(const T &value)
+
+    Inserts \a value at the beginning of the circular buffer. If the circular buffer
+    is full, then the highest index item is overwritten.
+
+    Example:
+    \snippet code/src_core_qcircularbuffer.cpp 10
+
+    This operation is very fast, because QCircularBuffer never allocates
+    memory in this function.
+
+    \sa operator<<(), operator+=(), append(), insert()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::remove(int i)
+
+    Removes the element at index position \a i.
+
+    \sa insert(), replace(), fill()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::remove(int i, int count)
+
+    \overload
+
+    Removes \a count elements from the middle of the circular buffer,
+    starting at index position \a i.
+
+    \sa insert(), replace(), fill()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::replace(int i, const T &value)
+
+    Replaces the item at index position \a i with \a value.
+
+    \a i must be a valid index position in the circular buffer (i.e., 0 <= \a
+    i < size()).
+
+    \sa operator[](), remove()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::reserve(int capacity)
+
+    Sets the capacity of the circular buffer to \a capacity. It is a synonym for
+    setCapacity().
+
+    \sa setCapacity()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::resize(int size)
+
+    Changes the size of the circular buffer to \a size which must be > 0 and
+    <= capacity(). If \a size is less than the old size, then the highest indexed
+    items are removed. If \a size is greater than the old size, then new items
+    with a \l{default-constructed value} are appended to the end of the circular
+    buffer.
+
+    \sa size(), insert(), remove(), capacity(), setCapacity()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::setCapacity(int capacity)
+
+    Sets the capacity of the circular buffer to \a capacity.
+
+    \sa reserve(), capacity()
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::size() const
+
+    Returns the number of items in the circular buffer.
+
+    \sa sizeAvailable(), capacity(), resize()
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::sizeAvailable() const
+
+    Returns the number of items that can be added to the circular buffer
+    without causing the earliest item to be overwritten. It is equivalent
+    to (capacity() - size()).
+
+    \sa capacity(), isEmpty(), isFull(), size(), freeSize()
+*/
+
+/*! \fn void Qt3D::QCircularBuffer::squeeze()
+
+    Releases any unused memory from the circular buffer. It is equivalent
+    to calling setCapacity(size()).
+
+    \sa setCapacity(), size(), resize(), sizeAvailable()
+*/
+
+/*! \fn bool Qt3D::QCircularBuffer::startsWith(const T &value) const
+
+    Returns true if the circular buffer is not empty and its first
+    item is equal to \a value; otherwise returns false.
+
+    \sa isEmpty(), first(), endsWith()
+*/
+
+/*! \fn QList<T> Qt3D::QCircularBuffer::toList() const
+
+    Returns a QList object with the data contained in this QCircularBuffer.
+
+    Example:
+
+    \snippet code/src_core_qcircularbuffer.cpp 17
+
+    \sa fromList(), toVector()
+*/
+
+/*! \fn QVector<T> Qt3D::QCircularBuffer::toVector() const
+
+    Returns a QVector object with the data contained in this QCircularBuffer.
+
+    \sa fromVector(), toList()
+*/
+
+/*! \fn T Qt3D::QCircularBuffer::value(int i) const
+
+    Returns the value at index position \a i in the circular buffer.
+
+    If the index \a i is out of bounds, the function returns
+    a \l{default-constructed value}. If you are certain that
+    \a i is within bounds, you can use at() instead, which is slightly
+    faster.
+
+    \sa at(), operator[]()
+*/
+
+/*! \fn T Qt3D::QCircularBuffer::value(int i, const T &defaultValue) const
+
+    \overload
+
+    If the index \a i is out of bounds, the function returns
+    \a defaultValue.
+*/
+
+/*! \fn bool Qt3D::operator==(const QCircularBuffer<T> &lhs, const QCircularBuffer<T> &rhs)
+
+    Returns true if the circular buffer \a lhs is equal to \a rhs; otherwise
+    returns false.
+
+    Two circular buffers are considered equal if they contain the same values
+    in the same order and have the same capacity.
+
+    This function requires the value type to have an implementation
+    of \c operator==().
+
+    \sa operator!=()
+*/
+
+/*! \fn bool Qt3D::operator!=(const QCircularBuffer<T> &lhs, const QCircularBuffer<T> &rhs)
+
+    Returns true if the circular buffer \a lhs is not equal to \a rhs; otherwise
+    returns false.
+
+    Two circular buffers are considered equal if they contain the same values
+    in the same order and have the same capacity.
+
+    This function requires the value type to have an implementation
+    of \c operator==().
+
+    \sa operator==()
+*/
+
+/*! \fn Qt3D::QCircularBuffer<T>& Qt3D::QCircularBuffer::operator+=(const T &other)
+
+    Appends the item \a other to this circular buffer and returns a
+    reference to this circular buffer.
+
+    \sa operator+(), operator<<(), append()
+*/
+
+/*! \fn Qt3D::QCircularBuffer<T>& Qt3D::QCircularBuffer::operator+=(const QCircularBuffer<T>& other)
+
+    \overload
+
+    Appends the items of the \a other circular buffer to this circular
+    buffer and returns a reference to this circular buffer.
+
+    \sa operator+(), operator<<(), append()
+*/
+
+/*! \fn Qt3D::QCircularBuffer<T>& Qt3D::QCircularBuffer::operator+=(const QVector<T>& other)
+
+    \overload
+*/
+
+/*! \fn Qt3D::QCircularBuffer<T>& Qt3D::QCircularBuffer::operator+=(const QList<T>& other)
+
+    \overload
+*/
+
+/*! \fn Qt3D::QCircularBuffer<T>& Qt3D::QCircularBuffer::operator<<(const T &other)
+
+    Appends the item \a other to this circular buffer and returns a
+    reference to this circular buffer.
+
+    \sa operator+(), operator+=(), append()
+*/
+
+/*! \fn Qt3D::QCircularBuffer<T>& Qt3D::QCircularBuffer::operator<<(const QCircularBuffer<T>& other)
+
+    \overload
+
+    Appends the items of the \a other circular buffer to this circular
+    buffer and returns a reference to this circular buffer.
+
+    \sa operator+(), operator+=(), append()
+*/
+
+/*! \fn Qt3D::QCircularBuffer<T>& Qt3D::QCircularBuffer::operator<<(const QVector<T>& other)
+
+    \overload
+*/
+
+/*! \fn Qt3D::QCircularBuffer<T>& Qt3D::QCircularBuffer::operator<<(const QList<T>& other)
+
+    \overload
+*/
+
+/*! \fn Qt3D::QCircularBuffer<T> Qt3D::operator+(const QCircularBuffer<T>& lhs, const QCircularBuffer<T>& rhs)
+
+    Returns a circular buffer object with capacity of lhs.size() + rhs.size() containing
+    the items from \a lhs followed by the items from \a rhs.
+
+    \sa Qt3D::QCircularBuffer::operator+=()
+*/
+
+/*! \fn void Qt3D::swap(QCircularBuffer<T> &lhs, QCircularBuffer<T> &rhs)
+
+    Swaps the contents of the circular buffer \a lhs with the contents of \a rhs.
+*/
+
+/*! \fn bool Qt3D::operator<(const QCircularBuffer<T> &lhs, const QCircularBuffer<T> &rhs)
+
+    Returns true if \a lhs is lexographically less than \a rhs. This is equivalent to calling
+    \c{return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end())}.
+*/
+
+/*! \fn bool Qt3D::operator>(const QCircularBuffer<T> &lhs, const QCircularBuffer<T> &rhs)
+
+    Returns true if \a rhs is lexographically less than \a lhs.
+*/
+
+/*! \fn bool Qt3D::operator>=(const QCircularBuffer<T> &lhs, const QCircularBuffer<T> &rhs)
+
+    Returns true if \a lhs is lexographically less than or equal to \a rhs.
+*/
+
+/*! \fn bool Qt3D::operator<=(const QCircularBuffer<T> &lhs, const QCircularBuffer<T> &rhs)
+
+    Returns true if \a lhs is lexographically less than or equal to \a rhs.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::Iterator
+
+    Qt-style synonym for Qt3D::QCircularBuffer::iterator.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::ConstIterator
+
+    Qt-style synonym for Qt3D::QCircularBuffer::const_iterator.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::const_pointer
+
+    Typedef for const T *. Provided for STL compatibility.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::const_reference
+
+    Typedef for T &. Provided for STL compatibility.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::difference_type
+
+    Typedef for ptrdiff_t. Provided for STL compatibility.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::pointer
+
+    Typedef for T *. Provided for STL compatibility.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::reference
+
+    Typedef for T &. Provided for STL compatibility.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::size_type
+
+    Typedef for int. Provided for STL compatibility.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::value_type
+
+    Typedef for T. Provided for STL compatibility.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::array_range
+
+    Typedef for QPair<T*,int>. The first element is a pointer to the
+    first element of an array of T. The second element is the number
+    of elements in the array.
+
+    \sa data(), dataOne(), dataTwo()
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::const_array_range
+
+    Typedef for QPair<const T*,int>. The first element is a pointer to the
+    first element of an array of const T. The second element is the number
+    of elements in the array.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::ArrayRange
+
+    Qt-style synonym for Qt3D::QCircularBuffer::array_range.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::ConstArrayRange
+
+    Qt-style synonym for Qt3D::QCircularBuffer::const_array_range.
+*/
+
+
+/*! \class Qt3D::QCircularBuffer::iterator
+    \inmodule Qt3DCore
+    \brief The Qt3D::QCircularBuffer::iterator class provides an STL-style non-const iterator for QCircularBuffer.
+
+    QCircularBuffer provides both \l{STL-Style Iterators} and \l{Java-Style
+    Iterators}.
+
+    \sa Qt3D::QCircularBuffer::begin(), Qt3D::QCircularBuffer::end(),
+    Qt3D::QCircularBuffer::const_iterator
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::iterator::iterator_category
+
+    A synonym for \e {std::random_access_iterator_tag} indicating
+    this iterator is a random access iterator.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::iterator::difference_type
+
+    \internal
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::iterator::value_type
+
+    \internal
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::iterator::pointer
+
+    \internal
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::iterator::reference
+
+    \internal
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator::iterator()
+
+    Constructs an uninitialized iterator.
+
+    Functions like operator*() and operator++() should not be called
+    on an uninitialized iterator. Use operator=() to assign a value
+    to it before using it.
+
+    \sa Qt3D::QCircularBuffer::begin() Qt3D::QCircularBuffer::end()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator::iterator(QCircularBuffer<T> *buffer, int index)
+
+    \internal
+*/
+
+/*! \fn T &Qt3D::QCircularBuffer::iterator::operator*() const
+
+    Returns a modifiable reference to the current item.
+
+    You can change the value of an item by using operator*() on the
+    left side of an assignment.
+
+    \sa operator->()
+*/
+
+/*! \fn T *Qt3D::QCircularBuffer::iterator::operator->() const
+
+    Returns a pointer to the current item.
+
+    \sa operator*()
+*/
+
+/*! \fn T &Qt3D::QCircularBuffer::iterator::operator[](int j) const
+
+    Returns a modifiable reference to the item at position *this +
+    \a{j}.
+
+    This function is provided to make QCircularBuffer iterators behave like C++
+    pointers.
+
+    \sa operator+()
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::iterator::operator==(const iterator &other) const
+
+    Returns true if \a other points to the same item as this
+    iterator; otherwise returns false.
+
+    \sa operator!=()
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::iterator::operator!=(const iterator &other) const
+
+    Returns true if \a other points to a different item than this
+    iterator; otherwise returns false.
+
+    \sa operator==()
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::iterator::operator<(const iterator& other) const
+
+    Returns true if the item pointed to by this iterator occurs before
+    the item pointed to by the \a other iterator.
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::iterator::operator<=(const iterator& other) const
+
+    Returns true if the item pointed to by this iterator occurs before
+    or at the same position as the item pointed to by the \a other iterator.
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::iterator::operator>(const iterator& other) const
+
+    Returns true if the item pointed to by this iterator occurs after
+    the item pointed to by the \a other iterator.
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::iterator::operator>=(const iterator& other) const
+
+    Returns true if the item pointed to by this iterator occurs after
+    or at the same position as the item pointed to by the \a other iterator.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator &Qt3D::QCircularBuffer::iterator::operator++()
+
+    The prefix ++ operator (\c{++it}) advances the iterator to the
+    next item in the circular buffer and returns an iterator to the new current
+    item.
+
+    Calling this function on Qt3D::QCircularBuffer::end() leads to undefined results.
+
+    \sa operator--()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::iterator::operator++(int)
+
+    \overload
+
+    The postfix ++ operator (\c{it++}) advances the iterator to the
+    next item in the circular buffer and returns an iterator to the previously
+    current item.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator &Qt3D::QCircularBuffer::iterator::operator--()
+
+    The prefix -- operator (\c{--it}) makes the preceding item
+    the current item, and returns an iterator to the new current item.
+
+    Calling this function on Qt3D::QCircularBuffer::begin() leads to undefined results.
+
+    \sa operator++()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::iterator::operator--(int)
+
+    \overload
+
+    The postfix -- operator (\c{it--}) makes the preceding item
+    the current item, and returns an iterator to the previously current item.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator &Qt3D::QCircularBuffer::iterator::operator+=(int j)
+
+    Advances the iterator by \a j items. (If \a j is negative, the
+    iterator goes backward.)
+
+    \sa operator-=(), operator+()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator &Qt3D::QCircularBuffer::iterator::operator-=(int j)
+
+    Makes the iterator go back by \a j items. (If \a j is negative,
+    the iterator goes forward.)
+
+    \sa operator+=(), operator-()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::iterator::operator+(int j) const
+
+    Returns an iterator to the item at \a j positions forward from
+    this iterator. (If \a j is negative, the iterator goes backward.)
+
+    \sa operator-(), operator+=()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::iterator Qt3D::QCircularBuffer::iterator::operator-(int j) const
+
+    Returns an iterator to the item at \a j positions backward from
+    this iterator. (If \a j is negative, the iterator goes forward.)
+
+    \sa operator+(), operator-=()
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::iterator::operator-(iterator other) const
+
+    Returns the number of items between the item pointed to by \a
+    other and the item pointed to by this iterator.
+*/
+
+
+/*! \class Qt3D::QCircularBuffer::const_iterator
+    \inmodule Qt3DCore
+    \brief The Qt3D::QCircularBuffer::const_iterator class provides an STL-style const iterator for QCircularBuffer.
+
+    QCircularBuffer provides both \l{STL-Style Iterators} and \l{Java-Style
+    Iterators}.
+
+    \sa Qt3D::QCircularBuffer::constBegin(), Qt3D::QCircularBuffer::constEnd(),
+    Qt3D::QCircularBuffer::iterator
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::const_iterator::iterator_category
+
+    A synonym for \e {std::random_access_iterator_tag} indicating
+    this iterator is a random access iterator.
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::const_iterator::difference_type
+
+    \internal
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::const_iterator::value_type
+
+    \internal
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::const_iterator::pointer
+
+    \internal
+*/
+
+/*! \typedef Qt3D::QCircularBuffer::const_iterator::reference
+
+    \internal
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator::const_iterator()
+
+    Constructs an uninitialized const iterator.
+
+    Functions like operator*() and operator++() should not be called
+    on an uninitialized iterator. Use operator=() to assign a value
+    to it before using it.
+
+    \sa Qt3D::QCircularBuffer::begin() Qt3D::QCircularBuffer::end()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator::const_iterator(const iterator &other)
+
+    \internal
+*/
+
+/*! \fn const T &Qt3D::QCircularBuffer::const_iterator::operator*() const
+
+    Returns a const reference to the current item.
+
+    \sa operator->()
+*/
+
+/*! \fn const T *Qt3D::QCircularBuffer::const_iterator::operator->() const
+
+    Returns a pointer to the current item.
+
+    \sa operator*()
+*/
+
+/*! \fn const T &Qt3D::QCircularBuffer::const_iterator::operator[](int j) const
+
+    Returns a const reference to the item at position *this +
+    \a{j}.
+
+    This function is provided to make QCircularBuffer iterators behave like C++
+    pointers.
+
+    \sa operator+()
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::const_iterator::operator==(const const_iterator &other) const
+
+    Returns true if \a other points to the same item as this
+    iterator; otherwise returns false.
+
+    \sa operator!=()
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::const_iterator::operator!=(const const_iterator &other) const
+
+    Returns true if \a other points to a different item than this
+    iterator; otherwise returns false.
+
+    \sa operator==()
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::const_iterator::operator<(const const_iterator& other) const
+
+    Returns true if the item pointed to by this iterator occurs before
+    the item pointed to by the \a other iterator.
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::const_iterator::operator<=(const const_iterator& other) const
+
+    Returns true if the item pointed to by this iterator occurs before,
+    or at the same position as the item pointed to by the \a other iterator.
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::const_iterator::operator>(const const_iterator& other) const
+
+    Returns true if the item pointed to by this iterator occurs after
+    the item pointed to by the \a other iterator.
+*/
+
+/*!
+    \fn bool Qt3D::QCircularBuffer::const_iterator::operator>=(const const_iterator& other) const
+
+    Returns true if the item pointed to by this iterator occurs after,
+    or at the same position as the item pointed to by the \a other iterator.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator &Qt3D::QCircularBuffer::const_iterator::operator++()
+
+    The prefix ++ operator (\c{++it}) advances the iterator to the
+    next item in the circular buffer and returns an iterator to the new current
+    item.
+
+    Calling this function on Qt3D::QCircularBuffer::constEnd() leads to undefined results.
+
+    \sa operator--()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator Qt3D::QCircularBuffer::const_iterator::operator++(int)
+
+    \overload
+
+    The postfix ++ operator (\c{it++}) advances the iterator to the
+    next item in the circular buffer and returns an iterator to the previously
+    current item.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator &Qt3D::QCircularBuffer::const_iterator::operator--()
+
+    The prefix -- operator (\c{--it}) makes the preceding item the
+    current and returns an iterator to the new current item.
+
+    Calling this function on Qt3D::QCircularBuffer::constBegin() leads to undefined results.
+
+    \sa operator++()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator Qt3D::QCircularBuffer::const_iterator::operator--(int)
+
+    \overload
+
+    The postfix -- operator (\c{it--}) makes the preceding item the
+    current and returns an iterator to the previously current item.
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator &Qt3D::QCircularBuffer::const_iterator::operator+=(int j)
+
+    Advances the iterator by \a j items. (If \a j is negative, the
+    iterator goes backward.)
+
+    \sa operator-=(), operator+()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator &Qt3D::QCircularBuffer::const_iterator::operator-=(int j)
+
+    Makes the iterator go back by \a j items. (If \a j is negative,
+    the iterator goes forward.)
+
+    \sa operator+=(), operator-()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator Qt3D::QCircularBuffer::const_iterator::operator+(int j) const
+
+    Returns an iterator to the item at \a j positions forward from
+    this iterator. (If \a j is negative, the iterator goes backward.)
+
+    \sa operator-(), operator+=()
+*/
+
+/*! \fn Qt3D::QCircularBuffer::const_iterator Qt3D::QCircularBuffer::const_iterator::operator-(int j) const
+
+    Returns an iterator to the item at \a j positions backward from
+    this iterator. (If \a j is negative, the iterator goes forward.)
+
+    \sa operator+(), operator-=()
+*/
+
+/*! \fn int Qt3D::QCircularBuffer::const_iterator::operator-(const_iterator other) const
+
+    Returns the number of items between the item pointed to by \a
+    other and the item pointed to by this iterator.
+*/