gpesquero/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Review fixes.

Browse source
This commit is contained in:
Yuri Gorshenin 2015-06-16 13:24:50 +03:00 • committed by Alex Zolotarev
parent c53d7f1494
commit 6afccd14ac
37 changed files with 490 additions and 147 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
android/jni/com/mapswithme/country/country_helper.cpp
View file

@ -8,7 +8,7 @@ namespace storage_utils
storage::CountryTree & GetTree() { return frm()->GetCountryTree(); }
storage::ActiveMapsLayout::TGroup ToGroup(int group) { return static_cast<storage::ActiveMapsLayout::TGroup>(group); }
storage::TMapOptions ToOptions(int options) {return static_cast<storage::TMapOptions>(options); }
TMapOptions ToOptions(int options) { return static_cast<TMapOptions>(options); }
jlongArray ToArray(JNIEnv * env, storage::LocalAndRemoteSizeT const & size)
{
jlongArray result = env->NewLongArray(2);

2
android/jni/com/mapswithme/country/country_helper.hpp
View file

@ -12,6 +12,6 @@ namespace storage_utils
storage::CountryTree & GetTree();
storage::ActiveMapsLayout::TGroup ToGroup(int group);
storage::TMapOptions ToOptions(int options);
TMapOptions ToOptions(int options);
jlongArray ToArray(JNIEnv * env, storage::LocalAndRemoteSizeT const & sizes);
}

7
android/jni/com/mapswithme/maps/Framework.hpp
View file

@ -6,6 +6,8 @@
#include "../../../../../search/result.hpp"
#include "../../../../../platform/country_defines.hpp"
#include "../../../../../geometry/avg_vector.hpp"
#include "../../../../../base/deferred_task.hpp"
@ -174,8 +176,9 @@ namespace android
storage::ActiveMapsLayout::TGroup const & newGroup, int newPosition);
virtual void CountryStatusChanged(storage::ActiveMapsLayout::TGroup const & group, int position,
storage::TStatus const & oldStatus, storage::TStatus const & newStatus);
virtual void CountryOptionsChanged(storage::ActiveMapsLayout::TGroup const & group, int position,
storage::TMapOptions const & oldOpt, storage::TMapOptions const & newOpt);
virtual void CountryOptionsChanged(storage::ActiveMapsLayout::TGroup const & group,
int position, TMapOptions const & oldOpt,
TMapOptions const & newOpt);
virtual void DownloadingProgressUpdate(storage::ActiveMapsLayout::TGroup const & group, int position,
storage::LocalAndRemoteSizeT const & progress);
};

21
coding/coding_tests/file_utils_test.cpp
View file

@ -38,3 +38,24 @@ UNIT_TEST(FileName_Smoke)
my::GetNameWithoutExt(name);
TEST_EQUAL(name, "test", ());
}
UNIT_TEST(FileName_GetDirectory)
{
// TODO (@gorshenin): implement a Clean() method to clean file path
// (remove redundant separators, correctly collapse dots, dot-dots, etc.).
#if !defined(OMIM_OS_WINDOWS)
TEST_EQUAL("/tmp", my::GetDirectory("/tmp/evil\\file"), ());
TEST_EQUAL(".", my::GetDirectory("evil\\file"), ());
TEST_EQUAL("/", my::GetDirectory("/somefile.txt"), ());
TEST_EQUAL("/", my::GetDirectory("////somefile"), ());
TEST_EQUAL("a/b", my::GetDirectory("a/b///somefile.txt"), ());
TEST_EQUAL("/a/b", my::GetDirectory("/a/b/c"), ());
TEST_EQUAL("/a/b", my::GetDirectory("/a/b/c.txt"), ());
TEST_EQUAL(".", my::GetDirectory("somefile.txt"), ());
TEST_EQUAL(".", my::GetDirectory("somefile"), ());
#endif // !defined(OMIM_OS_WINDOWS)
}

18
coding/file_name_utils.cpp
View file

@ -1,9 +1,7 @@
#include "coding/file_name_utils.hpp"
namespace my
{
void GetNameWithoutExt(string & name)
{
string::size_type const i = name.rfind('.');
@ -24,6 +22,19 @@ void GetNameFromFullPath(string & name)
name = name.substr(i+1);
}
string GetDirectory(string const & name)
{
string const sep = GetNativeSeparator();
size_t const sepSize = sep.size();
string::size_type i = name.rfind(sep);
if (i == string::npos)
return ".";
while (i > sepSize && (name.substr(i - sepSize, sepSize) == sep))
i -= sepSize;
return i == 0 ? sep : name.substr(0, i);
}
string GetNativeSeparator()
{
#ifdef OMIM_OS_WINDOWS
@ -63,5 +74,4 @@ string JoinFoldersToPath(const vector<string> & folders, const string & file)
result += file;
return result;
}
}
} // namespace my

5
coding/file_name_utils.hpp
View file

@ -13,6 +13,11 @@ namespace my
/// Get file name from full path.
void GetNameFromFullPath(string & name);
/// Returns all but last components of the path. After dropping the last
/// component, all trailing slashes are removed, unless the result is a
/// root directory. If the argument is a single component, returns ".".
string GetDirectory(string const & path);
/// Get folder separator for specific platform
string GetNativeSeparator();

2
iphone/Maps/ActiveMapsVC.mm
View file

@ -128,7 +128,7 @@ extern NSString * const MapsStatusChangedNotification;
return [NSString stringWithUTF8String:self.mapsLayout.GetCountryName(self.selectedGroup, self.selectedPosition).c_str()];
}
- (uint64_t)selectedMapSizeWithOptions:(storage::TMapOptions)options
- (uint64_t)selectedMapSizeWithOptions:(TMapOptions)options
{
return self.mapsLayout.GetCountrySize(self.selectedGroup, self.selectedPosition, options).second;
}

10
iphone/Maps/Classes/CustomAlert/DownloadTransitMapsAlert/MWMDownloadTransitMapAlert.mm
View file

@ -33,10 +33,12 @@ extern UIColor * const kActiveDownloaderViewColor;
MWMDownloadTransitMapAlert *alert = [[[NSBundle mainBundle] loadNibNamed:kDownloadTransitMapAlertNibName owner:self options:nil] firstObject];
ActiveMapsLayout& layout = GetFramework().GetCountryTree().GetActiveMapLayout();
alert.countryLabel.text = [NSString stringWithUTF8String:layout.GetFormatedCountryName(index).c_str()];
alert.sizeLabel.text = [NSString stringWithFormat:@"%@ %@", @(layout.GetCountrySize(index, storage::TMapOptions::EMapWithCarRouting).second/(1024 * 1024)), L(@"mb")];
alert.downloaderBlock = ^{
layout.DownloadMap(index, storage::TMapOptions::EMapWithCarRouting);
};
alert.sizeLabel.text = [NSString
stringWithFormat:@"%@ %@",
@(layout.GetCountrySize(index, TMapOptions::EMapWithCarRouting).second /
(1024 * 1024)),
L(@"mb")];
alert.downloaderBlock = ^{ layout.DownloadMap(index, TMapOptions::EMapWithCarRouting); };
[alert configure];
return alert;
}

