Revision control
Copy as Markdown
// Copyright (C) 2025 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qqmltreemodel_p.h"
#include "qqmltreerow_p.h"
#include <QtCore/qloggingcategory.h>
#include <QtQml/qqmlinfo.h>
#include <QtQml/qqmlengine.h>
QT_BEGIN_NAMESPACE
Q_STATIC_LOGGING_CATEGORY(lcTreeModel, "qt.qml.treemodel")
/*!
\qmltype TreeModel
//! \nativetype QQmlTreeModel
\inqmlmodule Qt.labs.qmlmodels
\brief Encapsulates a simple tree model.
\since 6.10
The TreeModel type stores JavaScript/JSON objects as data for a tree
model that can be used with \l TreeView. It is intended to support
very simple models without requiring the creation of a custom
\l QAbstractItemModel subclass in C++.
\snippet qml/treemodel/treemodel-filesystem-basic.qml file
The model's initial data is set with either the \l rows property or by
calling \l appendRow(). Each column in the model is specified by declaring
a \l TableModelColumn instance, where the order of each instance determines
its column index. Once the model's \l Component::completed() signal has been
emitted, the columns and roles will have been established and are then
fixed for the lifetime of the model.
\section1 Supported Row Data Structures
Each row represents a node in the tree. Each node has the same type of
columns. The TreeModel is designed to work with JavaScript/JSON data so
each row is a list of simple key-value pairs:
\snippet qml/treemodel/treemodel-filesystem-basic.qml rows
A node can have child nodes and these will be stored in an array
associated with the "rows" key. "rows" is reserved for this purpose: only
the list of child nodes should be associated with this key.
The model is manipulated via \l {QModelIndex} {QModelIndices}. To access
a specific row/node, the \l getRow() function can be used. It's also
possible to access the model's JavaScript data directly via the \l rows
property, but it is not possible to modify the model data this way.
To add new rows, use \l appendRow(). To modify existing rows, use
\l setRow(), \l removeRow() and \l clear().
\section1 Using the TreeModel with External JSON Sources
While the intended use of the TreeModel is to define the JSON data in-place in
the QML file, you can use any JSON object with the model as long as
its structure matches the structure defined by the TreeModel. If all the rows
of the JSON object conform to the columns defined by the model, you can
assign it directly through the rows property.
The source of the JSON object can be a file. For example, if the model is
defined as
\snippet setRowsViaJSON.qml model
and the JSON object stored in the file and looks like
\snippet TreeData.js file
then this object can be provided by importing the JavaScript file as a
module
\snippet setRowsViaJSON.qml import
and then it can be assigned directly
\snippet setRowsViaJSON.qml assignment
\warning Ensure that the JSON data comes from a trusted source. Since the
model dynamically populates its rows based on the input, malformed or
untrusted JSON can lead to unexpected behavior or performance issues.
See \l TableModel for an another example where a JSON object is parsed
into and assigned as a JavaScript array.
\sa TableModelColumn, TreeView
*/
QQmlTreeModel::QQmlTreeModel(QObject *parent)
: QQmlAbstractColumnModel(parent)
{
}
QQmlTreeModel::~QQmlTreeModel() = default;
/*!
\qmlproperty var TreeModel::rows
This property holds the model data in the form of an array of rows.
\sa getRow(), setRow(), appendRow(), clear(), columnCount
*/
QVariant QQmlTreeModel::rows() const
{
QVariantList rowsAsVariant;
for (const auto &row : mRows)
rowsAsVariant.append(row->toVariant());
return rowsAsVariant;
}
void QQmlTreeModel::setRows(const QVariant &rows)
{
const std::optional<QVariantList> validated = validateRowsArgument(rows);
if (!validated)
return;
const QVariantList rowsAsVariantList = *validated;
if (!mComponentCompleted) {
// Store the rows until we can call setRowsPrivate() after component completion.
mInitialRows = rowsAsVariantList;
return;
}
setRowsPrivate(rowsAsVariantList);
}
void QQmlTreeModel::setRowsPrivate(const QVariantList &rowsAsVariantList)
{
Q_ASSERT(mComponentCompleted);
// By now, all TableModelColumns should have been set.
if (mColumns.isEmpty()) {
qmlWarning(this) << "No TableModelColumns were set; model will be empty";
return;
}
const bool firstTimeValidRowsHaveBeenSet = mColumnMetadata.isEmpty();
if (!firstTimeValidRowsHaveBeenSet) {
// This is not the first time rows have been set; validate each one.
for (const auto &row : rowsAsVariantList) {
// validateNewRow() expects a QVariant wrapping a QJSValue, so to
// simplify the code, just create one here.
const QVariant wrappedRow = QVariant::fromValue(row);
if (!validateNewRow("TreeModel::setRows"_L1, wrappedRow, SetRowsOperation))
return;
}
}
beginResetModel();
// In case the model is empty and we cannot insert any new rows in the loop below,
// we don't want to emit rowsChanged
const bool wasEmpty = mRows.empty();
// We don't clear the column or role data, because a TreeModel should not be reused in that way.
// Once it has valid data, its columns and roles are fixed.
mRows.clear();
for (const auto &rowAsVariant : rowsAsVariantList) {
if (rowAsVariant.canConvert<QVariantMap>())
mRows.push_back(std::make_unique<QQmlTreeRow>(rowAsVariant));
else
qmlWarning(this) << "Cannot create tree row as the row does not contain "
<< "key-value pairs";
}
// Gather metadata the first time rows is set.
// If we call setrows on an empty model, mInitialRows will be empty, but mRows is not
if (firstTimeValidRowsHaveBeenSet && (!mRows.empty() || !mInitialRows.isEmpty()))
fetchColumnMetadata();
endResetModel();
// was empty, still empty => no emit
// was empty, now non-empty => emit
// was not empty, now empty => emit
// was not empty, now non-empty => emit (there was a clear in-between)
if (!wasEmpty || !mRows.empty())
emit rowsChanged();
}
QVariant QQmlTreeModel::dataPrivate(const QModelIndex &index, const QString &roleName) const
{
const ColumnMetadata columnMetadata = mColumnMetadata.at(index.column());
const QString propertyName = columnMetadata.roles.value(roleName).name;
const auto *thisRow = static_cast<const QQmlTreeRow *>(index.internalPointer());
return thisRow->data(propertyName);
}
void QQmlTreeModel::setDataPrivate(const QModelIndex &index, const QString &roleName, QVariant value)
{
auto *row = static_cast<QQmlTreeRow *>(index.internalPointer());
row->setField(roleName, value);
}
// TODO: Turn this into a snippet that compiles in CI
/*!
\qmlmethod void TreeModel::appendRow(parent, var treeRow)
Appends a new treeRow to \a parent, with the values (cells) in \a treeRow.
\code
treeModel.appendRow(index, {
checked: false,
size: "-",
type: "folder",
name: "Orders",
lastModified: "2025-07-02",
rows: [
{
checked: true,
size: "38 KB",
type: "file",
name: "monitors.xlsx",
lastModified: "2025-07-02"
},
{
checked: true,
size: "54 KB",
type: "file",
name: "notebooks.xlsx",
lastModified: "2025-07-02"
}
]
});
\endcode
\a parent is an anonymous QML type backed by \l QModelIndex.
If \a parent is invalid, \a treeRow gets appended to the root node.
\sa setRow(), removeRow()
*/
void QQmlTreeModel::appendRow(QModelIndex parent, const QVariant &row)
{
if (!validateNewRow("TreeModel::appendRow"_L1, row))
return;
const QVariant data = row.userType() == QMetaType::QVariantMap ? row : row.value<QJSValue>().toVariant();
if (parent.isValid()) {
auto *parentRow = static_cast<QQmlTreeRow *>(parent.internalPointer());
auto *newChild = new QQmlTreeRow(data);
beginInsertRows(parent, static_cast<int>(parentRow->rowCount()), static_cast<int>(parentRow->rowCount()));
parentRow->addChild(newChild);
// Gather metadata the first time a row is added.
if (mColumnMetadata.isEmpty())
fetchColumnMetadata();
endInsertRows();
} else {
qmlWarning(this) << "append: could not find any node at the specified index"
<< " - the new row will be appended to root";
if (data.canConvert<QVariantMap>()) {
beginInsertRows(QModelIndex(),
static_cast<int>(mRows.size()),
static_cast<int>(mRows.size()));
mRows.push_back(std::make_unique<QQmlTreeRow>(data));
// Gather metadata the first time a row is added.
if (mColumnMetadata.isEmpty())
fetchColumnMetadata();
endInsertRows();
} else {
qmlWarning(this) << "Cannot create tree row as the row does not contain "
<< "key-value pairs";
return;
}
}
emit rowsChanged();
}
/*!
\qmlmethod void TreeModel::appendRow(var treeRow)
Appends \a treeRow to the root node.
\sa setRow(), removeRow()
*/
void QQmlTreeModel::appendRow(const QVariant &row)
{
appendRow({}, row);
}
/*!
\qmlmethod void TreeModel::clear()
Removes all rows from the model.
\sa removeRow()
*/
void QQmlTreeModel::clear()
{
if (mRows.empty())
return;
beginResetModel();
mRows.clear();
endResetModel();
emit rowsChanged();
}
/*!
\qmlmethod var TreeModel::getRow(rowIndex)
Returns the treeRow at specified index in the model.
\a rowIndex is an anonymous QML type backed by \l QModelIndex.
\note the returned object cannot be used to modify the contents of the
model; use setTreeRow() instead.
\sa setRow(), appendRow(), removeRow()
*/
QVariant QQmlTreeModel::getRow(const QModelIndex &rowIndex) const
{
if (rowIndex.isValid())
return static_cast<QQmlTreeRow*>(rowIndex.internalPointer())->toVariant();
qmlWarning(this) << "getRow: could not find any node at the specified index";
return {};
}
/*!
\qmlmethod void TreeModel::insertRow(int rowIndex, QModelIndex parent, object row)
\since 6.12
Inserts a new row to the \a parent at position \a rowIndex, with the
values (cells) in \a row.
\code
model.insertRow(2, parentIndex, {
checkable: true, checked: false,
amount: 1,
fruitType: "Pear",
fruitName: "Williams",
fruitPrice: 1.50,
})
\endcode
\sa appendRow(), setRow(), removeRow()
*/
void QQmlTreeModel::insertRow(int rowIndex, QModelIndex parent, const QVariant &row)
{
if (rowIndex < 0) {
qmlWarning(this).noquote() << "insertRow(): rowIndex cannot be negative";
return;
}
if (rowIndex > rowCount(parent)) {
qmlWarning(this).noquote() << "insertRow(): rowIndex " << rowIndex
<< " is greater than rowCount() of "
<< rowCount(parent);
return;
}
if (!validateNewRow("insertRow()"_L1, row))
return;
doInsert(parent, rowIndex, row);
}
/*!
\qmlmethod void TreeModel::insertRow(int rowIndex, object row)
\since 6.12
Inserts a new row to the root item at position \a rowIndex, with the
values (cells) in \a row.
\sa appendRow(), setRow(), removeRow()
*/
void QQmlTreeModel::insertRow(int rowIndex, const QVariant &row)
{
insertRow(rowIndex, {}, row);
}
void QQmlTreeModel::doInsert(const QModelIndex &parent, int rowIndex, const QVariant &row)
{
beginInsertRows(parent, rowIndex, rowIndex);
const QVariant data =
row.userType() == QMetaType::QVariantMap
? row
: row.value<QJSValue>().toVariant();
auto newChild = std::make_unique<QQmlTreeRow>(data);
if (parent.isValid())
static_cast<QQmlTreeRow *>(parent.internalPointer())->insertChild(rowIndex, std::move(newChild));
else
mRows.insert(mRows.begin() + rowIndex, std::move(newChild));
qCDebug(lcTreeModel).nospace() << "inserted the following row to the row "
<< parent << " at index "
<< rowIndex << ":\n" << data.toMap();
// Gather metadata the first time a row is added.
if (mColumnMetadata.isEmpty())
fetchColumnMetadata();
endInsertRows();
emit rowsChanged();
}
QVariant QQmlTreeModel::firstRow() const
{
if (mRows.empty()) {
qmlWarning(this) << "TreeModel::firstRow(): model is empty";
return {};
}
return mRows.front().get()->data();
}
void QQmlTreeModel::setInitialRows()
{
setRowsPrivate(mInitialRows);
}
/*!
\qmlmethod void TreeModel::removeRow(rowIndex)
Removes the TreeRow referenced by \a rowIndex from the model.
\a rowIndex is an anonymous QML type backed by \l QModelIndex.
\code
treeModel.removeTreeRow(rowIndex)
\endcode
\sa clear()
*/
void QQmlTreeModel::removeRow(QModelIndex rowIndex)
{
if (rowIndex.isValid()) {
QModelIndex mIndexParent = rowIndex.parent();
beginRemoveRows(mIndexParent, rowIndex.row(), rowIndex.row());
if (mIndexParent.isValid()) {
auto *parent = static_cast<QQmlTreeRow *>(mIndexParent.internalPointer());
parent->removeChildAt(rowIndex.row());
} else {
mRows.erase(std::next(mRows.begin(), rowIndex.row()));
}
endRemoveRows();
} else {
qmlWarning(this) << "TreeModel::removeRow could not find any node at the specified index";
return;
}
emit rowsChanged();
}
// TODO: Turn this into a snippet that compiles in CI
/*!
\qmlmethod void TreeModel::setRow(rowIndex, var treeRow)
Replaces the TreeRow at \a rowIndex in the model with \a treeRow.
\a rowIndex is an anonymous QML type back by \l QModelIndex.
A row with child rows will be rejected.
All columns/cells must be present in \c treeRow, and in the correct order.
The child rows of the row remain unaffected.
\code
treeModel.setRow(rowIndex, {
checked: true,
size: "-",
type: "folder",
name: "Subtitles",
lastModified: "2025-07-07",
iconColor: "blue"
});
\endcode
\sa appendRow()
*/
void QQmlTreeModel::setRow(QModelIndex rowIndex, const QVariant &rowData)
{
if (!rowIndex.isValid()) {
qmlWarning(this) << "TreeModel::setRow: invalid modelIndex";
return;
}
const QVariantMap rowAsMap = rowData.toMap();
if (rowAsMap.contains(ROWS_PROPERTY_NAME) && rowAsMap[ROWS_PROPERTY_NAME].userType() == QMetaType::Type::QVariantList) {
qmlWarning(this) << "TreeModel::setRow: child rows are not allowed";
return;
}
if (!validateNewRow("TreeModel::setRow"_L1, rowData))
return;
const QVariant rowAsVariant = rowData.userType() == QMetaType::QVariantMap ? rowData : rowData.value<QJSValue>().toVariant();
auto *row = static_cast<QQmlTreeRow *>(rowIndex.internalPointer());
row->setData(rowAsVariant);
const QModelIndex topLeftModelIndex(createIndex(rowIndex.row(), 0, rowIndex.internalPointer()));
const QModelIndex bottomRightModelIndex(createIndex(rowIndex.row(), mColumnCount-1, rowIndex.internalPointer()));
emit dataChanged(topLeftModelIndex, bottomRightModelIndex);
emit rowsChanged();
}
/*!
\qmlmethod QModelIndex TreeModel::index(int row, int column, var parent)
Returns an object referencing the given \a row and \a column of
a given \a parent which can be passed to the data() function to get the data
from that cell, or to setData() to edit the contents of that cell.
The returned object is of an anonymous QML type backed by \l QModelIndex.
\sa {QModelIndex and related Classes in QML}, data()
*/
QModelIndex QQmlTreeModel::index(int row, int column, const QModelIndex &parent) const
{
if (!parent.isValid()){
if (static_cast<size_t>(row) >= mRows.size())
return {};
return createIndex(row, column, mRows.at(row).get());
}
const auto *treeRow = static_cast<const QQmlTreeRow *>(parent.internalPointer());
if (treeRow->rowCount() <= static_cast<size_t>(row))
return {};
return createIndex(row, column, treeRow->getRow(row));
}
/*!
\qmlmethod QModelIndex TreeModel::index(list<int> treeIndex, int column)
Returns an object referencing the given \a treeIndex and \a column,
which can be passed to the data() function to get the data from that cell,
or to setData() to edit the contents of that cell.
The returned object is of an anonymous QML type backed by \l QModelIndex.
The first parameter \a treeIndex represents a path of row numbers tracing from
the root to the desired row and is used for navigation inside the tree.
This is best explained through an example.
\table
\row \li \inlineimage treemodel.svg
{Tree diagram showing nodes A through F with index paths}
\li \list
\li The root of the tree is special, as it can be referenced by an invalid
\l QModelIndex.
\li Node A is the first child of the root and the corresponding \a treeIndex is \c [0].
\li Node B is the first child of node A. Since the \a treeIndex of A is \c [0]
the \a treeIndex of B will be \c [0,0].
\li Node C is the second child of A and its \a treeIndex is \c [0,1].
\li Node D is the third child of A and its \a treeIndex is \c [0,2].
\li Node E is the second child of the root and its \a treeIndex is \c [1].
\li Node F is the third child of the root and its \a treeIndex is \c [2].
\endlist
\endtable
With this overload it is possible to obtain a \l QModelIndex to a node without
having a \l QModelIndex to its parent node.
If no node is found by the list specified, an invalid model index is returned.
Please note that an invalid model index is referencing the root of the node.
\sa {QModelIndex and related Classes in QML}, data()
*/
QModelIndex QQmlTreeModel::index(const std::vector<int> &treeIndex, int column)
{
QModelIndex mIndex;
QQmlTreeRow *row = getPointerToTreeRow(mIndex, treeIndex);
if (row)
return createIndex(treeIndex.back(), column, row);
qmlWarning(this) << "TreeModel::index: could not find any node at the specified index: "
<< treeIndex;
return {};
}
QModelIndex QQmlTreeModel::parent(const QModelIndex &index) const
{
if (!index.isValid())
return {};
const auto *thisRow = static_cast<const QQmlTreeRow *>(index.internalPointer());
const QQmlTreeRow *parentRow = thisRow->parent();
if (!parentRow) // parent is root
return {};
const QQmlTreeRow *grandparentRow = parentRow->parent();
if (!grandparentRow) {// grandparent is root, parent is in mRows
for (size_t i = 0; i < mRows.size(); i++) {
if (mRows[i].get() == parentRow)
return createIndex(static_cast<int>(i), 0, parentRow);
}
Q_UNREACHABLE_RETURN(QModelIndex());
}
for (size_t i = 0; i < grandparentRow->rowCount(); i++) {
if (grandparentRow->getRow(static_cast<int>(i)) == parentRow)
return createIndex(static_cast<int>(i), 0, parentRow);
}
Q_UNREACHABLE_RETURN(QModelIndex());
}
int QQmlTreeModel::rowCount(const QModelIndex &parent) const
{
if (!parent.isValid())
return static_cast<int>(mRows.size());
const auto *row = static_cast<const QQmlTreeRow *>(parent.internalPointer());
return static_cast<int>(row->rowCount());
}
/*!
\qmlproperty int TreeModel::columnCount
\readonly
This read-only property holds the number of columns in the model.
The number of columns is fixed for the lifetime of the model
after the \l rows property is set or \l appendRow() is called for the first
time.
*/
int QQmlTreeModel::columnCount(const QModelIndex &parent) const
{
Q_UNUSED(parent);
return mColumnCount;
}
/*!
\qmlmethod variant TreeModel::data(index, string role)
Returns the data from the TreeModel at the given \a index belonging to the
given \a role.
\a index is an anonymous QML type backed by \l QModelIndex.
\sa index(), setData()
*/
/*!
\qmlmethod bool TreeModel::setData(index, variant value, string role)
Inserts or updates the data field named by \a role in the TreeRow at the
given \a index with \a value. Returns true if successful, false if not.
\a index is an anonymous QML type backed by \l QModelIndex.
\sa data(), index()
*/
bool QQmlTreeModel::validateNewRow(QLatin1StringView functionName, const QVariant &row,
NewRowOperationFlag operation) const
{
// Validates the row and all its descendants, children before their parent,
// in the same order as a recursive traversal would, but without recursing
// once per level of the nested rows, which can be arbitrarily deep.
struct Frame
{
QVariant row;
NewRowOperationFlag operation;
QVariantList children;
qsizetype nextChild = 0;
};
std::vector<Frame> pending;
const auto push = [&pending](const QVariant &newRow, NewRowOperationFlag newRowOperation) {
const bool isVariantMap = (newRow.userType() == QMetaType::QVariantMap);
const QVariant rowAsVariant = newRowOperation == SetRowsOperation || isVariantMap
? newRow : newRow.value<QJSValue>().toVariant();
const QVariantMap rowAsMap = rowAsVariant.toMap();
QVariantList children;
const auto it = rowAsMap.constFind(ROWS_PROPERTY_NAME);
if (it != rowAsMap.cend() && it->userType() == QMetaType::Type::QVariantList)
children = it->toList();
pending.push_back({ newRow, newRowOperation, std::move(children) });
};
push(row, operation);
while (!pending.empty()) {
Frame &top = pending.back();
if (top.nextChild < top.children.size()) {
const QVariant child = top.children.at(top.nextChild++);
push(child, OtherOperation); // invalidates top
continue;
}
if (!QQmlAbstractColumnModel::validateNewRow(functionName, top.row, top.operation))
return false;
pending.pop_back();
}
return true;
}
int QQmlTreeModel::treeSize() const
{
int treeSize = 0;
for (const auto &treeRow : mRows)
treeSize += treeRow->subTreeSize();
return treeSize;
}
QQmlTreeRow *QQmlTreeModel::getPointerToTreeRow(QModelIndex &modIndex,
const std::vector<int> &rowIndex) const
{
for (int r : rowIndex) {
modIndex = index(r, 0, modIndex);
if (!modIndex.isValid())
return nullptr;
}
return static_cast<QQmlTreeRow*>(modIndex.internalPointer());
}
/*!
\qmlmethod bool TreeModel::moveRows(QModelIndex sourceParent, int sourceRow, int count,
QModelIndex destinationParent, int destinationChild)
\since 6.12
Moves \a count rows starting at \a sourceRow from \a sourceParent to
\a destinationParent, inserting before \a destinationChild.
The \a destinationChild refers to the position in the \a destinationParent
\e before the move (pre-removal index), consistent with
QAbstractItemModel::beginMoveRows().
The source and destination ranges must exist, and \a sourceParent and
\a destinationParent must not overlap such that a parent would be moved
under its own child.
Returns \c true if the rows were successfully moved; otherwise returns
\c false.
\sa appendRow(), insertRow(), removeRow()
*/
bool QQmlTreeModel::moveRows(const QModelIndex &sourceParent, int sourceRow, int count,
const QModelIndex &destinationParent, int destinationChild)
{
if (count <= 0)
return false;
// beginMoveRows does not validate bounds against rowCount,
// so we must check before calling it.
if (sourceRow < 0 || sourceRow + count > rowCount(sourceParent))
return false;
if (destinationChild < 0 || destinationChild > rowCount(destinationParent))
return false;
if (!beginMoveRows(sourceParent, sourceRow, sourceRow + count - 1,
destinationParent, destinationChild))
return false;
// Root-level children live in mRows on the model, not in a QQmlTreeRow,
// so internalPointer() is nullptr for the root QModelIndex.
auto takeChild = [this](const QModelIndex &parent, int row) -> std::unique_ptr<QQmlTreeRow> {
if (parent.isValid())
return static_cast<QQmlTreeRow *>(parent.internalPointer())->takeChild(row);
auto it = std::next(mRows.begin(), row);
std::unique_ptr<QQmlTreeRow> child = std::move(*it);
mRows.erase(it);
return child;
};
auto insertChild = [this](const QModelIndex &parent, int row, std::unique_ptr<QQmlTreeRow> child) {
if (parent.isValid()) {
static_cast<QQmlTreeRow *>(parent.internalPointer())->insertChild(row, std::move(child));
} else {
child->setParent(nullptr);
mRows.insert(std::next(mRows.begin(), row), std::move(child));
}
};
std::vector<std::unique_ptr<QQmlTreeRow>> buffer;
buffer.reserve(count);
for (int i = 0; i < count; ++i)
buffer.push_back(takeChild(sourceParent, sourceRow));
// beginMoveRows uses pre-removal indexing, but after takeChild the
// parent's child vector has already shrunk. Adjust for same-parent
// backward moves.
int insertAt = destinationChild;
if (sourceParent == destinationParent && destinationChild > sourceRow)
insertAt -= count;
for (int i = 0; i < count; ++i)
insertChild(destinationParent, insertAt + i, std::move(buffer[i]));
endMoveRows();
emit rowsChanged();
return true;
}
QT_END_NAMESPACE
#include "moc_qqmltreemodel_p.cpp"