tdesktop/Telegram/SourceFiles/data/data_shared_media.h

204 lines
5.3 KiB
C
Raw Normal View History

/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#pragma once
#include "storage/storage_shared_media.h"
#include "base/weak_ptr.h"
#include "data/data_sparse_ids.h"
class History;
2020-06-08 09:06:50 +00:00
namespace Main {
class Session;
} // namespace Main
2018-09-21 16:28:46 +00:00
std::optional<Storage::SharedMediaType> SharedMediaOverviewType(
Storage::SharedMediaType type);
void SharedMediaShowOverview(
Storage::SharedMediaType type,
not_null<History*> history);
bool SharedMediaAllowSearch(Storage::SharedMediaType type);
rpl::producer<SparseIdsSlice> SharedMediaViewer(
2020-06-08 09:06:50 +00:00
not_null<Main::Session*> session,
Storage::SharedMediaKey key,
int limitBefore,
int limitAfter);
struct SharedMediaMergedKey {
using Type = Storage::SharedMediaType;
SharedMediaMergedKey(
SparseIdsMergedSlice::Key mergedKey,
Type type)
: mergedKey(mergedKey)
, type(type) {
}
bool operator==(const SharedMediaMergedKey &other) const {
return (mergedKey == other.mergedKey)
&& (type == other.type);
}
SparseIdsMergedSlice::Key mergedKey;
Type type = Type::kCount;
};
rpl::producer<SparseIdsMergedSlice> SharedMediaMergedViewer(
2020-06-08 09:06:50 +00:00
not_null<Main::Session*> session,
SharedMediaMergedKey key,
int limitBefore,
int limitAfter);
class SharedMediaWithLastSlice {
public:
using Type = Storage::SharedMediaType;
using Value = std::variant<FullMsgId, not_null<PhotoData*>>;
using MessageId = SparseIdsMergedSlice::UniversalMsgId;
using UniversalMsgId = std::variant<
MessageId,
not_null<PhotoData*>>;
struct Key {
Key(
PeerId peerId,
PeerId migratedPeerId,
Type type,
UniversalMsgId universalId)
: peerId(peerId)
, migratedPeerId(migratedPeerId)
, type(type)
, universalId(universalId) {
Expects(v::is<MessageId>(universalId) || type == Type::ChatPhoto);
}
bool operator==(const Key &other) const {
return (peerId == other.peerId)
&& (migratedPeerId == other.migratedPeerId)
&& (type == other.type)
&& (universalId == other.universalId);
}
bool operator!=(const Key &other) const {
return !(*this == other);
}
PeerId peerId = 0;
PeerId migratedPeerId = 0;
Type type = Type::kCount;
UniversalMsgId universalId;
};
SharedMediaWithLastSlice(
2020-06-08 15:17:33 +00:00
not_null<Main::Session*> session,
Key key);
SharedMediaWithLastSlice(
not_null<Main::Session*> session,
Key key,
SparseIdsMergedSlice slice,
2018-09-21 16:28:46 +00:00
std::optional<SparseIdsMergedSlice> ending);
2018-09-21 16:28:46 +00:00
std::optional<int> fullCount() const;
std::optional<int> skippedBefore() const;
std::optional<int> skippedAfter() const;
std::optional<int> indexOf(Value fullId) const;
int size() const;
Value operator[](int index) const;
2018-09-21 16:28:46 +00:00
std::optional<int> distance(const Key &a, const Key &b) const;
2017-11-23 09:58:12 +00:00
void reverse();
static SparseIdsMergedSlice::Key ViewerKey(const Key &key) {
return {
key.peerId,
key.migratedPeerId,
v::is<MessageId>(key.universalId)
2020-09-01 19:56:25 +00:00
? v::get<MessageId>(key.universalId)
: ServerMaxMsgId - 1
};
}
static SparseIdsMergedSlice::Key EndingKey(const Key &key) {
return {
key.peerId,
key.migratedPeerId,
ServerMaxMsgId - 1
};
}
private:
2018-09-21 16:28:46 +00:00
static std::optional<SparseIdsMergedSlice> EndingSlice(const Key &key) {
return v::is<MessageId>(key.universalId)
? base::make_optional(SparseIdsMergedSlice(EndingKey(key)))
2018-09-21 16:28:46 +00:00
: std::nullopt;
}
2020-06-08 15:17:33 +00:00
static std::optional<PhotoId> LastPeerPhotoId(
not_null<Main::Session*> session,
PeerId peerId);
2018-09-21 16:28:46 +00:00
static std::optional<bool> IsLastIsolated(
2020-06-08 15:17:33 +00:00
not_null<Main::Session*> session,
const SparseIdsMergedSlice &slice,
2018-09-21 16:28:46 +00:00
const std::optional<SparseIdsMergedSlice> &ending,
std::optional<PhotoId> lastPeerPhotoId);
static std::optional<FullMsgId> LastFullMsgId(
const SparseIdsMergedSlice &slice);
2018-09-21 16:28:46 +00:00
static std::optional<int> Add(
const std::optional<int> &a,
const std::optional<int> &b) {
return (a && b) ? base::make_optional(*a + *b) : std::nullopt;
}
static Value ComputeId(PeerId peerId, MsgId msgId) {
return FullMsgId(
peerIsChannel(peerId) ? peerToBareInt(peerId) : 0,
msgId);
}
static Value ComputeId(const Key &key) {
if (const auto messageId = std::get_if<MessageId>(&key.universalId)) {
return (*messageId >= 0)
? ComputeId(key.peerId, *messageId)
: ComputeId(key.migratedPeerId, ServerMaxMsgId + *messageId);
}
2020-09-01 19:56:25 +00:00
return v::get<not_null<PhotoData*>>(key.universalId);
}
bool isolatedInSlice() const {
return (_slice.skippedAfter() != 0);
}
2018-09-21 16:28:46 +00:00
std::optional<int> lastPhotoSkip() const {
return _isolatedLastPhoto
| [](bool isolated) { return isolated ? 1 : 0; };
}
2018-09-21 16:28:46 +00:00
std::optional<int> skippedBeforeImpl() const;
std::optional<int> skippedAfterImpl() const;
std::optional<int> indexOfImpl(Value fullId) const;
2017-11-23 09:58:12 +00:00
2020-06-08 15:17:33 +00:00
not_null<Main::Session*> _session;
Key _key;
SparseIdsMergedSlice _slice;
2018-09-21 16:28:46 +00:00
std::optional<SparseIdsMergedSlice> _ending;
std::optional<PhotoId> _lastPhotoId;
std::optional<bool> _isolatedLastPhoto;
2017-11-23 09:58:12 +00:00
bool _reversed = false;
};
rpl::producer<SharedMediaWithLastSlice> SharedMediaWithLastViewer(
2020-06-08 09:06:50 +00:00
not_null<Main::Session*> session,
SharedMediaWithLastSlice::Key key,
int limitBefore,
int limitAfter);
2017-11-23 09:58:12 +00:00
rpl::producer<SharedMediaWithLastSlice> SharedMediaWithLastReversedViewer(
2020-06-08 09:06:50 +00:00
not_null<Main::Session*> session,
2017-11-23 09:58:12 +00:00
SharedMediaWithLastSlice::Key key,
int limitBefore,
int limitAfter);