1
iphone/Maps/Classes/MapCell.h
View file

@ -4,6 +4,7 @@
#import "BadgeView.h"
#include "../../storage/storage_defines.hpp"
#include "../../platform/country_defines.hpp"
using namespace storage;

2
iphone/Maps/Classes/MapViewController.mm
View file

@ -676,7 +676,7 @@ typedef NS_ENUM(NSUInteger, UserTouchesAction)
LocalAndRemoteSizeT sizes = layout.GetRemoteCountrySizes(idx);
uint64_t sizeToDownload = sizes.first;
TMapOptions options = static_cast<TMapOptions>(opt);
if(options & TMapOptions::ECarRouting)
if(HasOptions(options, TMapOptions::ECarRouting))
sizeToDownload += sizes.second;
NSString * name = [NSString stringWithUTF8String:layout.GetCountryName(idx).c_str()];

2
iphone/Maps/CountryTreeVC.mm
View file

@ -135,7 +135,7 @@ extern NSString * const MapsStatusChangedNotification;
return [NSString stringWithUTF8String:self.tree.GetChildName(self.selectedPosition).c_str()];
}
- (uint64_t)selectedMapSizeWithOptions:(storage::TMapOptions)options
- (uint64_t)selectedMapSizeWithOptions:(TMapOptions)options
{
return self.tree.GetLeafSize(self.selectedPosition, options).second;
}

6
map/active_maps_layout.cpp
View file

@ -647,13 +647,13 @@ void ActiveMapsLayout::NotifyOptionsChanged(TGroup const & group, int position,
TMapOptions ActiveMapsLayout::ValidOptionsForDownload(TMapOptions const & options)
{
return options | TMapOptions::EMap;
return SetOptions(options, TMapOptions::EMap);
}
TMapOptions ActiveMapsLayout::ValidOptionsForDelete(TMapOptions const & options)
{
if (options & TMapOptions::EMap)
return options | TMapOptions::ECarRouting;
if (HasOptions(options, TMapOptions::EMap))
return SetOptions(options, TMapOptions::ECarRouting);
return options;
}

2
map/active_maps_layout.hpp
View file

@ -3,6 +3,8 @@
#include "storage/storage_defines.hpp"
#include "storage/index.hpp"
#include "platform/country_defines.hpp"
#include "base/buffer_vector.hpp"
#include "std/string.hpp"

2
map/country_status_display.cpp
View file

@ -449,7 +449,7 @@ void CountryStatusDisplay::OnButtonClicked(gui::Element const * button)
TMapOptions options = TMapOptions::EMap;
if (button == m_secondaryButton.get())
options |= TMapOptions::ECarRouting;
options = SetOptions(options, TMapOptions::ECarRouting);
ASSERT(m_downloadCallback, ());
int opt = static_cast<int>(options);

6
map/country_status_display.hpp
View file

@ -3,7 +3,7 @@
#include "map/active_maps_layout.hpp"
#include "gui/element.hpp"
#include "storage/storage_defines.hpp"
#include "platform/country_defines.hpp"
#ifdef OMIM_OS_ANDROID
#include "../base/mutex.hpp"
@ -70,7 +70,9 @@ private:
virtual void CountryStatusChanged(storage::ActiveMapsLayout::TGroup const & group, int position,
storage::TStatus const & oldStatus, storage::TStatus const & newStatus);
virtual void CountryOptionsChanged(storage::ActiveMapsLayout::TGroup const & group, int position,
storage::TMapOptions const & oldOpt, storage::TMapOptions const & newOpt){}
TMapOptions const & oldOpt, TMapOptions const & newOpt)
{
}
virtual void DownloadingProgressUpdate(storage::ActiveMapsLayout::TGroup const & group, int position,
storage::LocalAndRemoteSizeT const & progress);

10
map/framework.cpp
View file

