2017-04-27 19:04:45 +00:00
|
|
|
/*
|
|
|
|
This file is part of Telegram Desktop,
|
|
|
|
the official desktop version of Telegram messaging app, see https://telegram.org
|
|
|
|
|
|
|
|
Telegram Desktop is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
It is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
In addition, as a special exception, the copyright holders give permission
|
|
|
|
to link the code of portions of this program with the OpenSSL library.
|
|
|
|
|
|
|
|
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
|
|
|
|
Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
|
|
|
|
*/
|
|
|
|
#include "calls/calls_box_controller.h"
|
|
|
|
|
|
|
|
#include "styles/style_calls.h"
|
|
|
|
#include "styles/style_boxes.h"
|
2017-04-13 08:27:10 +00:00
|
|
|
#include "lang/lang_keys.h"
|
2017-04-27 19:04:45 +00:00
|
|
|
#include "observer_peer.h"
|
|
|
|
#include "ui/effects/ripple_animation.h"
|
|
|
|
#include "calls/calls_instance.h"
|
2017-04-27 21:17:00 +00:00
|
|
|
#include "history/history_media_types.h"
|
2017-10-03 13:05:58 +00:00
|
|
|
#include "mainwidget.h"
|
2017-10-05 15:35:52 +00:00
|
|
|
#include "auth_session.h"
|
2017-04-27 19:04:45 +00:00
|
|
|
|
|
|
|
namespace Calls {
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
constexpr auto kFirstPageCount = 20;
|
|
|
|
constexpr auto kPerPageCount = 100;
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2017-06-13 21:08:47 +00:00
|
|
|
class BoxController::Row : public PeerListRow {
|
2017-04-27 19:04:45 +00:00
|
|
|
public:
|
2017-10-05 15:35:52 +00:00
|
|
|
Row(not_null<HistoryItem*> item);
|
2017-04-27 19:04:45 +00:00
|
|
|
|
|
|
|
enum class Type {
|
|
|
|
Out,
|
|
|
|
In,
|
|
|
|
Missed,
|
|
|
|
};
|
|
|
|
|
2017-10-05 15:35:52 +00:00
|
|
|
bool canAddItem(not_null<const HistoryItem*> item) const {
|
2017-04-27 19:04:45 +00:00
|
|
|
return (ComputeType(item) == _type && item->date.date() == _date);
|
|
|
|
}
|
2017-11-20 12:23:20 +00:00
|
|
|
void addItem(not_null<HistoryItem*> item) {
|
2017-04-27 19:04:45 +00:00
|
|
|
Expects(canAddItem(item));
|
|
|
|
_items.push_back(item);
|
2017-11-20 12:23:20 +00:00
|
|
|
ranges::sort(_items, [](not_null<HistoryItem*> a, auto b) {
|
2017-04-27 19:04:45 +00:00
|
|
|
return (a->id > b->id);
|
|
|
|
});
|
|
|
|
refreshStatus();
|
|
|
|
}
|
2017-10-05 15:35:52 +00:00
|
|
|
void itemRemoved(not_null<const HistoryItem*> item) {
|
2017-04-27 19:04:45 +00:00
|
|
|
if (hasItems() && item->id >= minItemId() && item->id <= maxItemId()) {
|
|
|
|
_items.erase(std::remove(_items.begin(), _items.end(), item), _items.end());
|
|
|
|
refreshStatus();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bool hasItems() const {
|
|
|
|
return !_items.empty();
|
|
|
|
}
|
|
|
|
|
|
|
|
MsgId minItemId() const {
|
|
|
|
Expects(hasItems());
|
|
|
|
return _items.back()->id;
|
|
|
|
}
|
|
|
|
|
|
|
|
MsgId maxItemId() const {
|
|
|
|
Expects(hasItems());
|
|
|
|
return _items.front()->id;
|
|
|
|
}
|
|
|
|
|
2017-09-26 17:57:01 +00:00
|
|
|
void paintStatusText(
|
|
|
|
Painter &p,
|
|
|
|
const style::PeerListItem &st,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int availableWidth,
|
|
|
|
int outerWidth,
|
|
|
|
bool selected) override;
|
2017-04-27 19:04:45 +00:00
|
|
|
void addActionRipple(QPoint point, base::lambda<void()> updateCallback) override;
|
|
|
|
void stopLastActionRipple() override;
|
|
|
|
|
2017-11-07 17:53:00 +00:00
|
|
|
int nameIconWidth() const override {
|
|
|
|
return 0;
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
QSize actionSize() const override {
|
2017-04-27 21:17:00 +00:00
|
|
|
return peer()->isUser() ? QSize(st::callReDial.width, st::callReDial.height) : QSize();
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
QMargins actionMargins() const override {
|
2017-11-07 17:53:00 +00:00
|
|
|
return QMargins(
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
st::defaultPeerListItem.photoPosition.x(),
|
|
|
|
0);
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
2017-11-07 17:53:00 +00:00
|
|
|
void paintAction(
|
|
|
|
Painter &p,
|
|
|
|
TimeMs ms,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int outerWidth,
|
|
|
|
bool selected,
|
|
|
|
bool actionSelected) override;
|
2017-04-27 19:04:45 +00:00
|
|
|
|
2017-06-13 21:08:47 +00:00
|
|
|
private:
|
2017-04-27 19:04:45 +00:00
|
|
|
void refreshStatus();
|
2017-10-05 15:35:52 +00:00
|
|
|
static Type ComputeType(not_null<const HistoryItem*> item);
|
2017-04-27 19:04:45 +00:00
|
|
|
|
2017-11-20 12:23:20 +00:00
|
|
|
std::vector<not_null<HistoryItem*>> _items;
|
2017-04-27 19:04:45 +00:00
|
|
|
QDate _date;
|
|
|
|
Type _type;
|
|
|
|
|
|
|
|
std::unique_ptr<Ui::RippleAnimation> _actionRipple;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2017-10-05 15:35:52 +00:00
|
|
|
BoxController::Row::Row(not_null<HistoryItem*> item)
|
|
|
|
: PeerListRow(item->history()->peer, item->id)
|
2017-04-27 19:04:45 +00:00
|
|
|
, _items(1, item)
|
|
|
|
, _date(item->date.date())
|
|
|
|
, _type(ComputeType(item)) {
|
|
|
|
refreshStatus();
|
|
|
|
}
|
|
|
|
|
2017-09-26 17:57:01 +00:00
|
|
|
void BoxController::Row::paintStatusText(Painter &p, const style::PeerListItem &st, int x, int y, int availableWidth, int outerWidth, bool selected) {
|
2017-05-02 07:25:20 +00:00
|
|
|
auto icon = ([this] {
|
2017-04-27 19:04:45 +00:00
|
|
|
switch (_type) {
|
2017-05-02 07:25:20 +00:00
|
|
|
case Type::In: return &st::callArrowIn;
|
|
|
|
case Type::Out: return &st::callArrowOut;
|
|
|
|
case Type::Missed: return &st::callArrowMissed;
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
Unexpected("_type in Calls::BoxController::Row::paintStatusText().");
|
|
|
|
})();
|
2017-05-02 07:25:20 +00:00
|
|
|
icon->paint(p, x + st::callArrowPosition.x(), y + st::callArrowPosition.y(), outerWidth);
|
2017-06-28 05:57:58 +00:00
|
|
|
auto shift = st::callArrowPosition.x() + icon->width() + st::callArrowSkip;
|
|
|
|
x += shift;
|
|
|
|
availableWidth -= shift;
|
2017-04-27 19:04:45 +00:00
|
|
|
|
2017-09-26 17:57:01 +00:00
|
|
|
PeerListRow::paintStatusText(p, st, x, y, availableWidth, outerWidth, selected);
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
|
2017-11-07 17:53:00 +00:00
|
|
|
void BoxController::Row::paintAction(
|
|
|
|
Painter &p,
|
|
|
|
TimeMs ms,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int outerWidth,
|
|
|
|
bool selected,
|
|
|
|
bool actionSelected) {
|
2017-04-27 19:04:45 +00:00
|
|
|
auto size = actionSize();
|
|
|
|
if (_actionRipple) {
|
|
|
|
_actionRipple->paint(p, x + st::callReDial.rippleAreaPosition.x(), y + st::callReDial.rippleAreaPosition.y(), outerWidth, ms);
|
|
|
|
if (_actionRipple->empty()) {
|
|
|
|
_actionRipple.reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
st::callReDial.icon.paintInCenter(p, rtlrect(x, y, size.width(), size.height(), outerWidth));
|
|
|
|
}
|
|
|
|
|
|
|
|
void BoxController::Row::refreshStatus() {
|
|
|
|
if (!hasItems()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
auto text = [this] {
|
|
|
|
auto time = _items.front()->date.time().toString(cTimeFormat());
|
|
|
|
auto today = QDateTime::currentDateTime().date();
|
|
|
|
if (_date == today) {
|
|
|
|
return lng_call_box_status_today(lt_time, time);
|
|
|
|
} else if (_date.addDays(1) == today) {
|
|
|
|
return lng_call_box_status_yesterday(lt_time, time);
|
|
|
|
}
|
|
|
|
return lng_call_box_status_date(lt_date, langDayOfMonthFull(_date), lt_time, time);
|
|
|
|
};
|
|
|
|
setCustomStatus((_items.size() > 1) ? lng_call_box_status_group(lt_count, QString::number(_items.size()), lt_status, text()) : text());
|
|
|
|
}
|
|
|
|
|
2017-10-05 15:35:52 +00:00
|
|
|
BoxController::Row::Type BoxController::Row::ComputeType(
|
|
|
|
not_null<const HistoryItem*> item) {
|
2017-04-27 19:04:45 +00:00
|
|
|
if (item->out()) {
|
|
|
|
return Type::Out;
|
2017-04-27 21:17:00 +00:00
|
|
|
} else if (auto media = item->getMedia()) {
|
|
|
|
if (media->type() == MediaTypeCall) {
|
|
|
|
auto reason = static_cast<HistoryCall*>(media)->reason();
|
|
|
|
if (reason == HistoryCall::FinishReason::Busy || reason == HistoryCall::FinishReason::Missed) {
|
|
|
|
return Type::Missed;
|
|
|
|
}
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return Type::In;
|
|
|
|
}
|
|
|
|
|
|
|
|
void BoxController::Row::addActionRipple(QPoint point, base::lambda<void()> updateCallback) {
|
|
|
|
if (!_actionRipple) {
|
|
|
|
auto mask = Ui::RippleAnimation::ellipseMask(QSize(st::callReDial.rippleAreaSize, st::callReDial.rippleAreaSize));
|
|
|
|
_actionRipple = std::make_unique<Ui::RippleAnimation>(st::callReDial.ripple, std::move(mask), std::move(updateCallback));
|
|
|
|
}
|
|
|
|
_actionRipple->add(point - st::callReDial.rippleAreaPosition);
|
|
|
|
}
|
|
|
|
|
|
|
|
void BoxController::Row::stopLastActionRipple() {
|
|
|
|
if (_actionRipple) {
|
|
|
|
_actionRipple->lastStop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void BoxController::prepare() {
|
2017-10-05 15:35:52 +00:00
|
|
|
Auth().data().itemRemoved()
|
|
|
|
| rpl::start_with_next([this](auto item) {
|
|
|
|
if (auto row = rowForItem(item)) {
|
|
|
|
row->itemRemoved(item);
|
|
|
|
if (!row->hasItems()) {
|
|
|
|
delegate()->peerListRemoveRow(row);
|
|
|
|
if (!delegate()->peerListFullRowsCount()) {
|
|
|
|
refreshAbout();
|
|
|
|
}
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
2017-10-05 15:35:52 +00:00
|
|
|
delegate()->peerListRefreshRows();
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
2017-10-05 15:35:52 +00:00
|
|
|
}, lifetime());
|
2017-04-28 12:54:40 +00:00
|
|
|
subscribe(Current().newServiceMessage(), [this](const FullMsgId &msgId) {
|
|
|
|
if (auto item = App::histItemById(msgId)) {
|
|
|
|
insertRow(item, InsertWay::Prepend);
|
|
|
|
}
|
|
|
|
});
|
2017-04-27 19:04:45 +00:00
|
|
|
|
2017-06-13 21:08:47 +00:00
|
|
|
delegate()->peerListSetTitle(langFactory(lng_call_box_title));
|
|
|
|
setDescriptionText(lang(lng_contacts_loading));
|
|
|
|
delegate()->peerListRefreshRows();
|
2017-04-27 19:04:45 +00:00
|
|
|
|
2017-06-14 10:46:06 +00:00
|
|
|
loadMoreRows();
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
|
2017-06-14 10:46:06 +00:00
|
|
|
void BoxController::loadMoreRows() {
|
2017-04-27 19:04:45 +00:00
|
|
|
if (_loadRequestId || _allLoaded) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-11-20 19:54:05 +00:00
|
|
|
_loadRequestId = request(MTPmessages_Search(
|
|
|
|
MTP_flags(0),
|
|
|
|
MTP_inputPeerEmpty(),
|
|
|
|
MTP_string(QString()),
|
|
|
|
MTP_inputUserEmpty(),
|
|
|
|
MTP_inputMessagesFilterPhoneCalls(MTP_flags(0)),
|
|
|
|
MTP_int(0),
|
|
|
|
MTP_int(0),
|
|
|
|
MTP_int(_offsetId),
|
|
|
|
MTP_int(0),
|
|
|
|
MTP_int(_offsetId ? kFirstPageCount : kPerPageCount),
|
|
|
|
MTP_int(0),
|
|
|
|
MTP_int(0)
|
|
|
|
)).done([this](const MTPmessages_Messages &result) {
|
2017-04-27 19:04:45 +00:00
|
|
|
_loadRequestId = 0;
|
|
|
|
|
|
|
|
auto handleResult = [this](auto &data) {
|
|
|
|
App::feedUsers(data.vusers);
|
|
|
|
App::feedChats(data.vchats);
|
|
|
|
receivedCalls(data.vmessages.v);
|
|
|
|
};
|
|
|
|
|
|
|
|
switch (result.type()) {
|
|
|
|
case mtpc_messages_messages: handleResult(result.c_messages_messages()); _allLoaded = true; break;
|
|
|
|
case mtpc_messages_messagesSlice: handleResult(result.c_messages_messagesSlice()); break;
|
|
|
|
case mtpc_messages_channelMessages: {
|
|
|
|
LOG(("API Error: received messages.channelMessages! (Calls::BoxController::preloadRows)"));
|
|
|
|
handleResult(result.c_messages_channelMessages());
|
|
|
|
} break;
|
2017-11-20 19:54:05 +00:00
|
|
|
case mtpc_messages_messagesNotModified: {
|
|
|
|
LOG(("API Error: received messages.messagesNotModified! (Calls::BoxController::preloadRows)"));
|
|
|
|
} break;
|
2017-04-27 19:04:45 +00:00
|
|
|
default: Unexpected("Type of messages.Messages (Calls::BoxController::preloadRows)");
|
|
|
|
}
|
|
|
|
}).fail([this](const RPCError &error) {
|
|
|
|
_loadRequestId = 0;
|
|
|
|
}).send();
|
|
|
|
}
|
|
|
|
|
|
|
|
void BoxController::refreshAbout() {
|
2017-06-13 21:08:47 +00:00
|
|
|
setDescriptionText(delegate()->peerListFullRowsCount() ? QString() : lang(lng_call_box_about));
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
|
2017-08-17 08:31:24 +00:00
|
|
|
void BoxController::rowClicked(not_null<PeerListRow*> row) {
|
2017-06-13 21:08:47 +00:00
|
|
|
auto itemsRow = static_cast<Row*>(row.get());
|
2017-04-27 19:04:45 +00:00
|
|
|
auto itemId = itemsRow->maxItemId();
|
2017-10-03 13:05:58 +00:00
|
|
|
InvokeQueued(App::main(), [peerId = row->peer()->id, itemId] {
|
|
|
|
Ui::showPeerHistory(peerId, itemId);
|
|
|
|
});
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
|
2017-08-17 08:31:24 +00:00
|
|
|
void BoxController::rowActionClicked(not_null<PeerListRow*> row) {
|
2017-04-27 19:04:45 +00:00
|
|
|
auto user = row->peer()->asUser();
|
2017-08-17 09:06:26 +00:00
|
|
|
Assert(user != nullptr);
|
2017-04-27 19:04:45 +00:00
|
|
|
|
|
|
|
Current().startOutgoingCall(user);
|
|
|
|
}
|
|
|
|
|
|
|
|
void BoxController::receivedCalls(const QVector<MTPMessage> &result) {
|
|
|
|
if (result.empty()) {
|
|
|
|
_allLoaded = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
for_const (auto &message, result) {
|
|
|
|
auto msgId = idFromMessage(message);
|
|
|
|
auto peerId = peerFromMessage(message);
|
|
|
|
if (auto peer = App::peerLoaded(peerId)) {
|
|
|
|
auto item = App::histories().addNewMessage(message, NewMessageExisting);
|
2017-04-27 21:17:00 +00:00
|
|
|
insertRow(item, InsertWay::Append);
|
2017-04-27 19:04:45 +00:00
|
|
|
} else {
|
|
|
|
LOG(("API Error: a search results with not loaded peer %1").arg(peerId));
|
|
|
|
}
|
|
|
|
_offsetId = msgId;
|
|
|
|
}
|
|
|
|
|
|
|
|
refreshAbout();
|
2017-06-13 21:08:47 +00:00
|
|
|
delegate()->peerListRefreshRows();
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
|
2017-10-05 15:35:52 +00:00
|
|
|
bool BoxController::insertRow(
|
|
|
|
not_null<HistoryItem*> item,
|
|
|
|
InsertWay way) {
|
2017-04-27 19:04:45 +00:00
|
|
|
if (auto row = rowForItem(item)) {
|
2017-04-27 21:17:00 +00:00
|
|
|
if (row->canAddItem(item)) {
|
|
|
|
row->addItem(item);
|
|
|
|
return false;
|
|
|
|
}
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
2017-10-05 15:35:52 +00:00
|
|
|
(way == InsertWay::Append)
|
|
|
|
? delegate()->peerListAppendRow(createRow(item))
|
|
|
|
: delegate()->peerListPrependRow(createRow(item));
|
2017-10-22 17:06:57 +00:00
|
|
|
delegate()->peerListSortRows([](
|
|
|
|
const PeerListRow &a,
|
|
|
|
const PeerListRow &b) {
|
|
|
|
return static_cast<const Row&>(a).maxItemId()
|
|
|
|
> static_cast<const Row&>(b).maxItemId();
|
2017-04-27 19:04:45 +00:00
|
|
|
});
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-10-05 15:35:52 +00:00
|
|
|
BoxController::Row *BoxController::rowForItem(not_null<const HistoryItem*> item) {
|
2017-06-13 21:08:47 +00:00
|
|
|
auto v = delegate();
|
|
|
|
if (auto fullRowsCount = v->peerListFullRowsCount()) {
|
2017-04-27 19:04:45 +00:00
|
|
|
auto itemId = item->id;
|
2017-06-13 21:08:47 +00:00
|
|
|
auto lastRow = static_cast<Row*>(v->peerListRowAt(fullRowsCount - 1).get());
|
2017-04-27 19:04:45 +00:00
|
|
|
if (itemId < lastRow->minItemId()) {
|
2017-04-27 21:17:00 +00:00
|
|
|
return lastRow;
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
2017-06-13 21:08:47 +00:00
|
|
|
auto firstRow = static_cast<Row*>(v->peerListRowAt(0).get());
|
2017-04-27 19:04:45 +00:00
|
|
|
if (itemId > firstRow->maxItemId()) {
|
2017-04-27 21:17:00 +00:00
|
|
|
return firstRow;
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Binary search. Invariant:
|
|
|
|
// 1. rowAt(left)->maxItemId() >= itemId.
|
|
|
|
// 2. (left + 1 == fullRowsCount) OR rowAt(left + 1)->maxItemId() < itemId.
|
|
|
|
auto left = 0;
|
|
|
|
auto right = fullRowsCount;
|
|
|
|
while (left + 1 < right) {
|
|
|
|
auto middle = (right + left) / 2;
|
2017-06-13 21:08:47 +00:00
|
|
|
auto middleRow = static_cast<Row*>(v->peerListRowAt(middle).get());
|
2017-04-27 19:04:45 +00:00
|
|
|
if (middleRow->maxItemId() >= itemId) {
|
|
|
|
left = middle;
|
|
|
|
} else {
|
|
|
|
right = middle;
|
|
|
|
}
|
|
|
|
}
|
2017-06-13 21:08:47 +00:00
|
|
|
auto result = static_cast<Row*>(v->peerListRowAt(left).get());
|
2017-04-27 19:04:45 +00:00
|
|
|
// Check for rowAt(left)->minItemId > itemId > rowAt(left + 1)->maxItemId.
|
|
|
|
// In that case we sometimes need to return rowAt(left + 1), not rowAt(left).
|
|
|
|
if (result->minItemId() > itemId && left + 1 < fullRowsCount) {
|
2017-06-13 21:08:47 +00:00
|
|
|
auto possibleResult = static_cast<Row*>(v->peerListRowAt(left + 1).get());
|
2017-08-17 09:06:26 +00:00
|
|
|
Assert(possibleResult->maxItemId() < itemId);
|
2017-04-27 19:04:45 +00:00
|
|
|
if (possibleResult->canAddItem(item)) {
|
|
|
|
return possibleResult;
|
|
|
|
}
|
|
|
|
}
|
2017-04-27 21:17:00 +00:00
|
|
|
return result;
|
2017-04-27 19:04:45 +00:00
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2017-10-05 15:35:52 +00:00
|
|
|
std::unique_ptr<PeerListRow> BoxController::createRow(
|
|
|
|
not_null<HistoryItem*> item) const {
|
2017-04-27 19:04:45 +00:00
|
|
|
auto row = std::make_unique<Row>(item);
|
|
|
|
return std::move(row);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Calls
|