andreacavalli/tdlib-fork
Archived
1
0
Fork 0
Code Pull Requests Releases Activity

Make FileLocation.type_ private.

Browse Source 
GitOrigin-RevId: 14841a320804eacbeef501df79c94b3bff2f4d0c
This commit is contained in:
levlam 2018-01-20 17:57:52 +03:00
parent 144b2b3aad
commit 1dffa9608d
9 changed files with 152 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
td/telegram/files/FileDb.cpp
View File

@ -176,30 +176,30 @@ class FileDb : public FileDbInterface {
void clear_file_data(Id id, const FileData &file_data) override {
string remote_key;
if (file_data.remote_.type_ == RemoteFileLocation::Type::Full) {
if (file_data.remote_.type() == RemoteFileLocation::Type::Full) {
remote_key = as_key(file_data.remote_.full());
}
string local_key;
if (file_data.local_.type_ == LocalFileLocation::Type::Full) {
if (file_data.local_.type() == LocalFileLocation::Type::Full) {
local_key = as_key(file_data.local_.full());
}
string generate_key;
if (file_data.generate_.type_ == GenerateFileLocation::Type::Full) {
if (file_data.generate_.type() == GenerateFileLocation::Type::Full) {
generate_key = as_key(file_data.generate_.full());
}
send_closure(file_db_actor_, &FileDbActor::clear_file_data, id, remote_key, local_key, generate_key);
}
void set_file_data(Id id, const FileData &file_data, bool new_remote, bool new_local, bool new_generate) override {
string remote_key;
if (file_data.remote_.type_ == RemoteFileLocation::Type::Full && new_remote) {
if (file_data.remote_.type() == RemoteFileLocation::Type::Full && new_remote) {
remote_key = as_key(file_data.remote_.full());
}
string local_key;
if (file_data.local_.type_ == LocalFileLocation::Type::Full && new_local) {
if (file_data.local_.type() == LocalFileLocation::Type::Full && new_local) {
local_key = as_key(file_data.local_.full());
}
string generate_key;
if (file_data.generate_.type_ == GenerateFileLocation::Type::Full && new_generate) {
if (file_data.generate_.type() == GenerateFileLocation::Type::Full && new_generate) {
generate_key = as_key(file_data.generate_.full());
}
LOG(DEBUG) << "SAVE " << id << " -> " << file_data << " "

20
td/telegram/files/FileDownloader.cpp
View File

@ -45,12 +45,12 @@ Result<FileLoader::FileInfo> FileDownloader::init() {
SCOPE_EXIT {
try_release_fd();
};
if (local_.type_ == LocalFileLocation::Type::Full) {
if (local_.type() == LocalFileLocation::Type::Full) {
return Status::Error("File is already downloaded");
}
int offset = 0;
int32 part_size = 0;
if (local_.type_ == LocalFileLocation::Type::Partial) {
if (local_.type() == LocalFileLocation::Type::Partial) {
const auto &partial = local_.partial();
path_ = partial.path_;
auto result_fd = FileFd::open(path_, FileFd::Write | FileFd::Read);
@ -80,11 +80,11 @@ Result<FileLoader::FileInfo> FileDownloader::init() {
return res;
}
Status FileDownloader::on_ok(int64 size) {
auto dir = get_files_dir(remote_.type_);
auto dir = get_files_dir(remote_.file_type_);
TRY_RESULT(perm_path, create_from_temp(path_, dir, name_));
fd_.close();
callback_->on_ok(FullLocalFileLocation(remote_.type_, std::move(perm_path), 0), size);
callback_->on_ok(FullLocalFileLocation(remote_.file_type_, std::move(perm_path), 0), size);
return Status::OK();
}
void FileDownloader::on_error(Status status) {
@ -212,7 +212,7 @@ Result<std::pair<NetQueryPtr, bool>> FileDownloader::start_part(Part part, int32
cdn_part_reupload_token_.erase(it);
}
}
net_query->file_type_ = narrow_cast<int32>(remote_.type_);
net_query->file_type_ = narrow_cast<int32>(remote_.file_type_);
return std::make_pair(std::move(net_query), false);
}
@ -306,7 +306,7 @@ void FileDownloader::on_progress(int32 part_count, int32 part_size, int32 ready_
return;
}
if (encryption_key_.empty()) {
callback_->on_partial_download(PartialLocalFileLocation{remote_.type_, path_, part_size, ready_part_count, ""},
callback_->on_partial_download(PartialLocalFileLocation{remote_.file_type_, path_, part_size, ready_part_count, ""},
ready_size);
} else {
UInt256 iv;
@ -315,9 +315,9 @@ void FileDownloader::on_progress(int32 part_count, int32 part_size, int32 ready_
} else {
LOG(FATAL) << tag("ready_part_count", ready_part_count) << tag("next_part", next_part_);
}
callback_->on_partial_download(
PartialLocalFileLocation{remote_.type_, path_, part_size, ready_part_count, Slice(iv.raw, sizeof(iv)).str()},
ready_size);
callback_->on_partial_download(PartialLocalFileLocation{remote_.file_type_, path_, part_size, ready_part_count,
Slice(iv.raw, sizeof(iv)).str()},
ready_size);
}
}
@ -417,7 +417,7 @@ void FileDownloader::try_release_fd() {
Status FileDownloader::acquire_fd() {
if (fd_.empty()) {
if (path_.empty()) {
TRY_RESULT(file_path, open_temp_file(remote_.type_));
TRY_RESULT(file_path, open_temp_file(remote_.file_type_));
std::tie(fd_, path_) = std::move(file_path);
} else {
TRY_RESULT(fd, FileFd::open(path_, FileFd::Write | FileFd::Read));

18
td/telegram/files/FileGenerateManager.cpp
View File

@ -87,7 +87,7 @@ class FileDownloadGenerateActor : public FileGenerateActor {
auto file_view = G()->td().get_actor_unsafe()->file_manager_->get_file_view(file_id);
if (file_view.has_local_location()) {
auto location = file_view.local_location();
location.type_ = file_type;
location.file_type_ = file_type;
callback->on_ok(location);
} else {
LOG(ERROR) << "Expected to have local location";
@ -132,19 +132,19 @@ class FileExternalGenerateActor : public FileGenerateActor {
ActorShared<> parent_;
void start_up() override {
if (local_.type_ == LocalFileLocation::Type::Full) {
if (local_.type() == LocalFileLocation::Type::Full) {
callback_->on_ok(local_.full());
callback_.reset();
return stop();
}
if (local_.type_ == LocalFileLocation::Type::Partial) {
if (local_.type() == LocalFileLocation::Type::Partial) {
const auto &partial = local_.partial();
path_ = partial.path_;
LOG(INFO) << "Unlink partially generated file at " << path_;
unlink(path_).ignore();
} else {
auto r_file_path = open_temp_file(generate_location_.type_);
auto r_file_path = open_temp_file(generate_location_.file_type_);
if (r_file_path.is_error()) {
return check_status(r_file_path.move_as_error());
}
@ -165,18 +165,18 @@ class FileExternalGenerateActor : public FileGenerateActor {
if (local_prefix_size < 0) {
return Status::Error(1, "Invalid local prefix size");
}
callback_->on_partial_generate(PartialLocalFileLocation{generate_location_.type_, path_, 1, local_prefix_size, ""},
expected_size);
callback_->on_partial_generate(
PartialLocalFileLocation{generate_location_.file_type_, path_, 1, local_prefix_size, ""}, expected_size);
return Status::OK();
}
Status do_file_generate_finish(Status status) {
TRY_STATUS(std::move(status));
auto dir = get_files_dir(generate_location_.type_);
auto dir = get_files_dir(generate_location_.file_type_);
TRY_RESULT(perm_path, create_from_temp(path_, dir, name_));
callback_->on_ok(FullLocalFileLocation(generate_location_.type_, std::move(perm_path), 0));
callback_->on_ok(FullLocalFileLocation(generate_location_.file_type_, std::move(perm_path), 0));
callback_.reset();
stop();
return Status::OK();
@ -224,7 +224,7 @@ void FileGenerateManager::generate_file(uint64 query_id, const FullGenerateFileL
auto &query = it_flag.first->second;
if (conversion.copy().truncate(file_id_query.size()) == file_id_query) {
auto file_id = FileId(to_integer<int32>(conversion.substr(file_id_query.size())));
query.worker_ = create_actor<FileDownloadGenerateActor>("FileDownloadGenerateActor", generate_location.type_,
query.worker_ = create_actor<FileDownloadGenerateActor>("FileDownloadGenerateActor", generate_location.file_type_,
file_id, std::move(callback), std::move(parent));
} else {
query.worker_ = create_actor<FileExternalGenerateActor>("FileExternalGenerationActor", query_id, generate_location,

90
td/telegram/files/FileLocation.h
View File

@ -394,7 +394,7 @@ inline StringBuilder &operator<<(StringBuilder &string_builder, const CommonRemo
class FullRemoteFileLocation {
public:
FileType type_{FileType::None};
FileType file_type_{FileType::None};
private:
static constexpr int32 WEB_LOCATION_FLAG = 1 << 24;
@ -407,7 +407,7 @@ class FullRemoteFileLocation {
if (is_web()) {
return LocationType::Web;
}
switch (type_) {
switch (file_type_) {
case FileType::Photo:
case FileType::ProfilePhoto:
case FileType::Thumbnail:
@ -455,7 +455,7 @@ class FullRemoteFileLocation {
const FullRemoteFileLocation &full_remote_file_location);
int32 full_type() const {
auto type = static_cast<int32>(type_);
auto type = static_cast<int32>(file_type_);
if (is_web()) {
type |= WEB_LOCATION_FLAG;
}
@ -483,7 +483,7 @@ class FullRemoteFileLocation {
if (raw_type < 0 || raw_type >= static_cast<int32>(FileType::Size)) {
return parser.set_error("Invalid FileType in FullRemoteFileLocation");
}
type_ = static_cast<FileType>(raw_type);
file_type_ = static_cast<FileType>(raw_type);
int32 dc_id_value;
parse(dc_id_value, parser);
dc_id_ = DcId::from_value(dc_id_value);
@ -572,7 +572,7 @@ class FullRemoteFileLocation {
return location_type() == LocationType::Common;
}
bool is_encrypted() const {
return type_ == FileType::Encrypted;
return file_type_ == FileType::Encrypted;
}
tl_object_ptr<telegram_api::inputWebFileLocation> as_input_web_file_location() const {
@ -617,17 +617,17 @@ class FullRemoteFileLocation {
FullRemoteFileLocation() = default;
FullRemoteFileLocation(FileType file_type, int64 id, int64 access_hash, int32 local_id, int64 volume_id, int64 secret,
DcId dc_id)
: type_(file_type)
: file_type_(file_type)
, dc_id_(dc_id)
, variant_(PhotoRemoteFileLocation{id, access_hash, volume_id, secret, local_id}) {
CHECK(is_photo());
}
FullRemoteFileLocation(FileType file_type, int64 id, int64 access_hash, DcId dc_id)
: type_(file_type), dc_id_(dc_id), variant_(CommonRemoteFileLocation{id, access_hash}) {
: file_type_(file_type), dc_id_(dc_id), variant_(CommonRemoteFileLocation{id, access_hash}) {
CHECK(is_common());
}
FullRemoteFileLocation(FileType file_type, string url, int64 access_hash, DcId dc_id)
: type_(file_type)
: file_type_(file_type)
, web_location_flag_{true}
, dc_id_(dc_id)
, variant_(WebRemoteFileLocation{std::move(url), access_hash}) {
@ -681,7 +681,7 @@ class FullRemoteFileLocation {
inline StringBuilder &operator<<(StringBuilder &string_builder,
const FullRemoteFileLocation &full_remote_file_location) {
string_builder << "[" << file_type_name[static_cast<int32>(full_remote_file_location.type_)] << ", "
string_builder << "[" << file_type_name[static_cast<int32>(full_remote_file_location.file_type_)] << ", "
<< full_remote_file_location.get_dc_id() << ", location = ";
if (full_remote_file_location.is_web()) {
@ -698,7 +698,10 @@ inline StringBuilder &operator<<(StringBuilder &string_builder,
class RemoteFileLocation {
public:
enum class Type : int32 { Empty, Partial, Full };
Type type_;
Type type() const {
return type_;
}
template <class StorerT>
void store(StorerT &storer) const {
@ -759,6 +762,7 @@ class RemoteFileLocation {
}
private:
Type type_;
Variant<EmptyRemoteFileLocation, PartialRemoteFileLocation, FullRemoteFileLocation> variant_;
friend bool operator==(const RemoteFileLocation &lhs, const RemoteFileLocation &rhs);
@ -790,7 +794,7 @@ inline bool operator!=(const EmptyLocalFileLocation &lhs, const EmptyLocalFileLo
}
struct PartialLocalFileLocation {
FileType type_;
FileType file_type_;
string path_;
int32 part_size_;
int32 ready_part_count_;
@ -799,7 +803,7 @@ struct PartialLocalFileLocation {
template <class StorerT>
void store(StorerT &storer) const {
using td::store;
store(type_, storer);
store(file_type_, storer);
store(path_, storer);
store(part_size_, storer);
store(ready_part_count_, storer);
@ -808,8 +812,8 @@ struct PartialLocalFileLocation {
template <class ParserT>
void parse(ParserT &parser) {
using td::parse;
parse(type_, parser);
if (type_ < FileType::Thumbnail || type_ >= FileType::Size) {
parse(file_type_, parser);
if (file_type_ < FileType::Thumbnail || file_type_ >= FileType::Size) {
return parser.set_error("Invalid type in PartialLocalFileLocation");
}
parse(path_, parser);
@ -820,7 +824,7 @@ struct PartialLocalFileLocation {
};
inline bool operator==(const PartialLocalFileLocation &lhs, const PartialLocalFileLocation &rhs) {
return lhs.type_ == rhs.type_ && lhs.path_ == rhs.path_ && lhs.part_size_ == rhs.part_size_ &&
return lhs.file_type_ == rhs.file_type_ && lhs.path_ == rhs.path_ && lhs.part_size_ == rhs.part_size_ &&
lhs.ready_part_count_ == rhs.ready_part_count_ && lhs.iv_ == rhs.iv_;
}
@ -829,22 +833,22 @@ inline bool operator!=(const PartialLocalFileLocation &lhs, const PartialLocalFi
}
struct FullLocalFileLocation {
FileType type_;
FileType file_type_;
string path_;
uint64 mtime_nsec_;
template <class StorerT>
void store(StorerT &storer) const {
using td::store;
store(type_, storer);
store(file_type_, storer);
store(mtime_nsec_, storer);
store(path_, storer);
}
template <class ParserT>
void parse(ParserT &parser) {
using td::parse;
parse(type_, parser);
if (type_ < FileType::Thumbnail || type_ >= FileType::Size) {
parse(file_type_, parser);
if (file_type_ < FileType::Thumbnail || file_type_ >= FileType::Size) {
return parser.set_error("Invalid type in FullLocalFileLocation");
}
parse(mtime_nsec_, parser);
@ -855,21 +859,21 @@ struct FullLocalFileLocation {
}
// TODO: remove this constructor
FullLocalFileLocation() : type_(FileType::Photo) {
FullLocalFileLocation() : file_type_(FileType::Photo) {
}
FullLocalFileLocation(FileType file_type, string path, uint64 mtime_nsec)
: type_(file_type), path_(std::move(path)), mtime_nsec_(mtime_nsec) {
: file_type_(file_type), path_(std::move(path)), mtime_nsec_(mtime_nsec) {
}
static const int32 KEY_MAGIC = 0x84373817;
};
inline bool operator<(const FullLocalFileLocation &lhs, const FullLocalFileLocation &rhs) {
return std::tie(lhs.type_, lhs.mtime_nsec_, lhs.path_) < std::tie(rhs.type_, rhs.mtime_nsec_, rhs.path_);
return std::tie(lhs.file_type_, lhs.mtime_nsec_, lhs.path_) < std::tie(rhs.file_type_, rhs.mtime_nsec_, rhs.path_);
}
inline bool operator==(const FullLocalFileLocation &lhs, const FullLocalFileLocation &rhs) {
return std::tie(lhs.type_, lhs.mtime_nsec_, lhs.path_) == std::tie(rhs.type_, rhs.mtime_nsec_, rhs.path_);
return std::tie(lhs.file_type_, lhs.mtime_nsec_, lhs.path_) == std::tie(rhs.file_type_, rhs.mtime_nsec_, rhs.path_);
}
inline bool operator!=(const FullLocalFileLocation &lhs, const FullLocalFileLocation &rhs) {
@ -883,7 +887,10 @@ inline StringBuilder &operator<<(StringBuilder &sb, const FullLocalFileLocation
class LocalFileLocation {
public:
enum class Type : int32 { Empty, Partial, Full };
Type type_;
Type type() const {
return type_;
}
PartialLocalFileLocation &partial() {
return variant_.get<1>();
@ -936,6 +943,7 @@ class LocalFileLocation {
}
private:
Type type_;
Variant<EmptyLocalFileLocation, PartialLocalFileLocation, FullLocalFileLocation> variant_;
friend bool operator==(const LocalFileLocation &lhs, const LocalFileLocation &rhs);
@ -950,7 +958,7 @@ inline bool operator!=(const LocalFileLocation &lhs, const LocalFileLocation &rh
}
struct FullGenerateFileLocation {
FileType type_{FileType::None};
FileType file_type_{FileType::None};
string original_path_;
string conversion_;
static const int32 KEY_MAGIC = 0x8b60a1c8;
@ -958,14 +966,14 @@ struct FullGenerateFileLocation {
template <class StorerT>
void store(StorerT &storer) const {
using td::store;
store(type_, storer);
store(file_type_, storer);
store(original_path_, storer);
store(conversion_, storer);
}
template <class ParserT>
void parse(ParserT &parser) {
using td::parse;
parse(type_, parser);
parse(file_type_, parser);
parse(original_path_, parser);
parse(conversion_, parser);
}
@ -974,19 +982,19 @@ struct FullGenerateFileLocation {
return *this;
}
FullGenerateFileLocation() = default;
FullGenerateFileLocation(FileType type, string original_path, string conversion)
: type_(type), original_path_(std::move(original_path)), conversion_(std::move(conversion)) {
FullGenerateFileLocation(FileType file_type, string original_path, string conversion)
: file_type_(file_type), original_path_(std::move(original_path)), conversion_(std::move(conversion)) {
}
};
inline bool operator<(const FullGenerateFileLocation &lhs, const FullGenerateFileLocation &rhs) {
return std::tie(lhs.type_, lhs.original_path_, lhs.conversion_) <
std::tie(rhs.type_, rhs.original_path_, rhs.conversion_);
return std::tie(lhs.file_type_, lhs.original_path_, lhs.conversion_) <
std::tie(rhs.file_type_, rhs.original_path_, rhs.conversion_);
}
inline bool operator==(const FullGenerateFileLocation &lhs, const FullGenerateFileLocation &rhs) {
return std::tie(lhs.type_, lhs.original_path_, lhs.conversion_) ==
std::tie(rhs.type_, rhs.original_path_, rhs.conversion_);
return std::tie(lhs.file_type_, lhs.original_path_, lhs.conversion_) ==
std::tie(rhs.file_type_, rhs.original_path_, rhs.conversion_);
}
inline bool operator!=(const FullGenerateFileLocation &lhs, const FullGenerateFileLocation &rhs) {
@ -996,7 +1004,7 @@ inline bool operator!=(const FullGenerateFileLocation &lhs, const FullGenerateFi
inline StringBuilder &operator<<(StringBuilder &string_builder,
const FullGenerateFileLocation &full_generated_file_location) {
return string_builder << "["
<< tag("file_type", file_type_name[static_cast<int32>(full_generated_file_location.type_)])
<< tag("file_type", file_type_name[static_cast<int32>(full_generated_file_location.file_type_)])
<< tag("original_path", full_generated_file_location.original_path_)
<< tag("conversion", full_generated_file_location.conversion_) << "]";
}
@ -1004,7 +1012,10 @@ inline StringBuilder &operator<<(StringBuilder &string_builder,
class GenerateFileLocation {
public:
enum class Type : int32 { Empty, Full };
Type type_;
Type type() const {
return type_;
}
FullGenerateFileLocation &full() {
CHECK(type_ == Type::Full);
@ -1049,14 +1060,15 @@ class GenerateFileLocation {
}
private:
Type type_;
FullGenerateFileLocation full_;
};
inline bool operator==(const GenerateFileLocation &lhs, const GenerateFileLocation &rhs) {
if (lhs.type_ != rhs.type_) {
if (lhs.type() != rhs.type()) {
return false;
}
switch (lhs.type_) {
switch (lhs.type()) {
case GenerateFileLocation::Type::Empty:
return true;
case GenerateFileLocation::Type::Full:
@ -1138,10 +1150,10 @@ class FileData {
};
inline StringBuilder &operator<<(StringBuilder &sb, const FileData &file_data) {
sb << "[" << tag("name", file_data.name_);
if (file_data.local_.type_ == LocalFileLocation::Type::Full) {
if (file_data.local_.type() == LocalFileLocation::Type::Full) {
sb << " local " << file_data.local_.full();
}
if (file_data.remote_.type_ == RemoteFileLocation::Type::Full) {
if (file_data.remote_.type() == RemoteFileLocation::Type::Full) {
sb << " remote " << file_data.remote_.full();
}
return sb << "]";

112
td/telegram/files/FileManager.cpp
View File

@ -57,7 +57,7 @@ void FileNode::set_remote_location(const RemoteFileLocation &remote, FileLocatio
on_info_changed();
}
if (remote_ == remote) {
if (remote_.type_ == RemoteFileLocation::Type::Full) {
if (remote_.type() == RemoteFileLocation::Type::Full) {
if (remote_.full().get_access_hash() == remote.full().get_access_hash()) {
return;
}
@ -178,22 +178,22 @@ bool FileNode::need_pmc_flush() const {
// We must save encryption key
if (!encryption_key_.empty()) {
// && remote_.type_ != RemoteFileLocation::Type::Empty
// && remote_.type() != RemoteFileLocation::Type::Empty
return true;
}
bool has_generate_location = generate_.type_ == GenerateFileLocation::Type::Full;
bool has_generate_location = generate_.type() == GenerateFileLocation::Type::Full;
// Do not save "#file_id#" conversion.
if (has_generate_location && begins_with(generate_.full().conversion_, "#file_id#")) {
has_generate_location = false;
}
if (remote_.type_ == RemoteFileLocation::Type::Full &&
(has_generate_location || local_.type_ != LocalFileLocation::Type::Empty)) {
if (remote_.type() == RemoteFileLocation::Type::Full &&
(has_generate_location || local_.type() != LocalFileLocation::Type::Empty)) {
return true;
}
if (local_.type_ == LocalFileLocation::Type::Full &&
(has_generate_location || remote_.type_ != RemoteFileLocation::Type::Empty)) {
if (local_.type() == LocalFileLocation::Type::Full &&
(has_generate_location || remote_.type() != RemoteFileLocation::Type::Empty)) {
return true;
}
@ -211,21 +211,21 @@ void FileNode::on_info_flushed() {
/*** FileView ***/
bool FileView::has_local_location() const {
return node_->local_.type_ == LocalFileLocation::Type::Full;
return node_->local_.type() == LocalFileLocation::Type::Full;
}
const FullLocalFileLocation &FileView::local_location() const {
CHECK(has_local_location());
return node_->local_.full();
}
bool FileView::has_remote_location() const {
return node_->remote_.type_ == RemoteFileLocation::Type::Full;
return node_->remote_.type() == RemoteFileLocation::Type::Full;
}
const FullRemoteFileLocation &FileView::remote_location() const {
CHECK(has_remote_location());
return node_->remote_.full();
}
bool FileView::has_generate_location() const {
return node_->generate_.type_ == GenerateFileLocation::Type::Full;
return node_->generate_.type() == GenerateFileLocation::Type::Full;
}
const FullGenerateFileLocation &FileView::generate_location() const {
CHECK(has_generate_location());
@ -248,7 +248,7 @@ bool FileView::is_downloading() const {
}
int64 FileView::local_size() const {
switch (node_->local_.type_) {
switch (node_->local_.type()) {
case LocalFileLocation::Type::Full:
return node_->size_;
case LocalFileLocation::Type::Partial:
@ -258,7 +258,7 @@ int64 FileView::local_size() const {
}
}
int64 FileView::local_total_size() const {
switch (node_->local_.type_) {
switch (node_->local_.type()) {
case LocalFileLocation::Type::Empty:
return 0;
case LocalFileLocation::Type::Full:
@ -278,7 +278,7 @@ bool FileView::is_uploading() const {
}
int64 FileView::remote_size() const {
switch (node_->remote_.type_) {
switch (node_->remote_.type()) {
case RemoteFileLocation::Type::Full:
return node_->size_;
case RemoteFileLocation::Type::Partial: {
@ -296,7 +296,7 @@ int64 FileView::remote_size() const {
}
string FileView::path() const {
switch (node_->local_.type_) {
switch (node_->local_.type()) {
case LocalFileLocation::Type::Full:
return node_->local_.full().path_;
case LocalFileLocation::Type::Partial:
@ -337,7 +337,7 @@ bool FileView::can_download_from_server() const {
if (!has_remote_location()) {
return false;
}
if (remote_location().type_ == FileType::Encrypted && encryption_key().empty()) {
if (remote_location().file_type_ == FileType::Encrypted && encryption_key().empty()) {
return false;
}
if (remote_location().get_dc_id().is_empty()) {
@ -353,7 +353,7 @@ bool FileView::can_delete() const {
if (has_local_location()) {
return begins_with(local_location().path_, get_files_dir(get_type()));
}
return node_->local_.type_ == LocalFileLocation::Type::Partial;
return node_->local_.type() == LocalFileLocation::Type::Partial;
}
/*** FileManager ***/
@ -493,7 +493,7 @@ Status FileManager::check_local_location(FullLocalFileLocation &location, int64
LOG(INFO) << "File was nodified: old mtime = " << location.mtime_nsec_ << ", new mtime = " << stat.mtime_nsec_;
return Status::Error("File was modified");
}
if ((location.type_ == FileType::Thumbnail || location.type_ == FileType::EncryptedThumbnail) &&
if ((location.file_type_ == FileType::Thumbnail || location.file_type_ == FileType::EncryptedThumbnail) &&
size >= MAX_THUMBNAIL_SIZE) {
return Status::Error(PSLICE() << "File is too big for thumbnail " << tag("size", format::as_size(size)));
}
@ -514,9 +514,9 @@ static Status check_partial_local_location(const PartialLocalFileLocation &locat
Status FileManager::check_local_location(FileNode *node) {
Status status;
if (node->local_.type_ == LocalFileLocation::Type::Full) {
if (node->local_.type() == LocalFileLocation::Type::Full) {
status = check_local_location(node->local_.full(), node->size_);
} else if (node->local_.type_ == LocalFileLocation::Type::Partial) {
} else if (node->local_.type() == LocalFileLocation::Type::Partial) {
status = check_partial_local_location(node->local_.partial());
}
if (status.is_error()) {
@ -623,13 +623,13 @@ Result<FileId> FileManager::register_generate(FileType file_type, string origina
Result<FileId> FileManager::register_file(FileData data, FileLocationSource file_location_source, const char *source,
bool force) {
bool has_remote = data.remote_.type_ == RemoteFileLocation::Type::Full;
bool has_generate = data.generate_.type_ == GenerateFileLocation::Type::Full;
if (data.local_.type_ == LocalFileLocation::Type::Full && !force) {
bool has_remote = data.remote_.type() == RemoteFileLocation::Type::Full;
bool has_generate = data.generate_.type() == GenerateFileLocation::Type::Full;
if (data.local_.type() == LocalFileLocation::Type::Full && !force) {
if (file_location_source == FileLocationSource::FromDb) {
PathView path_view(data.local_.full().path_);
if (path_view.is_relative()) {
data.local_.full().path_ = get_files_base_dir(data.local_.full().type_) + data.local_.full().path_;
data.local_.full().path_ = get_files_base_dir(data.local_.full().file_type_) + data.local_.full().path_;
}
}
@ -643,7 +643,7 @@ Result<FileId> FileManager::register_file(FileData data, FileLocationSource file
}
}
}
bool has_local = data.local_.type_ == LocalFileLocation::Type::Full;
bool has_local = data.local_.type() == LocalFileLocation::Type::Full;
bool has_location = has_local || has_remote || has_generate;
if (!has_location) {
return Status::Error("No location");
@ -711,8 +711,8 @@ Result<FileId> FileManager::register_file(FileData data, FileLocationSource file
// 1 -- choose y
// 2 -- choose any
static int merge_choose(const LocalFileLocation &x, const LocalFileLocation &y) {
int32 x_type = static_cast<int32>(x.type_);
int32 y_type = static_cast<int32>(y.type_);
int32 x_type = static_cast<int32>(x.type());
int32 y_type = static_cast<int32>(y.type());
if (x_type != y_type) {
return x_type < y_type;
}
@ -720,13 +720,13 @@ static int merge_choose(const LocalFileLocation &x, const LocalFileLocation &y)
}
static int merge_choose(const RemoteFileLocation &x, int8 x_source, const RemoteFileLocation &y, int8 y_source) {
int32 x_type = static_cast<int32>(x.type_);
int32 y_type = static_cast<int32>(y.type_);
int32 x_type = static_cast<int32>(x.type());
int32 y_type = static_cast<int32>(y.type());
if (x_type != y_type) {
return x_type < y_type;
}
// If access_hash changed use a newer one
if (x.type_ == RemoteFileLocation::Type::Full) {
if (x.type() == RemoteFileLocation::Type::Full) {
if (x.full().get_access_hash() != y.full().get_access_hash()) {
return x_source < y_source;
}
@ -734,8 +734,8 @@ static int merge_choose(const RemoteFileLocation &x, int8 x_source, const Remote
return 2;
}
static int merge_choose(const GenerateFileLocation &x, const GenerateFileLocation &y) {
int32 x_type = static_cast<int32>(x.type_);
int32 y_type = static_cast<int32>(y.type_);
int32 x_type = static_cast<int32>(x.type());
int32 y_type = static_cast<int32>(y.type());
if (x_type != y_type) {
return x_type < y_type;
}
@ -856,8 +856,8 @@ Result<FileId> FileManager::merge(FileId x_file_id, FileId y_file_id, bool no_sy
y_node->upload_pause_ = FileId();
}
if (x_node->remote_.type_ == RemoteFileLocation::Type::Full &&
y_node->remote_.type_ == RemoteFileLocation::Type::Full &&
if (x_node->remote_.type() == RemoteFileLocation::Type::Full &&
y_node->remote_.type() == RemoteFileLocation::Type::Full &&
x_node->remote_.full().get_dc_id() != y_node->remote_.full().get_dc_id()) {
LOG(ERROR) << "File remote location was changed from " << y_node->remote_.full() << " to "
<< x_node->remote_.full();
@ -884,8 +884,8 @@ Result<FileId> FileManager::merge(FileId x_file_id, FileId y_file_id, bool no_sy
<< y_node->size_);
}
if (encryption_key_i == -1) {
if (nodes[remote_i]->remote_.type_ == RemoteFileLocation::Type::Full &&
nodes[local_i]->local_.type_ != LocalFileLocation::Type::Partial) {
if (nodes[remote_i]->remote_.type() == RemoteFileLocation::Type::Full &&
nodes[local_i]->local_.type() != LocalFileLocation::Type::Partial) {
//???
LOG(ERROR) << "Different encryption key in files, but go Choose same key as remote location";
encryption_key_i = remote_i;
@ -1105,19 +1105,19 @@ void FileManager::flush_to_pmc(FileNode *node, bool new_remote, bool new_local,
FileData data;
data.pmc_id_ = node->pmc_id_;
data.local_ = node->local_;
if (data.local_.type_ == LocalFileLocation::Type::Full) {
prepare_path_for_pmc(data.local_.full().type_, data.local_.full().path_);
if (data.local_.type() == LocalFileLocation::Type::Full) {
prepare_path_for_pmc(data.local_.full().file_type_, data.local_.full().path_);
}
data.remote_ = node->remote_;
data.generate_ = node->generate_;
if (data.generate_.type_ == GenerateFileLocation::Type::Full &&
if (data.generate_.type() == GenerateFileLocation::Type::Full &&
begins_with(data.generate_.full().conversion_, "#file_id#")) {
data.generate_ = GenerateFileLocation();
}
// TODO: not needed when GenerateLocation has constant convertion
if (data.remote_.type_ != RemoteFileLocation::Type::Full && data.local_.type_ != LocalFileLocation::Type::Full) {
if (data.remote_.type() != RemoteFileLocation::Type::Full && data.local_.type() != LocalFileLocation::Type::Full) {
data.local_ = LocalFileLocation();
data.remote_ = RemoteFileLocation();
}
@ -1182,7 +1182,7 @@ bool FileManager::load_from_pmc(FileNode *node, bool new_remote, bool new_local,
new_local &= file_view.has_local_location();
if (new_local) {
local = get_file_view(file_id).local_location();
prepare_path_for_pmc(local.type_, local.path_);
prepare_path_for_pmc(local.file_type_, local.path_);
}
new_generate &= file_view.has_generate_location();
if (new_generate) {
@ -1230,7 +1230,7 @@ bool FileManager::set_content(FileId file_id, BufferSlice bytes) {
return false;
}
if (node->local_.type_ == LocalFileLocation::Type::Full) {
if (node->local_.type() == LocalFileLocation::Type::Full) {
// There was no download so we don't need an update
return true;
}
@ -1249,7 +1249,7 @@ bool FileManager::set_content(FileId file_id, BufferSlice bytes) {
QueryId id = queries_container_.create(Query{file_id, Query::SetContent});
node->download_id_ = id;
node->is_download_started_ = true;
send_closure(file_load_manager_, &FileLoadManager::from_bytes, id, node->remote_.full().type_, std::move(bytes),
send_closure(file_load_manager_, &FileLoadManager::from_bytes, id, node->remote_.full().file_type_, std::move(bytes),
node->name_);
return true;
}
@ -1294,7 +1294,7 @@ void FileManager::delete_file(FileId file_id, Promise<Unit> promise, const char
if (file_view.get_type() == FileType::Encrypted) {
clear_from_pmc(node);
}
if (node->local_.type_ == LocalFileLocation::Type::Partial) {
if (node->local_.type() == LocalFileLocation::Type::Partial) {
LOG(INFO) << "Unlink partial file " << file_id << " at " << node->local_.partial().path_;
unlink(node->local_.partial().path_).ignore();
node->set_local_location(LocalFileLocation(), 0);
@ -1314,7 +1314,7 @@ void FileManager::download(FileId file_id, std::shared_ptr<DownloadCallback> cal
return;
}
if (node->local_.type_ == LocalFileLocation::Type::Full) {
if (node->local_.type() == LocalFileLocation::Type::Full) {
auto status = check_local_location(node);
if (status.is_error()) {
LOG(WARNING) << "Need to redownload file " << file_id << ": " << status.error();
@ -1324,7 +1324,7 @@ void FileManager::download(FileId file_id, std::shared_ptr<DownloadCallback> cal
}
return;
}
} else if (node->local_.type_ == LocalFileLocation::Type::Partial) {
} else if (node->local_.type() == LocalFileLocation::Type::Partial) {
auto status = check_local_location(node);
if (status.is_error()) {
LOG(WARNING) << "Need to download file " << file_id << " from beginning: " << status.error();
@ -1461,7 +1461,7 @@ bool FileManager::delete_partial_remote_location(FileId file_id) {
if (node->upload_pause_ == file_id) {
node->upload_pause_ = FileId();
}
if (node->remote_.type_ == RemoteFileLocation::Type::Full) {
if (node->remote_.type() == RemoteFileLocation::Type::Full) {
LOG(INFO) << "File " << file_id << " is already uploaded";
return true;
}
@ -1470,7 +1470,7 @@ bool FileManager::delete_partial_remote_location(FileId file_id) {
auto *file_info = get_file_id_info(file_id);
file_info->upload_priority_ = 0;
if (node->local_.type_ != LocalFileLocation::Type::Full) {
if (node->local_.type() != LocalFileLocation::Type::Full) {
LOG(INFO) << "Need full local location to upload file " << file_id;
return false;
}
@ -1603,8 +1603,8 @@ void FileManager::run_upload(FileNode *node, std::vector<int> bad_parts) {
}
// create encryption key if necessary
if (((file_view.has_generate_location() && file_view.generate_location().type_ == FileType::Encrypted) ||
(file_view.has_local_location() && file_view.local_location().type_ == FileType::Encrypted)) &&
if (((file_view.has_generate_location() && file_view.generate_location().file_type_ == FileType::Encrypted) ||
(file_view.has_local_location() && file_view.local_location().file_type_ == FileType::Encrypted)) &&
file_view.encryption_key().empty()) {
CHECK(!node->file_ids_.empty());
bool success = set_encryption_key(node->file_ids_[0], FileEncryptionKey::create());
@ -1619,7 +1619,7 @@ void FileManager::run_upload(FileNode *node, std::vector<int> bad_parts) {
}
CHECK(node->upload_id_ == 0);
if (node->remote_.type_ != RemoteFileLocation::Type::Partial && node->get_by_hash_) {
if (node->remote_.type() != RemoteFileLocation::Type::Partial && node->get_by_hash_) {
QueryId id = queries_container_.create(Query{file_id, Query::UploadByHash});
node->upload_id_ = id;
@ -1726,10 +1726,10 @@ Result<FileId> FileManager::from_persistent_id(CSlice persistent_id, FileType fi
if (status.is_error()) {
return Status::Error(10, "Wrong remote file id specified: can't unserialize it");
}
auto &real_type = remote_location.type_;
if (is_document_type(real_type) && is_document_type(file_type)) {
real_type = file_type;
} else if (real_type != file_type && file_type != FileType::Temp) {
auto &real_file_type = remote_location.file_type_;
if (is_document_type(real_file_type) && is_document_type(file_type)) {
real_file_type = file_type;
} else if (real_file_type != file_type && file_type != FileType::Temp) {
return Status::Error(10, "Type of file mismatch");
}
FileData data;
@ -2173,12 +2173,12 @@ void FileManager::on_error_impl(FileNode *node, FileManager::Query::Type type, b
<< ". File type is " << file_type_name[static_cast<int32>(FileView(node).get_type())];
if (status.code() == 0) {
// Remove partial locations
if (node->local_.type_ == LocalFileLocation::Type::Partial) {
if (node->local_.type() == LocalFileLocation::Type::Partial) {
LOG(INFO) << "Unlink file " << node->local_.partial().path_;
unlink(node->local_.partial().path_).ignore();
node->set_local_location(LocalFileLocation(), 0);
}
if (node->remote_.type_ == RemoteFileLocation::Type::Partial) {
if (node->remote_.type() == RemoteFileLocation::Type::Partial) {
node->set_remote_location(RemoteFileLocation(), FileLocationSource::None, 0);
}
status = Status::Error(400, status.message());

6
td/telegram/files/FileManager.h
View File

@ -166,13 +166,13 @@ class FileView {
FileType get_type() const {
if (has_local_location()) {
return local_location().type_;
return local_location().file_type_;
}
if (has_remote_location()) {
return remote_location().type_;
return remote_location().file_type_;
}
if (has_generate_location()) {
return generate_location().type_;
return generate_location().file_type_;
}
return FileType::Temp;
}

10
td/telegram/files/FileManager.hpp
View File

@ -160,7 +160,7 @@ FileId FileManager::parse_file(ParserT &parser) {
return r_file_id.move_as_ok();
}
LOG(ERROR) << "Can't resend local file " << full_local_location.path_;
return register_empty(full_local_location.type_);
return register_empty(full_local_location.file_type_);
}
case FileStoreType::Generate: {
FullGenerateFileLocation full_generated_location;
@ -175,23 +175,23 @@ FileId FileManager::parse_file(ParserT &parser) {
}
if (begins_with(full_generated_location.conversion_, "#file_id#")) {
LOG(ERROR) << "Can't resend message with '#file_id#...' location";
return register_empty(full_generated_location.type_);
return register_empty(full_generated_location.file_type_);
}
if (full_generated_location.conversion_ == "#_file_id#") {
auto file_id = parse_file(parser);
if (file_id.empty()) {
return register_empty(full_generated_location.type_);
return register_empty(full_generated_location.file_type_);
}
auto download_file_id = dup_file_id(file_id);
full_generated_location.conversion_ = PSTRING() << "#file_id#" << download_file_id.get();
}
auto r_file_id = register_generate(full_generated_location.type_, full_generated_location.original_path_,
auto r_file_id = register_generate(full_generated_location.file_type_, full_generated_location.original_path_,
full_generated_location.conversion_, owner_dialog_id, expected_size);
if (r_file_id.is_ok()) {
return r_file_id.move_as_ok();
}
return register_empty(full_generated_location.type_);
return register_empty(full_generated_location.file_type_);
}
case FileStoreType::Url: {
FileType type;

10
td/telegram/files/FileStatsWorker.cpp
View File

@ -54,11 +54,11 @@ Status scan_db(CallbackT &&callback) {
return;
}
DbFileInfo info;
if (data.local_.type_ == LocalFileLocation::Type::Full) {
info.file_type = data.local_.full().type_;
if (data.local_.type() == LocalFileLocation::Type::Full) {
info.file_type = data.local_.full().file_type_;
info.path = data.local_.full().path_;
} else if (data.local_.type_ == LocalFileLocation::Type::Partial) {
info.file_type = data.local_.partial().type_;
} else if (data.local_.type() == LocalFileLocation::Type::Partial) {
info.file_type = data.local_.partial().file_type_;
info.path = data.local_.partial().path_;
} else {
return;
@ -69,7 +69,7 @@ Status scan_db(CallbackT &&callback) {
}
info.owner_dialog_id = data.owner_dialog_id_;
info.size = data.size_;
if (info.size == 0 && data.local_.type_ == LocalFileLocation::Type::Full) {
if (info.size == 0 && data.local_.type() == LocalFileLocation::Type::Full) {
LOG(ERROR) << "Unknown size in db";
return;
}

14
td/telegram/files/FileUploader.cpp
View File

@ -36,7 +36,7 @@ FileUploader::FileUploader(const LocalFileLocation &local, const RemoteFileLocat
}
Result<FileLoader::FileInfo> FileUploader::init() {
if (remote_.type_ == RemoteFileLocation::Type::Full) {
if (remote_.type() == RemoteFileLocation::Type::Full) {
return Status::Error("File is already uploaded");
}
@ -45,7 +45,7 @@ Result<FileLoader::FileInfo> FileUploader::init() {
int offset = 0;
int part_size = 0;
if (remote_.type_ == RemoteFileLocation::Type::Partial) {
if (remote_.type() == RemoteFileLocation::Type::Partial) {
const auto &partial = remote_.partial();
file_id_ = partial.file_id_;
part_size = partial.part_size_;
@ -87,20 +87,20 @@ Result<FileLoader::PrefixInfo> FileUploader::on_update_local_location(const Loca
int64 local_size = 0;
bool local_is_ready{false};
FileType file_type{FileType::Temp};
if (location.type_ == LocalFileLocation::Type::Empty) {
if (location.type() == LocalFileLocation::Type::Empty) {
path = "";
local_size = 0;
local_is_ready = false;
file_type = FileType::Temp;
} else if (location.type_ == LocalFileLocation::Type::Partial) {
} else if (location.type() == LocalFileLocation::Type::Partial) {
path = location.partial().path_;
local_size = static_cast<int64>(location.partial().part_size_) * location.partial().ready_part_count_;
local_is_ready = false;
file_type = location.partial().type_;
file_type = location.partial().file_type_;
} else {
path = location.full().path_;
local_is_ready = true;
file_type = location.full().type_;
file_type = location.full().file_type_;
}
if (!path.empty() && path != fd_path_) {
@ -108,7 +108,7 @@ Result<FileLoader::PrefixInfo> FileUploader::on_update_local_location(const Loca
// Race: partial location could be already deleted. Just ignore such locations
if (res_fd.is_error()) {
if (location.type_ == LocalFileLocation::Type::Partial) {
if (location.type() == LocalFileLocation::Type::Partial) {
PrefixInfo info;
info.size = local_size_;
info.is_ready = local_is_ready_;