@ -396,20 +396,20 @@ double Framework::GetVisualScale() const
void Framework::DeleteCountry(TIndex const & index, TMapOptions opt)
{
if (opt & TMapOptions::EMap)
if (HasOptions(opt, TMapOptions::EMap))
opt = TMapOptions::EMapWithCarRouting;
if (!m_storage.DeleteFromDownloader(index))
{
CountryFile const & file = m_storage.CountryByIndex(index).GetFile();
if (opt & TMapOptions::EMap)
if (HasOptions(opt, TMapOptions::EMap))
{
if (m_model.DeleteMap(file.GetFileWithExt(TMapOptions::EMap)))
InvalidateRect(GetCountryBounds(file.GetFileWithoutExt()), true);
}
if (opt & TMapOptions::ECarRouting)
if (HasOptions(opt, TMapOptions::ECarRouting))
m_routingSession.DeleteIndexFile(file.GetFileWithExt(TMapOptions::ECarRouting));
m_storage.NotifyStatusChanged(index);
@ -470,7 +470,7 @@ void Framework::ShowCountry(TIndex const & index)
void Framework::UpdateAfterDownload(string const & fileName, TMapOptions opt)
{
if (opt & TMapOptions::EMap)
if (HasOptions(opt, TMapOptions::EMap))
{
// Delete old (splitted) map files, if any.
char const * arr[] = { "Japan", "Brazil" };
@ -496,7 +496,7 @@ void Framework::UpdateAfterDownload(string const & fileName, TMapOptions opt)
}
// Replace routing file.
if (opt & TMapOptions::ECarRouting)
if (HasOptions(opt, TMapOptions::ECarRouting))
{
string routingName = fileName + ROUTING_FILE_EXTENSION;
m_routingSession.DeleteIndexFile(routingName);

7
map/framework.hpp
View file

@ -33,6 +33,7 @@
#include "storage/storage.hpp"
#include "platform/country_defines.hpp"
#include "platform/location.hpp"
#ifndef USE_DRAPE
@ -135,7 +136,7 @@ protected:
/// This function is called by m_storage to notify that country downloading is finished.
/// @param[in] file Country file name (without extensions).
void UpdateAfterDownload(string const & file, storage::TMapOptions opt);
void UpdateAfterDownload(string const & file, TMapOptions opt);
//my::Timer m_timer;
inline double ElapsedSeconds() const
@ -211,9 +212,9 @@ public:
/// @name This functions is used by Downloader UI.
//@{
/// options - flags that signal about parts of map that must be deleted
void DeleteCountry(storage::TIndex const & index, storage::TMapOptions opt);
void DeleteCountry(storage::TIndex const & index, TMapOptions opt);
/// options - flags that signal about parts of map that must be downloaded
void DownloadCountry(storage::TIndex const & index, storage::TMapOptions opt);
void DownloadCountry(storage::TIndex const & index, TMapOptions opt);
storage::TStatus GetCountryStatus(storage::TIndex const & index) const;
string GetCountryName(storage::TIndex const & index) const;

12
platform/country_defines.cpp
View file

@ -2,13 +2,23 @@
#include "base/assert.hpp"
bool HasOptions(TMapOptions options, TMapOptions bits)
{
return (static_cast<uint8_t>(options) & static_cast<uint8_t>(bits)) == static_cast<uint8_t>(bits);
}
TMapOptions SetOptions(TMapOptions options, TMapOptions bits)
{
return static_cast<TMapOptions>(static_cast<uint8_t>(options) | static_cast<uint8_t>(bits));
}
string DebugPrint(TMapOptions options)
{
switch (options)
{
case TMapOptions::ENothing:
return "Nothing";
case TMapOptions::EMapOnly:
case TMapOptions::EMap:
return "MapOnly";
case TMapOptions::ECarRouting:
return "CarRouting";

10
platform/country_defines.hpp
View file

@ -1,15 +1,17 @@
#pragma once
#include "std/string.hpp"
#include "3party/enum_flags.hpp"
ENUM_FLAGS(TMapOptions)
enum class TMapOptions
enum class TMapOptions : uint8_t
{
ENothing = 0x0,
EMapOnly = 0x1,
EMap = 0x1,
ECarRouting = 0x2,
EMapWithCarRouting = 0x3
};
bool HasOptions(TMapOptions options, TMapOptions bits);
TMapOptions SetOptions(TMapOptions options, TMapOptions bits);
string DebugPrint(TMapOptions options);

9
platform/country_file.cpp
View file

@ -4,6 +4,8 @@
#include "base/assert.hpp"
#include "std/sstream.hpp"
namespace platform
{
CountryFile::CountryFile() : m_mapSize(0), m_routingSize(0) {}
CountryFile::CountryFile(string const & name) : m_name(name), m_mapSize(0), m_routingSize(0) {}
@ -14,7 +16,7 @@ string CountryFile::GetNameWithExt(TMapOptions file) const
{
switch (file)
{
case TMapOptions::EMapOnly:
case TMapOptions::EMap:
return m_name + DATA_FILE_EXTENSION;
case TMapOptions::ECarRouting:
return m_name + DATA_FILE_EXTENSION + ROUTING_FILE_EXTENSION;
@ -33,9 +35,9 @@ void CountryFile::SetRemoteSizes(uint32_t mapSize, uint32_t routingSize)
uint32_t CountryFile::GetRemoteSize(TMapOptions filesMask) const
{
uint32_t size = 0;
if (filesMask & TMapOptions::EMapOnly)
if (HasOptions(filesMask, TMapOptions::EMap))
size += m_mapSize;
if (filesMask & TMapOptions::ECarRouting)
if (HasOptions(filesMask, TMapOptions::ECarRouting))
size += m_routingSize;
return size;
}
@ -46,3 +48,4 @@ string DebugPrint(CountryFile const & file)
os << "CountryFile [" << file.m_name << "]";
return os.str();
}
} // namespace platform

5
platform/country_file.hpp
View file

@ -3,9 +3,11 @@
#include "platform/country_defines.hpp"
#include "std/string.hpp"
namespace platform
{
// This class represents a country file name and sizes of
// corresponding map files on a server, which should correspond to an
// entry in counties.txt file. Also, this class can be used to
// entry in countries.txt file. Also, this class can be used to
// represent a hand-made-country name. Instances of this class don't
// represent paths to disk files.
class CountryFile
@ -34,3 +36,4 @@ private:
};
string DebugPrint(CountryFile const & file);
} // namespace platform

30
platform/local_country_file.cpp
View file

@ -8,6 +8,8 @@
#include "std/sstream.hpp"
namespace platform
{
LocalCountryFile::LocalCountryFile()
: m_version(0), m_files(TMapOptions::ENothing), m_mapSize(0), m_routingSize()
{
@ -32,21 +34,23 @@ void LocalCountryFile::SyncWithDisk()
Platform & platform = GetPlatform();
string const mapPath = GetPath(TMapOptions::EMapOnly);
if (platform.GetFileSizeByName(mapPath, m_mapSize))
m_files = m_files | TMapOptions::EMapOnly;
if (platform.GetFileSizeByName(GetPath(TMapOptions::EMap), m_mapSize))
m_files = SetOptions(m_files, TMapOptions::EMap);
string const routingPath = GetPath(TMapOptions::ECarRouting);
if (platform.GetFileSizeByName(routingPath, m_routingSize))
m_files = m_files | TMapOptions::ECarRouting;
m_files = SetOptions(m_files, TMapOptions::ECarRouting);
}
void LocalCountryFile::DeleteFromDisk()
{
for (TMapOptions file : {TMapOptions::EMapOnly, TMapOptions::ECarRouting})
for (TMapOptions file : {TMapOptions::EMap, TMapOptions::ECarRouting})
{
if (OnDisk(file))
my::DeleteFileX(GetPath(file));
{
bool const deleted = my::DeleteFileX(GetPath(file));
ASSERT(deleted, (file, "from", *this, "wasn't deleted from disk."));
}
}
}
@ -58,9 +62,9 @@ string LocalCountryFile::GetPath(TMapOptions file) const
uint32_t LocalCountryFile::GetSize(TMapOptions filesMask) const
{
uint64_t size64 = 0;
if (filesMask & TMapOptions::EMapOnly)
if (HasOptions(filesMask, TMapOptions::EMap))
size64 += m_mapSize;
if (filesMask & TMapOptions::ECarRouting)
if (HasOptions(filesMask, TMapOptions::ECarRouting))
size64 += m_routingSize;
uint32_t const size32 = static_cast<uint32_t>(size64);
ASSERT_EQUAL(size32, size64, ());
@ -73,12 +77,17 @@ bool LocalCountryFile::operator<(LocalCountryFile const & rhs) const
return m_countryFile < rhs.m_countryFile;
if (m_version != rhs.m_version)
return m_version < rhs.m_version;
return m_files < rhs.m_files;
if (m_directory != rhs.m_directory)
return m_directory < rhs.m_directory;
if (m_files != rhs.m_files)
return m_files < rhs.m_files;
return false;
}
bool LocalCountryFile::operator==(LocalCountryFile const & rhs) const
{
return m_countryFile == rhs.m_countryFile && m_version == rhs.m_version && m_files == rhs.m_files;
return m_directory == rhs.m_directory && m_countryFile == rhs.m_countryFile &&
m_version == rhs.m_version && m_files == rhs.m_files;
}
// static
@ -97,3 +106,4 @@ string DebugPrint(LocalCountryFile const & file)
<< file.m_version << ", " << DebugPrint(file.m_files) << "]";
return os.str();
}
} // namespace platform

3
platform/local_country_file.hpp
View file

@ -6,6 +6,8 @@
#include "std/string.hpp"
#include "std/vector.hpp"
namespace platform
{
// This class represents a path to disk files corresponding to some
// country region.
class LocalCountryFile
@ -71,3 +73,4 @@ private:
};
string DebugPrint(LocalCountryFile const & file);
} // namespace platform

149
platform/local_country_file_utils.cpp
View file

@ -2,17 +2,71 @@
#include "platform/platform.hpp"
#include "coding/file_name_utils.hpp"
#include "coding/file_writer.hpp"
#include "base/string_utils.hpp"
#include "base/logging.hpp"
#include "std/algorithm.hpp"
#include "std/cctype.hpp"
namespace local_country_file_utils
namespace platform
{
namespace
{
size_t const kMaxTimestampLength = 18;
bool IsSpecialFile(string const & file) { return file == "." || file == ".."; }
} // namespace
void CleanupMapsDirectory()
{
Platform & platform = GetPlatform();
string const mapsDir = platform.WritableDir();
// Remove partially downloaded maps.
{
Platform::FilesList files;
string const regexp = "\\" DATA_FILE_EXTENSION "\\.(downloading2?$|resume2?$)";
platform.GetFilesByRegExp(mapsDir, regexp, files);
for (string const & file : files)
FileWriter::DeleteFileX(file);
}
// Find and remove Brazil and Japan maps.
vector<LocalCountryFile> localFiles;
FindAllLocalMaps(localFiles);
for (LocalCountryFile & localFile : localFiles)
{
CountryFile const countryFile = localFile.GetCountryFile();
if (countryFile.GetNameWithoutExt() == "Japan" || countryFile.GetNameWithoutExt() == "Brazil")
{
localFile.SyncWithDisk();
localFile.DeleteFromDisk();
}
}
// Try to delete empty folders.
Platform::FilesList subdirs;
Platform::GetFilesByType(mapsDir, Platform::FILE_TYPE_DIRECTORY, subdirs);
for (string const & subdir : subdirs)
{
int64_t version;
if (ParseVersion(subdir, version))
{
vector<string> files;
string const subdirPath = my::JoinFoldersToPath(mapsDir, subdir);
platform.GetFilesByType(subdirPath,
Platform::FILE_TYPE_REGULAR | Platform::FILE_TYPE_DIRECTORY, files);
if (all_of(files.begin(), files.end(), &IsSpecialFile))
{
Platform::EError ret = Platform::RmDir(subdirPath);
ASSERT_EQUAL(Platform::ERR_OK, ret,
("Can't remove empty directory:", subdirPath, "error:", ret));
}
}
}
}
void FindAllLocalMapsInDirectory(string const & directory, int64_t version,
vector<LocalCountryFile> & localFiles)
{
@ -22,11 +76,10 @@ void FindAllLocalMapsInDirectory(string const & directory, int64_t version,
platform.GetFilesByRegExp(directory, ".*\\" DATA_FILE_EXTENSION "$", files);
for (string const & file : files)
{
// Remove DATA_FILE_EXTENSION and use base name as a country file name.
string name = file;
my::GetNameWithoutExt(name);
CountryFile const countryFile(name);
localFiles.emplace_back(directory, countryFile, version);
localFiles.emplace_back(directory, CountryFile(name), version);
}
}
@ -34,7 +87,13 @@ void FindAllLocalMaps(vector<LocalCountryFile> & localFiles)
{
vector<LocalCountryFile> allFiles;
Platform & platform = GetPlatform();
for (string const & directory : {platform.ResourcesDir(), platform.WritableDir()})
vector<string> baseDirectories = {
platform.ResourcesDir(), platform.WritableDir(),
};
sort(baseDirectories.begin(), baseDirectories.end());
baseDirectories.erase(unique(baseDirectories.begin(), baseDirectories.end()),
baseDirectories.end());
for (string const & directory : baseDirectories)
{
FindAllLocalMapsInDirectory(directory, 0 /* version */, allFiles);
@ -47,12 +106,35 @@ void FindAllLocalMaps(vector<LocalCountryFile> & localFiles)
FindAllLocalMapsInDirectory(my::JoinFoldersToPath(directory, subdir), version, allFiles);
}
}
#ifdef OMIM_OS_ANDROID
#if defined(OMIM_OS_ANDROID)
// On Android World and WorldCoasts can be stored in alternative /Android/obb/ path.
FindAllLocalMapsInDirectory("/Android/obb/", 0 /* version */, allFiles);
#endif
sort(allFiles.begin(), allFiles.end());
allFiles.erase(unique(allFiles.begin(), allFiles.end()), allFiles.end());
for (string const & file : {WORLD_FILE_NAME, WORLD_COASTS_FILE_NAME})
{
bool found = false;
for (LocalCountryFile const & localFile : allFiles)
{
if (localFile.GetCountryFile().GetNameWithoutExt() == file)
{
found = true;
break;
}
}
if (!found)
{
try
{
ModelReaderPtr reader = platform.GetReader(file + DATA_FILE_EXTENSION);
allFiles.emplace_back(my::GetDirectory(reader.GetName()), CountryFile(file),
0 /* version */);
}
catch (FileAbsentException const & e)
{
LOG(LERROR, ("Can't find map file for", file, "."));
}
}
}
#endif // defined(OMIM_OS_ANDROID)
localFiles.insert(localFiles.end(), allFiles.begin(), allFiles.end());
}
@ -60,14 +142,41 @@ bool ParseVersion(string const & s, int64_t & version)
{
if (s.empty() || s.size() > kMaxTimestampLength)
return false;
if (!all_of(s.begin(), s.end(), [](char c) -> bool
{
return isdigit(c);
}))
return false;
version = 0;
for (char c : s)
version = version * 10 + c - '0';
int64_t v = 0;
for (char const c : s)
{
if (!isdigit(c))
return false;
v = v * 10 + c - '0';
}
version = v;
return true;
}
} // namespace local_country_file_utils
shared_ptr<LocalCountryFile> PreparePlaceForCountryFiles(CountryFile const & countryFile,
int64_t version)
{
Platform & platform = GetPlatform();
if (version == 0)
return make_shared<LocalCountryFile>(platform.WritableDir(), countryFile, version);
string const directory =
my::JoinFoldersToPath(platform.WritableDir(), strings::to_string(version));
switch (platform.MkDir(directory))
{
case Platform::ERR_OK:
return make_shared<LocalCountryFile>(directory, countryFile, version);
case Platform::ERR_FILE_ALREADY_EXISTS:
{
Platform::EFileType type;
if (Platform::GetFileType(directory, type) != Platform::ERR_OK ||
type != Platform::FILE_TYPE_DIRECTORY)
{
return shared_ptr<LocalCountryFile>();
}
return make_shared<LocalCountryFile>(directory, countryFile, version);
}
default:
return shared_ptr<LocalCountryFile>();
};
}
} // namespace platform

37
platform/local_country_file_utils.hpp
View file

@ -2,14 +2,47 @@
#include "platform/local_country_file.hpp"
#include "std/shared_ptr.hpp"
#include "std/utility.hpp"
#include "std/vector.hpp"
namespace local_country_file_utils
namespace platform
{
// Removes partially downloaded maps, empty directories and old
// (format v1) maps. Also, removes old (splitted) Japan and Brazil
// maps.
void CleanupMapsDirectory();
// Finds all local map files in a directory. Version of these files is
// passed as an argument.
void FindAllLocalMapsInDirectory(string const & directory, int64_t version,
vector<LocalCountryFile> & localFiles);
// Finds all local map files in resources and writable
// directory. Also, for Android, checks /Android/obb directory.
// Directories should have the following structure:
//
// dir/*.mwm -- map files, base name should correspond to countries.txt,
// -- version is assumed to be zero (unknown).
// dir/*.mwm.routing -- routing files for corresponding map files,
// -- version is assumed to be zero (unknown).
// dir/[0-9]+/*.mwm -- map files, base name should correspond to countries.txt,
// -- version is assumed to be the name of a directory.
// dir/[0-9]{1,18}/*.mwm.routing -- routing file for corresponding map files,
// -- version is assumed to be the name of a directory.
//
// We can't derive version of a map file from its header because
// currently header stores format version + individual mwm's file
// generation timestamp, not timestamp mentioned in countries.txt.
void FindAllLocalMaps(vector<LocalCountryFile> & localFiles);
// Tries to parse a version from a string of size not longer than 18
// symbols and representing an unsigned decimal number. Leading zeroes
// are allowed.
bool ParseVersion(string const & s, int64_t & version);
} // namespace local_country_file_utils
// When version is zero, uses writable directory, otherwise, creates
// directory with name equal to decimal representation of version.
shared_ptr<LocalCountryFile> PreparePlaceForCountryFiles(CountryFile const & countryFile,
int64_t version);
} // namespace platform

2
platform/platform.cpp
View file

@ -20,6 +20,8 @@ Platform::EError Platform::ErrnoToError()
return ERR_ACCESS_FAILED;
case ENOTEMPTY:
return ERR_DIRECTORY_NOT_EMPTY;
case EEXIST:
return ERR_FILE_ALREADY_EXISTS;
default:
return ERR_UNKNOWN;
}

1
platform/platform.hpp
View file

@ -25,6 +25,7 @@ public:
ERR_FILE_DOES_NOT_EXIST,
ERR_ACCESS_FAILED,
ERR_DIRECTORY_NOT_EMPTY,
ERR_FILE_ALREADY_EXISTS,
ERR_UNKNOWN
};

2
platform/platform_qt.cpp
View file

@ -59,6 +59,8 @@ int Platform::VideoMemoryLimit() const
Platform::EError Platform::MkDir(string const & dirName) const
{
if (QDir().exists(dirName.c_str()))
return Platform::ERR_FILE_ALREADY_EXISTS;
if(!QDir().mkdir(dirName.c_str()))
{
LOG(LWARNING, ("Can't create directory: ", dirName));

10
platform/platform_tests/country_file_tests.cpp
View file

@ -3,24 +3,26 @@
#include "defines.hpp"
#include "platform/country_file.hpp"
namespace platform
{
UNIT_TEST(CountryFile_Smoke)
{
CountryFile countryFile("TestCountry");
TEST_EQUAL("TestCountry", countryFile.GetNameWithoutExt(), ());
TEST_EQUAL("TestCountry" DATA_FILE_EXTENSION, countryFile.GetNameWithExt(TMapOptions::EMapOnly),
());
TEST_EQUAL("TestCountry" DATA_FILE_EXTENSION, countryFile.GetNameWithExt(TMapOptions::EMap), ());
TEST_EQUAL("TestCountry" DATA_FILE_EXTENSION ROUTING_FILE_EXTENSION,
countryFile.GetNameWithExt(TMapOptions::ECarRouting), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::ENothing), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::EMapOnly), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::EMap), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::ECarRouting), ());
TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::EMapWithCarRouting), ());
countryFile.SetRemoteSizes(1 /* mapSize */, 2 /* routingSize */);
TEST_EQUAL(0, countryFile.GetRemoteSize(TMapOptions::ENothing), ());
TEST_EQUAL(1, countryFile.GetRemoteSize(TMapOptions::EMapOnly), ());
TEST_EQUAL(1, countryFile.GetRemoteSize(TMapOptions::EMap), ());
TEST_EQUAL(2, countryFile.GetRemoteSize(TMapOptions::ECarRouting), ());
TEST_EQUAL(3, countryFile.GetRemoteSize(TMapOptions::EMapWithCarRouting), ());
}
} // namespace platform

197
platform/platform_tests/local_country_file_tests.cpp
View file

@ -16,22 +16,73 @@
#include "std/bind.hpp"
#include "std/set.hpp"
using namespace local_country_file_utils;
namespace platform
{
namespace
{
void CreateTestDir(string const & testDir)
template <typename T>
bool Contains(vector<T> const & v, T const & t)
{
Platform & platform = GetPlatform();
TEST(!Platform::IsFileExistsByFullPath(testDir),
("Please, remove", testDir, "before running the test."));
TEST_EQUAL(Platform::ERR_OK, platform.MkDir(testDir), ("Can't create directory", testDir));
return find(v.begin(), v.end(), t) != v.end();
}
class ScopedTestDir
{
public:
ScopedTestDir(string const & path) : m_path(path), m_reset(false)
{
Platform & platform = GetPlatform();
Platform::EError ret = platform.MkDir(m_path);
switch (ret)
{
case Platform::ERR_OK:
break;
case Platform::ERR_FILE_ALREADY_EXISTS:
Platform::EFileType type;
TEST_EQUAL(Platform::ERR_OK, Platform::GetFileType(m_path, type), ());
TEST_EQUAL(Platform::FILE_TYPE_DIRECTORY, type, ());
break;
default:
CHECK(false, ("Can't create directory:", m_path, "error:", ret));
break;
}
}
~ScopedTestDir()
{
if (m_reset)
return;
Platform::EError ret = Platform::RmDir(m_path);
switch (ret)
{
case Platform::ERR_OK:
break;
case Platform::ERR_FILE_DOES_NOT_EXIST:
LOG(LWARNING, (m_path, "was deleted before destruction of ScopedTestDir."));
break;
case Platform::ERR_DIRECTORY_NOT_EMPTY:
LOG(LWARNING, ("There are files in", m_path));
break;
default:
LOG(LWARNING, ("Platform::RmDir() error:", ret));
break;
}
}
inline void Reset() { m_reset = true; }
inline string const GetPath() const { return m_path; }
private:
string const m_path;
bool m_reset;
DISALLOW_COPY_AND_MOVE(ScopedTestDir);
};
void CreateTestFile(string const & testFile, string const & contents)
{
TEST(!Platform::IsFileExistsByFullPath(testFile),
("Please, remove", testFile, "before running the test."));
{
FileWriter writer(testFile);
writer.Write(contents.data(), contents.size());
@ -59,6 +110,7 @@ UNIT_TEST(LocalCountryFile_ParseVersion)
TEST_EQUAL(version, 999999999999999999, ());
TEST(!ParseVersion("1000000000000000000", version), ());
TEST(!ParseVersion("00000000000000000000000000000000123", version), ());
TEST(!ParseVersion("", version), ());
TEST(!ParseVersion("150309 ", version), ());
@ -75,8 +127,7 @@ UNIT_TEST(LocalCountryFile_Smoke)
LocalCountryFile localFile("/test-dir", countryFile, 150309);
TEST_EQUAL("/test-dir/TestCountry" DATA_FILE_EXTENSION, localFile.GetPath(TMapOptions::EMapOnly),
());
TEST_EQUAL("/test-dir/TestCountry" DATA_FILE_EXTENSION, localFile.GetPath(TMapOptions::EMap), ());
TEST_EQUAL("/test-dir/TestCountry" DATA_FILE_EXTENSION ROUTING_FILE_EXTENSION,
localFile.GetPath(TMapOptions::ECarRouting), ());
@ -86,14 +137,14 @@ UNIT_TEST(LocalCountryFile_Smoke)
// Any statement is true about elements of an empty set.
TEST(localFile.OnDisk(TMapOptions::ENothing), ());
TEST(!localFile.OnDisk(TMapOptions::EMapOnly), ());
TEST(!localFile.OnDisk(TMapOptions::EMap), ());
TEST(!localFile.OnDisk(TMapOptions::ECarRouting), ());
TEST(!localFile.OnDisk(TMapOptions::EMapWithCarRouting), ());
TEST_EQUAL("/test-dir", localFile.GetDirectory(), ());
TEST_EQUAL(0, localFile.GetSize(TMapOptions::ENothing), ());
TEST_EQUAL(0, localFile.GetSize(TMapOptions::EMapOnly), ());
TEST_EQUAL(0, localFile.GetSize(TMapOptions::EMap), ());
TEST_EQUAL(0, localFile.GetSize(TMapOptions::ECarRouting), ());
TEST_EQUAL(0, localFile.GetSize(TMapOptions::EMapWithCarRouting), ());
@ -109,31 +160,31 @@ UNIT_TEST(LocalCountryFile_DiskFiles)
CountryFile countryFile("TestCountry");
countryFile.SetRemoteSizes(1 /* mapSize */, 2 /* routingSize */);
string const testMapFile = my::JoinFoldersToPath(
platform.WritableDir(), countryFile.GetNameWithExt(TMapOptions::EMapOnly));
string const testMapFile =
my::JoinFoldersToPath(platform.WritableDir(), countryFile.GetNameWithExt(TMapOptions::EMap));
string const testRoutingFile = my::JoinFoldersToPath(
platform.WritableDir(), countryFile.GetNameWithExt(TMapOptions::ECarRouting));
LocalCountryFile localFile(platform.WritableDir(), countryFile, 0 /* version */);
TEST(!localFile.OnDisk(TMapOptions::EMapOnly), ());
TEST(!localFile.OnDisk(TMapOptions::EMap), ());
TEST(!localFile.OnDisk(TMapOptions::ECarRouting), ());
TEST(!localFile.OnDisk(TMapOptions::EMapWithCarRouting), ());
CreateTestFile(testMapFile, "map");
localFile.SyncWithDisk();
TEST(localFile.OnDisk(TMapOptions::EMapOnly), ());
TEST(localFile.OnDisk(TMapOptions::EMap), ());
TEST(!localFile.OnDisk(TMapOptions::ECarRouting), ());
TEST(!localFile.OnDisk(TMapOptions::EMapWithCarRouting), ());
TEST_EQUAL(3, localFile.GetSize(TMapOptions::EMapOnly), ());
TEST_EQUAL(3, localFile.GetSize(TMapOptions::EMap), ());
CreateTestFile(testRoutingFile, "routing");
localFile.SyncWithDisk();
TEST(localFile.OnDisk(TMapOptions::EMapOnly), ());
TEST(localFile.OnDisk(TMapOptions::EMap), ());
TEST(localFile.OnDisk(TMapOptions::ECarRouting), ());
TEST(localFile.OnDisk(TMapOptions::EMapWithCarRouting), ());
TEST_EQUAL(3, localFile.GetSize(TMapOptions::EMapOnly), ());
TEST_EQUAL(3, localFile.GetSize(TMapOptions::EMap), ());
TEST_EQUAL(7, localFile.GetSize(TMapOptions::ECarRouting), ());
TEST_EQUAL(10, localFile.GetSize(TMapOptions::EMapWithCarRouting), ());
@ -144,6 +195,52 @@ UNIT_TEST(LocalCountryFile_DiskFiles)
("Routing file", testRoutingFile, "wasn't deleted by LocalCountryFile."));
}
UNIT_TEST(LocalCountryFile_DirectoryCleanup)
{
Platform & platform = GetPlatform();
string const mapsDir = platform.WritableDir();
CountryFile japanFile("Japan");
CountryFile brazilFile("Brazil");
CountryFile irelandFile("Ireland");
ScopedTestDir testDir1(my::JoinFoldersToPath(mapsDir, "1"));
LocalCountryFile japanLocalFile(testDir1.GetPath(), japanFile, 1 /* version */);
CreateTestFile(japanLocalFile.GetPath(TMapOptions::EMap), "Japan");
ScopedTestDir testDir2(my::JoinFoldersToPath(mapsDir, "2"));
LocalCountryFile brazilLocalFile(testDir2.GetPath(), brazilFile, 2 /* version */);
CreateTestFile(brazilLocalFile.GetPath(TMapOptions::EMap), "Brazil");
ScopedTestDir testDir3(my::JoinFoldersToPath(mapsDir, "3"));
LocalCountryFile irelandLocalFile(testDir2.GetPath(), irelandFile, 2 /* version */);
CreateTestFile(irelandLocalFile.GetPath(TMapOptions::EMap), "Ireland");
vector<LocalCountryFile> localFiles;
FindAllLocalMaps(localFiles);
TEST(Contains(localFiles, japanLocalFile), (japanLocalFile));
TEST(Contains(localFiles, brazilLocalFile), (brazilLocalFile));
TEST(Contains(localFiles, irelandLocalFile), (irelandLocalFile));
CleanupMapsDirectory();
japanLocalFile.SyncWithDisk();
TEST_EQUAL(TMapOptions::ENothing, japanLocalFile.GetFiles(), ());
TEST(!Platform::IsFileExistsByFullPath(testDir1.GetPath()), ("Empty directory wasn't removed."));
testDir1.Reset();
brazilLocalFile.SyncWithDisk();
TEST_EQUAL(TMapOptions::ENothing, brazilLocalFile.GetFiles(), ());
irelandLocalFile.SyncWithDisk();
TEST_EQUAL(TMapOptions::EMap, irelandLocalFile.GetFiles(), ());
irelandLocalFile.DeleteFromDisk();
TEST(!Platform::IsFileExistsByFullPath(testDir3.GetPath()), ("Empty directory wasn't removed."));
testDir3.Reset();
}
// Creates test-dir and following files:
// * test-dir/Ireland.mwm
// * test-dir/Netherlands.mwm
@ -158,41 +255,39 @@ UNIT_TEST(LocalCountryFile_DirectoryLookup)
Platform & platform = GetPlatform();
string const testDir = my::JoinFoldersToPath(platform.WritableDir(), "test-dir");
CreateTestDir(testDir);
MY_SCOPE_GUARD(removeTestDir, bind(&Platform::RmDir, testDir));
ScopedTestDir testDir(my::JoinFoldersToPath(platform.WritableDir(), "test-dir"));
string const testIrelandMapFile =
my::JoinFoldersToPath(testDir, irelandFile.GetNameWithExt(TMapOptions::EMapOnly));
my::JoinFoldersToPath(testDir.GetPath(), irelandFile.GetNameWithExt(TMapOptions::EMap));
CreateTestFile(testIrelandMapFile, "Ireland-map");
MY_SCOPE_GUARD(removeTestIrelandMapFile, bind(&FileWriter::DeleteFileX, testIrelandMapFile));
string const testNetherlandsMapFile =
my::JoinFoldersToPath(testDir, netherlandsFile.GetNameWithExt(TMapOptions::EMapOnly));
my::JoinFoldersToPath(testDir.GetPath(), netherlandsFile.GetNameWithExt(TMapOptions::EMap));
CreateTestFile(testNetherlandsMapFile, "Netherlands-map");
MY_SCOPE_GUARD(removeTestNetherlandsMapFile,
bind(&FileWriter::DeleteFileX, testNetherlandsMapFile));
string const testNetherlandsRoutingFile =
my::JoinFoldersToPath(testDir, netherlandsFile.GetNameWithExt(TMapOptions::ECarRouting));
string const testNetherlandsRoutingFile = my::JoinFoldersToPath(
testDir.GetPath(), netherlandsFile.GetNameWithExt(TMapOptions::ECarRouting));
CreateTestFile(testNetherlandsRoutingFile, "Netherlands-routing");
MY_SCOPE_GUARD(removeTestNetherlandsRoutingFile,
bind(&FileWriter::DeleteFileX, testNetherlandsRoutingFile));
vector<LocalCountryFile> localFiles;
FindAllLocalMapsInDirectory(testDir, 150309, localFiles);
FindAllLocalMapsInDirectory(testDir.GetPath(), 150309, localFiles);
sort(localFiles.begin(), localFiles.end());
for (LocalCountryFile & localFile : localFiles)
localFile.SyncWithDisk();
LocalCountryFile expectedIrelandFile(testDir, irelandFile, 150309);
expectedIrelandFile.m_files = TMapOptions::EMapOnly;
LocalCountryFile expectedIrelandFile(testDir.GetPath(), irelandFile, 150309);
expectedIrelandFile.m_files = TMapOptions::EMap;
LocalCountryFile expectedNetherlandsFile(testDir, netherlandsFile, 150309);
LocalCountryFile expectedNetherlandsFile(testDir.GetPath(), netherlandsFile, 150309);
expectedNetherlandsFile.m_files = TMapOptions::EMapWithCarRouting;
vector<LocalCountryFile> expectedLocalFiles = {expectedIrelandFile, expectedNetherlandsFile};
sort(expectedLocalFiles.begin(), expectedLocalFiles.end());
TEST_EQUAL(expectedLocalFiles, localFiles, ());
}
@ -206,18 +301,15 @@ UNIT_TEST(LocalCountryFile_AllLocalFilesLookup)
Platform & platform = GetPlatform();
string const testDir = my::JoinFoldersToPath(platform.WritableDir(), "010101");
CreateTestDir(testDir);
MY_SCOPE_GUARD(removeTestDir, bind(&Platform::RmDir, testDir));
ScopedTestDir testDir(my::JoinFoldersToPath(platform.WritableDir(), "010101"));
string const testItalyMapFile =
my::JoinFoldersToPath(testDir, italyFile.GetNameWithExt(TMapOptions::EMapOnly));
my::JoinFoldersToPath(testDir.GetPath(), italyFile.GetNameWithExt(TMapOptions::EMap));
CreateTestFile(testItalyMapFile, "Italy-map");
MY_SCOPE_GUARD(remoteTestItalyMapFile, bind(&FileWriter::DeleteFileX, testItalyMapFile));
vector<LocalCountryFile> localFiles;
FindAllLocalMaps(localFiles);
LOG(LINFO, (localFiles));
multiset<LocalCountryFile> localFilesSet(localFiles.begin(), localFiles.end());
LocalCountryFile expectedWorldFile(platform.WritableDir(), CountryFile(WORLD_FILE_NAME),
@ -228,6 +320,35 @@ UNIT_TEST(LocalCountryFile_AllLocalFilesLookup)
CountryFile(WORLD_COASTS_FILE_NAME), 0 /* version */);
TEST_EQUAL(1, localFilesSet.count(expectedWorldCoastsFile), ());
LocalCountryFile expectedItalyFile(testDir, italyFile, 10101);
LocalCountryFile expectedItalyFile(testDir.GetPath(), italyFile, 10101);
TEST_EQUAL(1, localFilesSet.count(expectedItalyFile), ());
}
UNIT_TEST(LocalCountryFile_PreparePlaceForCountryFiles)
{
Platform & platform = GetPlatform();
CountryFile italyFile("Italy");
LocalCountryFile expectedItalyFile(platform.WritableDir(), italyFile, 0 /* version */);
shared_ptr<LocalCountryFile> italyLocalFile =
PreparePlaceForCountryFiles(italyFile, 0 /* version */);
TEST(italyLocalFile.get(), ());
TEST_EQUAL(expectedItalyFile, *italyLocalFile, ());
ScopedTestDir directoryForV1(my::JoinFoldersToPath(platform.WritableDir(), "1"));
CountryFile germanyFile("Germany");
LocalCountryFile expectedGermanyFile(directoryForV1.GetPath(), germanyFile, 1 /* version */);
shared_ptr<LocalCountryFile> germanyLocalFile =
PreparePlaceForCountryFiles(germanyFile, 1 /* version */);
TEST(germanyLocalFile.get(), ());
TEST_EQUAL(expectedGermanyFile, *germanyLocalFile, ());
CountryFile franceFile("France");
LocalCountryFile expectedFranceFile(directoryForV1.GetPath(), franceFile, 1 /* version */);
shared_ptr<LocalCountryFile> franceLocalFile =
PreparePlaceForCountryFiles(franceFile, 1 /* version */);
TEST(franceLocalFile.get(), ());
TEST_EQUAL(expectedFranceFile, *franceLocalFile, ());
}
} // namespace platform

2
qt/draw_widget.cpp
View file

@ -99,7 +99,7 @@ namespace qt
if (opt == -1)
layout.RetryDownloading(idx);
else
layout.DownloadMap(idx, static_cast<storage::TMapOptions>(opt));
layout.DownloadMap(idx, static_cast<TMapOptions>(opt));
});
m_framework->SetRouteBuildingListener([] (routing::IRouter::ResultCode, vector<storage::TIndex> const &)

12
qt/update_dialog.cpp
View file

@ -150,10 +150,10 @@ namespace qt
QAbstractButton * res = ask.clickedButton();
if (res == btns[0])
m_framework.DownloadCountry(countryIndex, storage::TMapOptions::EMapWithCarRouting);
m_framework.DownloadCountry(countryIndex, TMapOptions::EMapWithCarRouting);
if (res == btns[1])
m_framework.DeleteCountry(countryIndex, storage::TMapOptions::EMapWithCarRouting);
m_framework.DeleteCountry(countryIndex, TMapOptions::EMapWithCarRouting);
}
break;
@ -167,18 +167,18 @@ namespace qt
ask.setDefaultButton(QMessageBox::No);
if (ask.exec() == QMessageBox::Yes)
m_framework.DeleteCountry(countryIndex, storage::TMapOptions::EMapWithCarRouting);
m_framework.DeleteCountry(countryIndex, TMapOptions::EMapWithCarRouting);
}
break;
case TStatus::ENotDownloaded:
case TStatus::EDownloadFailed:
m_framework.DownloadCountry(countryIndex, storage::TMapOptions::EMapWithCarRouting);
m_framework.DownloadCountry(countryIndex, TMapOptions::EMapWithCarRouting);
break;
case TStatus::EInQueue:
case TStatus::EDownloading:
m_framework.DeleteCountry(countryIndex, storage::TMapOptions::EMapWithCarRouting);
m_framework.DeleteCountry(countryIndex, TMapOptions::EMapWithCarRouting);
break;
default:
@ -247,7 +247,7 @@ namespace qt
QString statusString;
LocalAndRemoteSizeT size(0, 0);
storage::TMapOptions const options = storage::TMapOptions::EMapWithCarRouting;
TMapOptions const options = TMapOptions::EMapWithCarRouting;
Storage const & st = GetStorage();
switch (m_framework.GetCountryStatus(index))

14
storage/country.cpp
View file

@ -41,13 +41,15 @@ uint32_t CountryFile::GetRemoteSize(TMapOptions opt) const
{
switch (opt)
{
case TMapOptions::EMap: return m_mapSize;
case TMapOptions::ECarRouting: return m_routingSize;
case TMapOptions::EMapWithCarRouting : return m_mapSize + m_routingSize;
case TMapOptions::ENothing:
return 0;
case TMapOptions::EMap:
return m_mapSize;
case TMapOptions::ECarRouting:
return m_routingSize;
case TMapOptions::EMapWithCarRouting:
return m_mapSize + m_routingSize;
}
ASSERT(false, ());
return 0;
}
/*

2
storage/country.hpp
View file

@ -4,6 +4,8 @@
#include "storage/simple_tree.hpp"
#include "storage/country_decl.hpp"
#include "platform/country_defines.hpp"
#include "defines.hpp"
#include "geometry/rect2d.hpp"

21
storage/storage.cpp
View file

@ -62,8 +62,8 @@ namespace storage
// Don't queue files with 0-size on server (empty or absent).
// Downloader has lots of assertions about it. If car routing was
// requested for downloading, try to download it first.
if ((m_init & TMapOptions::ECarRouting) &&
(m_pFile->GetRemoteSize(TMapOptions::ECarRouting) > 0))
if (HasOptions(m_init, TMapOptions::ECarRouting) &&
m_pFile->GetRemoteSize(TMapOptions::ECarRouting) > 0)
{
m_current = TMapOptions::ECarRouting;
}
@ -78,10 +78,10 @@ namespace storage
TMapOptions const arr[] = { TMapOptions::EMap, TMapOptions::ECarRouting };
for (size_t i = 0; i < ARRAY_SIZE(arr); ++i)
{
if (opt & arr[i] && !(m_init & arr[i]))
if (HasOptions(opt, arr[i]) && !HasOptions(m_init, arr[i]))
{
m_init |= arr[i];
m_left |= arr[i];
m_init = SetOptions(m_init, arr[i]);
m_left = SetOptions(m_left, arr[i]);
}
}
}
@ -114,9 +114,9 @@ namespace storage
ASSERT(m_pFile->GetFileSize(TMapOptions::ECarRouting) == 0, ());
#endif
if (m_init & TMapOptions::ECarRouting)
if (HasOptions(m_init, TMapOptions::ECarRouting))
{
ASSERT(m_init & TMapOptions::EMap, ());
ASSERT(HasOptions(m_init, TMapOptions::EMap), ());
if (currentStatus == TStatus::EOnDisk)
{
@ -141,7 +141,7 @@ namespace storage
TMapOptions const arr[] = { TMapOptions::EMap, TMapOptions::ECarRouting };
for (size_t i = 0; i < ARRAY_SIZE(arr); ++i)
{
if (m_init & arr[i])
if (HasOptions(m_init, arr[i]))
{
res.first += m_pFile->GetFileSize(arr[i]);
res.second += m_pFile->GetRemoteSize(arr[i]);
@ -157,7 +157,7 @@ namespace storage
TMapOptions const arr[] = { TMapOptions::EMap, TMapOptions::ECarRouting };
for (size_t i = 0; i < ARRAY_SIZE(arr); ++i)
{
if (m_init & arr[i])
if (HasOptions(m_init, arr[i]))
res += m_pFile->GetRemoteSize(arr[i]);
}
@ -311,7 +311,7 @@ namespace storage
string const fName = QueuedCountry(*this, index, TMapOptions::ECarRouting).GetFileName();
Platform const & pl = GetPlatform();
if (pl.IsFileExistsByFullPath(pl.WritablePathForFile(fName)))
options |= TMapOptions::ECarRouting;
options = SetOptions(options, TMapOptions::ECarRouting);
}
}
@ -474,6 +474,7 @@ namespace storage
string optionName;
switch (cnt.GetInitOptions())
{
case TMapOptions::ENothing: optionName = "Nothing"; break;
case TMapOptions::EMap: optionName = "Map"; break;
case TMapOptions::ECarRouting: optionName = "CarRouting"; break;
case TMapOptions::EMapWithCarRouting: optionName = "MapWithCarRouting"; break;

10
storage/storage_defines.hpp
View file

@ -1,7 +1,5 @@
#pragma once
#include "3party/enum_flags.hpp"
#include "std/stdint.hpp"
#include "std/string.hpp"
#include "std/utility.hpp"
@ -23,13 +21,5 @@ namespace storage
string DebugPrint(TStatus status);
ENUM_FLAGS(TMapOptions)
enum class TMapOptions
{
EMap = 0x1,
ECarRouting = 0x2,
EMapWithCarRouting = 0x3
};
typedef pair<uint64_t, uint64_t> LocalAndRemoteSizeT;
}

4
storage/storage_tests/storage_tests.cpp
View file

@ -190,9 +190,9 @@ void OnCountryDownloaded(string const & mapFileName, TMapOptions files)
string const localMapFile = my::JoinFoldersToPath(platform.WritableDir(), mapFileName);
string const localRoutingFile = localMapFile + ROUTING_FILE_EXTENSION;
if (files & TMapOptions::EMap)
if (HasOptions(files, TMapOptions::EMap))
CHECK(my::RenameFileX(localMapFile + READY_FILE_EXTENSION, localMapFile), ());
if (files & TMapOptions::ECarRouting)
if (HasOptions(files, TMapOptions::ECarRouting))
CHECK(my::RenameFileX(localRoutingFile + READY_FILE_EXTENSION, localRoutingFile), ());
}