YZBruh/pmt-renovated
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases 2 Wiki Activity

pmt: reformat code, etc.

Browse Source
This commit is contained in:
Yağız Zengin
2025-11-24 18:50:57 +03:00
parent 579b2623a4
commit 11d75e401e
30 changed files with 755 additions and 647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

347
srclib/libhelper/include/libhelper/lib.hpp
View File

@@ -17,8 +17,9 @@
#ifndef LIBHELPER_LIB_HPP
#define LIBHELPER_LIB_HPP
#include <cstdint>
#include <dirent.h>
#include <cstdint>
#include <exception>
#include <functional>
#include <optional>
@@ -29,13 +30,13 @@
#include <string_view>
#include <vector>
#define KB(x) (static_cast<uint64_t>(x) * 1024) // KB(8) = 8192 (8 * 1024)
#define MB(x) (KB(x) * 1024) // MB(4) = 4194304 (KB(4) * 1024)
#define GB(x) (MB(x) * 1024) // GB(1) = 1073741824 (MB(1) * 1024)
#define KB(x) (static_cast<uint64_t>(x) * 1024) // KB(8) = 8192 (8 * 1024)
#define MB(x) (KB(x) * 1024) // MB(4) = 4194304 (KB(4) * 1024)
#define GB(x) (MB(x) * 1024) // GB(1) = 1073741824 (MB(1) * 1024)
#define TO_KB(x) (x / 1024) // TO_KB(1024) = 1
#define TO_MB(x) (TO_KB(x) / 1024) // TO_MB(2048) (2048 / 1024)
#define TO_GB(x) (TO_MB(x) / 1024) // TO_GB(1048576) (TO_MB(1048576) / 1024)
#define TO_KB(x) (x / 1024) // TO_KB(1024) = 1
#define TO_MB(x) (TO_KB(x) / 1024) // TO_MB(2048) (2048 / 1024)
#define TO_GB(x) (TO_MB(x) / 1024) // TO_GB(1048576) (TO_MB(1048576) / 1024)
#ifndef ONLY_HELPER_MACROS
@@ -62,57 +63,59 @@ constexpr int NO = 0;
namespace Helper {
// Throwable error class
class Error final : public std::exception {
private:
private:
std::string _message;
std::ostringstream _oss;
public:
__attribute__((format(printf, 2, 3))) explicit Error(const char *format, ...);
public:
__attribute__((format(printf, 2, 3))) explicit Error(const char* format, ...);
[[nodiscard]] const char *what() const noexcept override;
[[nodiscard]] const char* what() const noexcept override;
};
// Logging
class Logger final {
private:
private:
LogLevels _level;
std::ostringstream _oss;
const char *_function_name, *_logFile, *_program_name, *_file;
int _line;
public:
Logger(LogLevels level, const char *func, const char *file, const char *name,
const char *source_file, int line);
public:
Logger(LogLevels level, const char* func, const char* file, const char* name,
const char* source_file, int line);
~Logger();
template <typename T> Logger &operator<<(const T &msg) {
template <typename T>
Logger& operator<<(const T& msg) {
_oss << msg;
return *this;
}
Logger &operator<<(std::ostream &(*msg)(std::ostream &));
Logger& operator<<(std::ostream& (*msg)(std::ostream&));
};
// Close file descriptors and delete allocated array memory
class garbageCollector {
private:
private:
std::vector<std::function<void()>> _cleaners;
std::vector<FILE *> _fps;
std::vector<DIR *> _dps;
std::vector<FILE*> _fps;
std::vector<DIR*> _dps;
std::vector<int> _fds;
std::vector<std::string> _files;
public:
public:
~garbageCollector();
template <typename T> void delAfterProgress(T *_ptr) {
template <typename T>
void delAfterProgress(T* _ptr) {
_cleaners.push_back([_ptr] { delete[] _ptr; });
}
void delFileAfterProgress(const std::string &_path);
void closeAfterProgress(FILE *_fp);
void closeAfterProgress(DIR *_dp);
void delFileAfterProgress(const std::string& _path);
void closeAfterProgress(FILE* _fp);
void closeAfterProgress(DIR* _dp);
void closeAfterProgress(int _fd);
};
@@ -122,7 +125,7 @@ class Random {
static_assert(count > 1, "count is larger than 1");
static_assert(count <= max - start, "count is greater than max-start");
public:
public:
static std::set<int> get() {
std::set<int> set;
std::random_device rd;
@@ -130,12 +133,10 @@ public:
if constexpr (d > 0) {
std::uniform_int_distribution<> dist(0, (max - start - 1) / d);
while (set.size() < count)
set.insert(start + dist(gen) * d);
while (set.size() < count) set.insert(start + dist(gen) * d);
} else {
std::uniform_int_distribution<> dist(start, max - 1);
while (set.size() < count)
set.insert(dist(gen));
while (set.size() < count) set.insert(dist(gen));
}
return set;
@@ -150,7 +151,7 @@ public:
std::uniform_int_distribution<> dist(0, (max - start - 1) / d);
ret = start + dist(gen) * d;
} else {
std::uniform_int_distribution<> dist(start, max - 1); // max exclusive
std::uniform_int_distribution<> dist(start, max - 1); // max exclusive
ret = dist(gen);
}
@@ -158,39 +159,39 @@ public:
}
};
template <typename _Type1, typename _Type2, typename _Type3> class PureTuple {
private:
template <typename _Type1, typename _Type2, typename _Type3>
class PureTuple {
private:
void expand_if_needed() {
if (count == capacity) {
capacity *= 2;
Data *data = new Data[capacity];
Data* data = new Data[capacity];
for (size_t i = 0; i < count; i++)
data[i] = tuple_data[i];
for (size_t i = 0; i < count; i++) data[i] = tuple_data[i];
delete[] tuple_data;
tuple_data = data;
}
}
public:
public:
struct Data {
_Type1 first;
_Type2 second;
_Type3 third;
bool
operator==(const std::tuple<_Type1, _Type2, _Type3> &t) const noexcept {
bool operator==(
const std::tuple<_Type1, _Type2, _Type3>& t) const noexcept {
return first == std::get<0>(t) && second == std::get<1>(t) &&
third == std::get<2>(t);
}
bool operator==(const Data &other) const noexcept {
bool operator==(const Data& other) const noexcept {
return first == other.first && second == other.second &&
third == other.third;
}
bool operator!=(const Data &other) const noexcept {
bool operator!=(const Data& other) const noexcept {
return !(*this == other);
}
@@ -200,13 +201,13 @@ public:
bool operator!() const noexcept { return !bool{*this}; }
void operator()(const std::tuple<_Type1, _Type2, _Type3> &t) {
void operator()(const std::tuple<_Type1, _Type2, _Type3>& t) {
first = std::get<0>(t);
second = std::get<1>(t);
third = std::get<2>(t);
}
Data &operator=(const std::tuple<_Type1, _Type2, _Type3> &t) {
Data& operator=(const std::tuple<_Type1, _Type2, _Type3>& t) {
first = std::get<0>(t);
second = std::get<1>(t);
third = std::get<2>(t);
@@ -214,7 +215,7 @@ public:
}
};
Data *tuple_data = nullptr;
Data* tuple_data = nullptr;
Data tuple_data_type = {_Type1{}, _Type2{}, _Type3{}};
size_t capacity{}, count{};
@@ -223,38 +224,39 @@ public:
PureTuple(std::initializer_list<Data> val)
: tuple_data(new Data[20]), capacity(20), count(0) {
for (const auto &v : val)
insert(v);
for (const auto& v : val) insert(v);
}
PureTuple(PureTuple &other)
: tuple_data(new Data[other.capacity]), capacity(other.capacity),
PureTuple(PureTuple& other)
: tuple_data(new Data[other.capacity]),
capacity(other.capacity),
count(other.count) {
std::copy(other.tuple_data, other.tuple_data + count, tuple_data);
}
PureTuple(PureTuple &&other) noexcept
: tuple_data(new Data[other.capacity]), capacity(other.capacity),
PureTuple(PureTuple&& other) noexcept
: tuple_data(new Data[other.capacity]),
capacity(other.capacity),
count(other.count) {
std::copy(other.tuple_data, other.tuple_data + count, tuple_data);
other.clear();
}
class iterator {
private:
Data *it;
private:
Data* it;
public:
public:
using iterator_category = std::random_access_iterator_tag;
using value_type = Data;
using difference_type = std::ptrdiff_t;
using pointer = Data *;
using reference = Data &;
using pointer = Data*;
using reference = Data&;
explicit iterator(Data *ptr) : it(ptr) {}
explicit iterator(Data* ptr) : it(ptr) {}
pointer operator->() const { return it; }
reference operator*() { return *it; }
iterator &operator++() {
iterator& operator++() {
++it;
return *this;
}
@@ -263,7 +265,7 @@ public:
++(*this);
return tmp;
}
iterator &operator--() {
iterator& operator--() {
--it;
return *this;
}
@@ -273,32 +275,32 @@ public:
return tmp;
}
iterator &operator+=(difference_type n) {
iterator& operator+=(difference_type n) {
it += n;
return *this;
}
iterator operator+(difference_type n) const { return iterator(it + n); }
iterator &operator-=(difference_type n) {
iterator& operator-=(difference_type n) {
it -= n;
return *this;
}
iterator operator-(difference_type n) const { return iterator(it - n); }
difference_type operator-(const iterator &other) const {
difference_type operator-(const iterator& other) const {
return it - other.it;
}
reference operator[](difference_type n) const { return it[n]; }
bool operator<(const iterator &other) const { return it < other.it; }
bool operator>(const iterator &other) const { return it > other.it; }
bool operator<=(const iterator &other) const { return it <= other.it; }
bool operator>=(const iterator &other) const { return it >= other.it; }
bool operator<(const iterator& other) const { return it < other.it; }
bool operator>(const iterator& other) const { return it > other.it; }
bool operator<=(const iterator& other) const { return it <= other.it; }
bool operator>=(const iterator& other) const { return it >= other.it; }
bool operator!=(const iterator &other) const { return it != other.it; }
bool operator==(const iterator &other) const { return it == other.it; }
bool operator!=(const iterator& other) const { return it != other.it; }
bool operator==(const iterator& other) const { return it == other.it; }
};
bool find(const Data &data) const noexcept {
bool find(const Data& data) const noexcept {
for (size_t i = 0; i < count; i++)
if (data == tuple_data[i]) return true;
@@ -307,51 +309,50 @@ public:
template <typename T = std::tuple<_Type1, _Type2, _Type3>>
std::enable_if_t<std::is_same_v<T, std::tuple<_Type1, _Type2, _Type3>>, bool>
find(const std::tuple<_Type1, _Type2, _Type3> &t) const noexcept {
find(const std::tuple<_Type1, _Type2, _Type3>& t) const noexcept {
for (size_t i = 0; i < count; i++)
if (tuple_data[i] == t) return true;
return false;
}
bool find(const _Type1 &val, const _Type2 &val2,
const _Type3 &val3) const noexcept {
bool find(const _Type1& val, const _Type2& val2,
const _Type3& val3) const noexcept {
for (size_t i = 0; i < count; i++)
if (tuple_data[i] == std::make_tuple(val, val2, val3)) return true;
return false;
}
void insert(const Data &val) noexcept {
void insert(const Data& val) noexcept {
expand_if_needed();
if (!find(val)) tuple_data[count++] = val;
}
template <typename T = std::tuple<_Type1, _Type2, _Type3>>
std::enable_if_t<std::is_same_v<T, std::tuple<_Type1, _Type2, _Type3>>, void>
insert(const std::tuple<_Type1, _Type2, _Type3> &t) noexcept {
insert(const std::tuple<_Type1, _Type2, _Type3>& t) noexcept {
expand_if_needed();
if (!find(t))
tuple_data[count++] =
Data{std::get<0>(t), std::get<1>(t), std::get<2>(t)};
}
void insert(const _Type1 &val, const _Type2 &val2,
const _Type3 &val3) noexcept {
void insert(const _Type1& val, const _Type2& val2,
const _Type3& val3) noexcept {
expand_if_needed();
if (!find(val, val2, val3)) tuple_data[count++] = Data{val, val2, val3};
}
void merge(const PureTuple &other) noexcept {
for (const auto &v : other)
insert(v);
void merge(const PureTuple& other) noexcept {
for (const auto& v : other) insert(v);
}
void pop_back() noexcept {
if (count > 0) --count;
}
void pop(const Data &data) noexcept {
void pop(const Data& data) noexcept {
for (size_t i = 0; i < count; i++) {
if (tuple_data[i] == data) {
for (size_t j = i; j < count - 1; j++)
@@ -374,7 +375,7 @@ public:
}
}
void pop(const _Type1 &val, const _Type2 &val2, const _Type3 &val3) noexcept {
void pop(const _Type1& val, const _Type2& val2, const _Type3& val3) noexcept {
for (size_t i = 0; i < count; i++) {
if (tuple_data[i] == std::make_tuple(val, val2, val3)) {
for (size_t j = i; j < count - 1; j++)
@@ -387,7 +388,7 @@ public:
template <typename T = std::tuple<_Type1, _Type2, _Type3>>
std::enable_if_t<std::is_same_v<T, std::tuple<_Type1, _Type2, _Type3>>, void>
pop(const std::tuple<_Type1, _Type2, _Type3> &t) noexcept {
pop(const std::tuple<_Type1, _Type2, _Type3>& t) noexcept {
for (size_t i = 0; i < count; i++) {
if (tuple_data[i] == t) {
for (size_t j = i; j < count - 1; j++)
@@ -435,7 +436,7 @@ public:
explicit operator bool() const noexcept { return count > 0; }
bool operator!() const noexcept { return count == 0; }
bool operator==(const PureTuple &other) const noexcept {
bool operator==(const PureTuple& other) const noexcept {
if (this->count != other.count || this->capacity != other.capacity)
return false;
@@ -444,7 +445,7 @@ public:
return true;
}
bool operator!=(const PureTuple &other) const noexcept {
bool operator!=(const PureTuple& other) const noexcept {
return !(*this == other);
}
@@ -454,7 +455,7 @@ public:
}
explicit operator int() const noexcept { return count; }
PureTuple &operator=(const PureTuple &other) {
PureTuple& operator=(const PureTuple& other) {
if (this != &other) {
delete[] tuple_data;
@@ -468,70 +469,71 @@ public:
return *this;
}
PureTuple &operator<<(const std::tuple<_Type1, _Type2, _Type3> &t) noexcept {
PureTuple& operator<<(const std::tuple<_Type1, _Type2, _Type3>& t) noexcept {
insert(t);
return *this;
}
friend PureTuple &operator>>(const std::tuple<_Type1, _Type2, _Type3> &t,
PureTuple &tuple) noexcept {
friend PureTuple& operator>>(const std::tuple<_Type1, _Type2, _Type3>& t,
PureTuple& tuple) noexcept {
tuple.insert(t);
return tuple;
}
};
// Provides a capsule structure to store variable references and values.
template <typename _Type> class Capsule : public garbageCollector {
public:
_Type &value;
template <typename _Type>
class Capsule : public garbageCollector {
public:
_Type& value;
// The value to be stored is taken as a reference as an argument
explicit Capsule(_Type &value) noexcept : value(value) {}
explicit Capsule(_Type& value) noexcept : value(value) {}
// Set the value.
void set(const _Type &_value) noexcept { this->value = _value; }
void set(_Type &_value) noexcept { this->value = _value; }
void set(const _Type& _value) noexcept { this->value = _value; }
void set(_Type& _value) noexcept { this->value = _value; }
// Get reference of the value.
_Type &get() noexcept { return this->value; }
const _Type &get() const noexcept { return this->value; }
_Type& get() noexcept { return this->value; }
const _Type& get() const noexcept { return this->value; }
// You can get the reference of the stored value in the input type (casting is
// required).
operator _Type &() noexcept { return this->value; }
operator const _Type &() const noexcept { return this->value; }
explicit operator _Type *() noexcept { return &this->value; }
operator _Type&() noexcept { return this->value; }
operator const _Type&() const noexcept { return this->value; }
explicit operator _Type*() noexcept { return &this->value; }
// The value of another capsule is taken.
Capsule &operator=(const Capsule &other) noexcept {
Capsule& operator=(const Capsule& other) noexcept {
this->value = other.value;
return *this;
}
// Assign another value.
Capsule &operator=(const _Type &_value) noexcept {
Capsule& operator=(const _Type& _value) noexcept {
this->value = _value;
return *this;
}
// Check if this capsule and another capsule hold the same data.
bool operator==(const Capsule &other) const noexcept {
bool operator==(const Capsule& other) const noexcept {
return this->value == other.value;
}
// Check if this capsule value and another capsule value hold the same data.
bool operator==(const _Type &_value) const noexcept {
bool operator==(const _Type& _value) const noexcept {
return this->value == _value;
}
// Check that this capsule and another capsule do not hold the same data.
bool operator!=(const Capsule &other) const noexcept {
bool operator!=(const Capsule& other) const noexcept {
return !(*this == other);
}
// Check that this capsule value and another capsule value do not hold the
// same data.
bool operator!=(const _Type &_value) const noexcept {
bool operator!=(const _Type& _value) const noexcept {
return !(*this == _value);
}
@@ -542,17 +544,17 @@ public:
bool operator!() const noexcept { return this->value == _Type{}; }
// Change the value with the input operator.
friend Capsule &operator>>(const _Type &_value, Capsule &_capsule) noexcept {
friend Capsule& operator>>(const _Type& _value, Capsule& _capsule) noexcept {
_capsule.value = _value;
return _capsule;
}
// Get the reference of the value held.
_Type &operator()() noexcept { return value; }
const _Type &operator()() const noexcept { return value; }
_Type& operator()() noexcept { return value; }
const _Type& operator()() const noexcept { return value; }
// Set the value.
void operator()(const _Type &_value) noexcept { this->value = _value; }
void operator()(const _Type& _value) noexcept { this->value = _value; }
};
namespace LoggingProperties {
@@ -563,17 +565,23 @@ void set(std::string_view name, std::string_view file);
void setProgramName(std::string_view name);
void setLogFile(std::string_view file);
template <int state> void setPrinting() {
if (state == 1 || state == 0) PRINT = state;
else PRINT = NO;
template <int state>
void setPrinting() {
if (state == 1 || state == 0)
PRINT = state;
else
PRINT = NO;
}
template <int state> void setLoggingState() {
if (state == 1 || state == 0) DISABLE = state;
else DISABLE = NO;
template <int state>
void setLoggingState() {
if (state == 1 || state == 0)
DISABLE = state;
else
DISABLE = NO;
}
void reset();
} // namespace LoggingProperties
} // namespace LoggingProperties
// -------------------------------
// Checkers - not throws Helper::Error
@@ -803,13 +811,14 @@ std::string multipleToString(sizeCastTypes type);
/**
* Format it input and return as std::string.
*/
__attribute__((format(printf, 1, 2))) std::string format(const char *format,
__attribute__((format(printf, 1, 2))) std::string format(const char* format,
...);
/**
* Convert input size to input multiple
*/
template <uint64_t size> int convertTo(const sizeCastTypes type) {
template <uint64_t size>
int convertTo(const sizeCastTypes type) {
if (type == KB) return TO_KB(size);
if (type == MB) return TO_MB(size);
if (type == GB) return TO_GB(size);
@@ -840,26 +849,26 @@ std::string getLibVersion();
* Open input path with flags and add to integrity list.
* And returns file descriptor.
*/
[[nodiscard]] int openAndAddToCloseList(const std::string_view &path,
garbageCollector &collector, int flags,
[[nodiscard]] int openAndAddToCloseList(const std::string_view& path,
garbageCollector& collector, int flags,
mode_t mode = 0000);
/**
* Open input path with flags and add to integrity list.
* And returns file pointer.
*/
[[nodiscard]] FILE *openAndAddToCloseList(const std::string_view &path,
garbageCollector &collector,
const char *mode);
[[nodiscard]] FILE* openAndAddToCloseList(const std::string_view& path,
garbageCollector& collector,
const char* mode);
/**
* Open input directory and add to integrity list.
* And returns directory pointer.
*/
[[nodiscard]] DIR *openAndAddToCloseList(const std::string_view &path,
garbageCollector &collector);
[[nodiscard]] DIR* openAndAddToCloseList(const std::string_view& path,
garbageCollector& collector);
} // namespace Helper
} // namespace Helper
#endif // #ifndef ONLY_HELPER_MACROS
#endif // #ifndef ONLY_HELPER_MACROS
#define HELPER "libhelper"
@@ -879,73 +888,73 @@ std::string getLibVersion();
#ifndef NO_C_TYPE_HANDLERS
// ABORT(message), ex: ABORT("memory error!\n")
#define ABORT(msg) \
do { \
fprintf(stderr, "%s%sCRITICAL ERROR%s: %s\nAborting...\n", BOLD, RED, \
STYLE_RESET, msg); \
abort(); \
#define ABORT(msg) \
do { \
fprintf(stderr, "%s%sCRITICAL ERROR%s: %s\nAborting...\n", BOLD, RED, \
STYLE_RESET, msg); \
abort(); \
} while (0)
// ERROR(message, exit), ex: ERROR("an error occured.\n", 1)
#define ERROR(msg, code) \
do { \
fprintf(stderr, "%s%sERROR%s: %s", BOLD, RED, STYLE_RESET, msg); \
exit(code); \
#define ERROR(msg, code) \
do { \
fprintf(stderr, "%s%sERROR%s: %s", BOLD, RED, STYLE_RESET, msg); \
exit(code); \
} while (0)
// WARNING(message), ex: WARNING("using default setting.\n")
#define WARNING(msg) \
#define WARNING(msg) \
fprintf(stderr, "%s%sWARNING%s: %s", BOLD, YELLOW, STYLE_RESET, msg);
// INFO(message), ex: INFO("operation ended.\n")
#define INFO(msg) \
#define INFO(msg) \
fprintf(stdout, "%s%sINFO%s: %s", BOLD, GREEN, STYLE_RESET, msg);
#endif // #ifndef NO_C_TYPE_HANDLERS
#endif // #ifndef NO_C_TYPE_HANDLERS
#define LOG(level) \
Helper::Logger(level, __func__, Helper::LoggingProperties::FILE.data(), \
#define LOG(level) \
Helper::Logger(level, __func__, Helper::LoggingProperties::FILE.data(), \
Helper::LoggingProperties::NAME.data(), __FILE__, __LINE__)
#define LOGF(file, level) \
Helper::Logger(level, __func__, file, \
#define LOGF(file, level) \
Helper::Logger(level, __func__, file, \
Helper::LoggingProperties::NAME.data(), __FILE__, __LINE__)
#define LOGN(name, level) \
Helper::Logger(level, __func__, Helper::LoggingProperties::FILE.data(), \
#define LOGN(name, level) \
Helper::Logger(level, __func__, Helper::LoggingProperties::FILE.data(), \
name, __FILE__, __LINE__)
#define LOGNF(name, file, level) \
#define LOGNF(name, file, level) \
Helper::Logger(level, file, name, __FILE__, __LINE__)
#define LOG_IF(level, condition) \
if (condition) \
Helper::Logger(level, __func__, Helper::LoggingProperties::FILE.data(), \
#define LOG_IF(level, condition) \
if (condition) \
Helper::Logger(level, __func__, Helper::LoggingProperties::FILE.data(), \
Helper::LoggingProperties::NAME.data(), __FILE__, __LINE__)
#define LOGF_IF(file, level, condition) \
if (condition) \
Helper::Logger(level, __func__, file, \
#define LOGF_IF(file, level, condition) \
if (condition) \
Helper::Logger(level, __func__, file, \
Helper::LoggingProperties::NAME.data(), __FILE__, __LINE__)
#define LOGN_IF(name, level, condition) \
if (condition) \
Helper::Logger(level, __func__, Helper::LoggingProperties::FILE.data(), \
#define LOGN_IF(name, level, condition) \
if (condition) \
Helper::Logger(level, __func__, Helper::LoggingProperties::FILE.data(), \
name, __FILE__, __LINE__)
#define LOGNF_IF(name, file, level, condition) \
#define LOGNF_IF(name, file, level, condition) \
if (condition) Helper::Logger(level, __func__, file, name, __FILE__, __LINE__)
#ifdef ANDROID_BUILD
#define MKVERSION(name) \
char vinfo[512]; \
sprintf(vinfo, \
"%s 1.3.0\nCompiler: clang\n" \
"BuildFlags: -Wall;-Werror;-Wno-deprecated-declarations;-Os", \
name); \
#define MKVERSION(name) \
char vinfo[512]; \
sprintf(vinfo, \
"%s 1.3.0\nCompiler: clang\n" \
"BuildFlags: -Wall;-Werror;-Wno-deprecated-declarations;-Os", \
name); \
return std::string(vinfo)
#else
#define MKVERSION(name) \
char vinfo[512]; \
sprintf(vinfo, \
"%s %s [%s %s]\nBuildType: %s\nCMakeVersion: %s\nCompilerVersion: " \
"%s\nBuildFlags: %s", \
name, BUILD_VERSION, BUILD_DATE, BUILD_TIME, BUILD_TYPE, \
BUILD_CMAKE_VERSION, BUILD_COMPILER_VERSION, BUILD_FLAGS); \
#define MKVERSION(name) \
char vinfo[512]; \
sprintf(vinfo, \
"%s %s [%s %s]\nBuildType: %s\nCMakeVersion: %s\nCompilerVersion: " \
"%s\nBuildFlags: %s", \
name, BUILD_VERSION, BUILD_DATE, BUILD_TIME, BUILD_TYPE, \
BUILD_CMAKE_VERSION, BUILD_COMPILER_VERSION, BUILD_FLAGS); \
return std::string(vinfo)
#endif
#endif // #ifndef LIBHELPER_LIB_HPP
#endif // #ifndef LIBHELPER_LIB_HPP

9
srclib/libhelper/src/Checkers.cpp
View File

@@ -14,13 +14,14 @@
limitations under the License.
*/
#include <cstdio>
#include <cstdlib>
#include <libhelper/lib.hpp>
#include <private/android_filesystem_config.h>
#include <sys/stat.h>
#include <unistd.h>
#include <cstdio>
#include <cstdlib>
#include <libhelper/lib.hpp>
namespace Helper {
bool hasSuperUser() { return (getuid() == AID_ROOT); }
bool hasAdbPermissions() { return (getuid() == AID_SHELL); }
@@ -68,4 +69,4 @@ bool areLinked(const std::string_view entry1, const std::string_view entry2) {
return (st1 == st2);
}
} // namespace Helper
} // namespace Helper

54
srclib/libhelper/src/Classes.cpp
View File

@@ -14,22 +14,23 @@
limitations under the License.
*/
#include <dirent.h>
#include <fcntl.h>
#include <libgen.h>
#include <unistd.h>
#include <cerrno>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <dirent.h>
#include <exception>
#include <fcntl.h>
#include <functional>
#include <libgen.h>
#include <libhelper/lib.hpp>
#include <sstream>
#include <unistd.h>
namespace Helper {
Error::Error(const char *format, ...) {
Error::Error(const char* format, ...) {
char buf[1024];
va_list args;
va_start(args, format);
@@ -39,19 +40,23 @@ Error::Error(const char *format, ...) {
LOGN(HELPER, ERROR) << _message << std::endl;
}
const char *Error::what() const noexcept { return _message.data(); }
const char* Error::what() const noexcept { return _message.data(); }
Logger::Logger(const LogLevels level, const char *func, const char *file,
const char *name, const char *source_file, const int line)
: _level(level), _function_name(func), _logFile(file), _program_name(name),
_file(source_file), _line(line) {}
Logger::Logger(const LogLevels level, const char* func, const char* file,
const char* name, const char* source_file, const int line)
: _level(level),
_function_name(func),
_logFile(file),
_program_name(name),
_file(source_file),
_line(line) {}
Logger::~Logger() {
if (LoggingProperties::DISABLE) return;
char str[1024];
snprintf(str, sizeof(str), "<%c> [ <prog %s> <on %s:%d> %s %s] %s(): %s",
static_cast<char>(_level), _program_name,
basename(const_cast<char *>(_file)), _line, currentDate().data(),
basename(const_cast<char*>(_file)), _line, currentDate().data(),
currentTime().data(), _function_name, _oss.str().data());
if (!isExists(_logFile)) {
@@ -76,7 +81,7 @@ Logger::~Logger() {
}
}
if (FILE *fp = fopen(_logFile, "a"); fp != nullptr) {
if (FILE* fp = fopen(_logFile, "a"); fp != nullptr) {
fprintf(fp, "%s", str);
fclose(fp);
} else {
@@ -91,30 +96,25 @@ Logger::~Logger() {
if (LoggingProperties::PRINT) printf("%s", str);
}
Logger &Logger::operator<<(std::ostream &(*msg)(std::ostream &)) {
Logger& Logger::operator<<(std::ostream& (*msg)(std::ostream&)) {
_oss << msg;
return *this;
}
garbageCollector::~garbageCollector() {
for (auto &ptr_func : _cleaners)
ptr_func();
for (const auto &fd : _fds)
close(fd);
for (const auto &fp : _fps)
fclose(fp);
for (const auto &dp : _dps)
closedir(dp);
for (const auto &file : _files)
eraseEntry(file);
for (auto& ptr_func : _cleaners) ptr_func();
for (const auto& fd : _fds) close(fd);
for (const auto& fp : _fps) fclose(fp);
for (const auto& dp : _dps) closedir(dp);
for (const auto& file : _files) eraseEntry(file);
}
void garbageCollector::delFileAfterProgress(const std::string &_path) {
void garbageCollector::delFileAfterProgress(const std::string& _path) {
_files.push_back(_path);
}
void garbageCollector::closeAfterProgress(const int _fd) {
_fds.push_back(_fd);
}
void garbageCollector::closeAfterProgress(FILE *_fp) { _fps.push_back(_fp); }
void garbageCollector::closeAfterProgress(DIR *_dp) { _dps.push_back(_dp); }
} // namespace Helper
void garbageCollector::closeAfterProgress(FILE* _fp) { _fps.push_back(_fp); }
void garbageCollector::closeAfterProgress(DIR* _dp) { _dps.push_back(_dp); }
} // namespace Helper

24
srclib/libhelper/src/FileUtil.cpp
View File

@@ -14,16 +14,17 @@
limitations under the License.
*/
#include <dirent.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <dirent.h>
#include <fcntl.h>
#include <libhelper/lib.hpp>
#include <string>
#include <sys/stat.h>
#include <unistd.h>
namespace Helper {
bool writeFile(const std::string_view file, const std::string_view text) {
@@ -31,7 +32,7 @@ bool writeFile(const std::string_view file, const std::string_view text) {
<< std::endl;
garbageCollector collector;
FILE *fp = openAndAddToCloseList(file, collector, "a");
FILE* fp = openAndAddToCloseList(file, collector, "a");
if (fp == nullptr) return false;
fprintf(fp, "%s", text.data());
@@ -43,13 +44,12 @@ std::optional<std::string> readFile(const std::string_view file) {
LOGN(HELPER, INFO) << "read " << file << " requested." << std::endl;
garbageCollector collector;
FILE *fp = openAndAddToCloseList(file, collector, "r");
FILE* fp = openAndAddToCloseList(file, collector, "r");
if (fp == nullptr) return std::nullopt;
char buffer[1024];
std::string str;
while (fgets(buffer, sizeof(buffer), fp))
str += buffer;
while (fgets(buffer, sizeof(buffer), fp)) str += buffer;
LOGN(HELPER, INFO) << "read " << file << " successfully, read text: \"" << str
<< "\"" << std::endl;
@@ -95,7 +95,7 @@ bool makeRecursiveDirectory(const std::string_view paths) {
snprintf(tmp, sizeof(tmp), "%s", paths.data());
if (const size_t len = strlen(tmp); tmp[len - 1] == '/') tmp[len - 1] = '\0';
for (char *p = tmp + 1; *p; p++) {
for (char* p = tmp + 1; *p; p++) {
if (*p == '/') {
*p = '\0';
if (access(tmp, F_OK) != 0) {
@@ -150,10 +150,10 @@ bool eraseEntry(const std::string_view entry) {
bool eraseDirectoryRecursive(const std::string_view directory) {
LOGN(HELPER, INFO) << "erase recursive requested: " << directory << std::endl;
struct stat buf{};
dirent *entry;
dirent* entry;
garbageCollector collector;
DIR *dir = openAndAddToCloseList(directory.data(), collector);
DIR* dir = openAndAddToCloseList(directory.data(), collector);
if (dir == nullptr) return false;
while ((entry = readdir(dir)) != nullptr) {
@@ -202,4 +202,4 @@ int64_t fileSize(const std::string_view file) {
if (stat(file.data(), &st) != 0) return -1;
return st.st_size;
}
} // namespace Helper
} // namespace Helper

7
srclib/libhelper/src/Sha256.cpp
View File

@@ -14,13 +14,14 @@
limitations under the License.
*/
#include <picosha2.h>
#include <sys/stat.h>
#include <fstream>
#include <iostream>
#include <libhelper/lib.hpp>
#include <optional>
#include <picosha2.h>
#include <string>
#include <sys/stat.h>
#include <vector>
namespace Helper {
@@ -54,4 +55,4 @@ bool sha256Compare(const std::string_view file1, const std::string_view file2) {
<< "(): input files is contains same sha256 signature." << std::endl;
return (*f1 == *f2);
}
} // namespace Helper
} // namespace Helper

87
srclib/libhelper/src/Utilities.cpp
View File

@@ -14,52 +14,57 @@
limitations under the License.
*/
#include <cutils/android_reboot.h>
#include <fcntl.h>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cutils/android_reboot.h>
#include <fcntl.h>
#ifndef ANDROID_BUILD
#include <generated/buildInfo.hpp>
#include <sys/_system_properties.h>
#include <generated/buildInfo.hpp>
#else
#include <sys/system_properties.h>
#endif
#include <cstdarg>
#include <cutils/android_reboot.h>
#include <iostream>
#include <libgen.h>
#include <libhelper/lib.hpp>
#include <memory>
#include <string>
#include <string_view>
#include <sys/_system_properties.h>
#include <sys/stat.h>
#include <unistd.h>
#include <cstdarg>
#include <iostream>
#include <libhelper/lib.hpp>
#include <memory>
#include <string>
#include <string_view>
#ifdef __ANDROID__
// From system/core/libcutils/android_reboot.cpp android16-s2-release
int android_reboot(const unsigned cmd, int /*flags*/, const char *arg) {
int android_reboot(const unsigned cmd, int /*flags*/, const char* arg) {
int ret;
const char *restart_cmd = nullptr;
char *prop_value;
const char* restart_cmd = nullptr;
char* prop_value;
switch (cmd) {
case ANDROID_RB_RESTART: // deprecated
case ANDROID_RB_RESTART2:
restart_cmd = "reboot";
break;
case ANDROID_RB_POWEROFF:
restart_cmd = "shutdown";
break;
case ANDROID_RB_THERMOFF:
restart_cmd = "shutdown,thermal";
break;
case ANDROID_RB_RESTART: // deprecated
case ANDROID_RB_RESTART2:
restart_cmd = "reboot";
break;
case ANDROID_RB_POWEROFF:
restart_cmd = "shutdown";
break;
case ANDROID_RB_THERMOFF:
restart_cmd = "shutdown,thermal";
break;
}
if (!restart_cmd) return -1;
if (arg && arg[0]) ret = asprintf(&prop_value, "%s,%s", restart_cmd, arg);
else ret = asprintf(&prop_value, "%s", restart_cmd);
if (arg && arg[0])
ret = asprintf(&prop_value, "%s,%s", restart_cmd, arg);
else
ret = asprintf(&prop_value, "%s", restart_cmd);
if (ret < 0) return -1;
ret = __system_property_set(ANDROID_RB_PROPERTY, prop_value);
@@ -86,7 +91,7 @@ void set(std::string_view file, std::string_view name) {
void setProgramName(const std::string_view name) { NAME = name; }
void setLogFile(const std::string_view file) { FILE = file; }
} // namespace LoggingProperties
} // namespace LoggingProperties
bool runCommand(const std::string_view cmd) {
LOGN(HELPER, INFO) << "run command request: " << cmd << std::endl;
@@ -116,7 +121,7 @@ std::string currentWorkingDirectory() {
std::string currentDate() {
const time_t t = time(nullptr);
if (const tm *date = localtime(&t))
if (const tm* date = localtime(&t))
return std::string(std::to_string(date->tm_mday) + "/" +
std::to_string(date->tm_mon + 1) + "/" +
std::to_string(date->tm_year + 1900));
@@ -126,7 +131,7 @@ std::string currentDate() {
std::string currentTime() {
const time_t t = time(nullptr);
if (const tm *date = localtime(&t))
if (const tm* date = localtime(&t))
return std::string(std::to_string(date->tm_hour) + ":" +
std::to_string(date->tm_min) + ":" +
std::to_string(date->tm_sec));
@@ -137,7 +142,7 @@ std::pair<std::string, int> runCommandWithOutput(const std::string_view cmd) {
LOGN(HELPER, INFO) << "run command and catch out request: " << cmd
<< std::endl;
FILE *pipe = popen(cmd.data(), "r");
FILE* pipe = popen(cmd.data(), "r");
if (!pipe) return {};
std::unique_ptr<FILE, decltype(&pclose)> pipe_holder(pipe, pclose);
@@ -148,7 +153,7 @@ std::pair<std::string, int> runCommandWithOutput(const std::string_view cmd) {
while (fgets(buffer, sizeof(buffer), pipe_holder.get()) != nullptr)
output += buffer;
FILE *raw = pipe_holder.release();
FILE* raw = pipe_holder.release();
const int status = pclose(raw);
return {output, (WIFEXITED(status) ? WEXITSTATUS(status) : -1)};
}
@@ -161,12 +166,12 @@ std::string pathJoin(std::string base, std::string relative) {
}
std::string pathBasename(const std::string_view entry) {
char *base = basename(const_cast<char *>(entry.data()));
char* base = basename(const_cast<char*>(entry.data()));
return (base == nullptr) ? std::string() : std::string(base);
}
std::string pathDirname(const std::string_view entry) {
char *base = dirname(const_cast<char *>(entry.data()));
char* base = dirname(const_cast<char*>(entry.data()));
return (base == nullptr) ? std::string() : std::string(base);
}
@@ -183,8 +188,8 @@ bool changeOwner(const std::string_view file, const uid_t uid,
return chown(file.data(), uid, gid) == 0;
}
int openAndAddToCloseList(const std::string_view &path,
garbageCollector &collector, const int flags,
int openAndAddToCloseList(const std::string_view& path,
garbageCollector& collector, const int flags,
const mode_t mode) {
const int fd =
mode == 0 ? open(path.data(), flags) : open(path.data(), flags, mode);
@@ -192,16 +197,16 @@ int openAndAddToCloseList(const std::string_view &path,
return fd;
}
FILE *openAndAddToCloseList(const std::string_view &path,
garbageCollector &collector, const char *mode) {
FILE *fp = fopen(path.data(), mode);
FILE* openAndAddToCloseList(const std::string_view& path,
garbageCollector& collector, const char* mode) {
FILE* fp = fopen(path.data(), mode);
collector.closeAfterProgress(fp);
return fp;
}
DIR *openAndAddToCloseList(const std::string_view &path,
garbageCollector &collector) {
DIR *dp = opendir(path.data());
DIR* openAndAddToCloseList(const std::string_view& path,
garbageCollector& collector) {
DIR* dp = opendir(path.data());
collector.closeAfterProgress(dp);
return dp;
}
@@ -247,7 +252,7 @@ std::string multipleToString(const sizeCastTypes type) {
return "B";
}
std::string format(const char *format, ...) {
std::string format(const char* format, ...) {
va_list args;
va_start(args, format);
char str[1024];
@@ -257,4 +262,4 @@ std::string format(const char *format, ...) {
}
std::string getLibVersion() { MKVERSION("libhelper"); }
} // namespace Helper
} // namespace Helper

19
srclib/libhelper/tests/test.cpp
View File

@@ -19,14 +19,14 @@
#include <iostream>
#include <libhelper/lib.hpp>
char *TEST_DIR = nullptr;
char* TEST_DIR = nullptr;
std::string test_path(const char *file) {
std::string test_path(const char* file) {
std::string end = std::string(TEST_DIR) + "/" + file;
return end;
}
int main(int argc, char **argv) {
int main(int argc, char** argv) {
if (argc < 2) return 2;
TEST_DIR = argv[1];
@@ -51,11 +51,13 @@ int main(int argc, char **argv) {
if (!Helper::writeFile("file.txt", "hello world"))
throw Helper::Error("Cannot write \"hello world\" in 'file.txt'");
else std::cout << "file.txt writed." << std::endl;
else
std::cout << "file.txt writed." << std::endl;
if (const auto content = Helper::readFile("file.txt"); !content)
throw Helper::Error("Cannot read 'file.txt'");
else std::cout << "'file.txt': " << *content << std::endl;
else
std::cout << "'file.txt': " << *content << std::endl;
std::cout << "Making directory 'dir2': " << std::boolalpha
<< Helper::makeDirectory(test_path("dir2")) << std::endl;
@@ -80,7 +82,8 @@ int main(int argc, char **argv) {
if (const auto sha256 = Helper::sha256Of(test_path("file2.txt")); !sha256)
throw Helper::Error("Cannot get sha256 of 'file2.txt'");
else std::cout << "SHA256 of 'file2.txt': " << *sha256 << std::endl;
else
std::cout << "SHA256 of 'file2.txt': " << *sha256 << std::endl;
std::cout << "'file2.txt' and 'file2lnk.txt' same? (SHA256): "
<< std::boolalpha
@@ -130,7 +133,7 @@ int main(int argc, char **argv) {
std::cout << "pure tuple test: " << std::boolalpha
<< static_cast<bool>(values.at(0)) << std::endl;
for (const auto &[x, y, z] : values) {
for (const auto& [x, y, z] : values) {
std::cout << std::boolalpha << "(" << x << ", " << y << ", " << z << ")"
<< std::endl;
}
@@ -141,7 +144,7 @@ int main(int argc, char **argv) {
LOG(WARNING) << "Warning message" << std::endl;
LOG(ERROR) << "Error message" << std::endl;
LOG(ABORT) << "Abort message" << std::endl;
} catch (std::exception &err) {
} catch (std::exception& err) {
std::cout << err.what() << std::endl;
return 1;
}

133
srclib/libpartition_map/include/libpartition_map/lib.hpp
View File

@@ -17,7 +17,7 @@
#ifndef LIBPARTITION_MAP_LIB_HPP
#define LIBPARTITION_MAP_LIB_HPP
#include <cstdint> // for uint64_t
#include <cstdint> // for uint64_t
#include <exception>
#include <functional>
#include <libhelper/lib.hpp>
@@ -27,7 +27,7 @@
#include <optional>
#include <string>
#include <string_view>
#include <utility> // for std::pair
#include <utility> // for std::pair
namespace PartitionMap {
struct _entry {
@@ -52,74 +52,73 @@ using Info = _entry;
* to be easily manipulated and modified only on this class.
*/
class basic_partition_map {
private:
private:
void _resize_map();
[[nodiscard]] int _index_of(std::string_view name) const;
public:
_entry *_data;
public:
_entry* _data;
size_t _count{}, _capacity{};
basic_partition_map(const std::string &name, uint64_t size, bool logical);
basic_partition_map(const basic_partition_map &other);
basic_partition_map(basic_partition_map &&other) noexcept;
basic_partition_map(const std::string& name, uint64_t size, bool logical);
basic_partition_map(const basic_partition_map& other);
basic_partition_map(basic_partition_map&& other) noexcept;
basic_partition_map();
~basic_partition_map();
bool insert(const std::string &name, uint64_t size, bool logical);
void merge(const basic_partition_map &map);
bool insert(const std::string& name, uint64_t size, bool logical);
void merge(const basic_partition_map& map);
void clear();
[[nodiscard]] uint64_t get_size(std::string_view name) const;
[[nodiscard]] bool is_logical(std::string_view name) const;
[[nodiscard]] _returnable_entry get_all(std::string_view name) const;
[[nodiscard]] bool find(std::string_view name) const;
[[nodiscard]] std::string find_(const std::string &name) const;
[[nodiscard]] std::string find_(const std::string& name) const;
[[nodiscard]] size_t size() const;
[[nodiscard]] bool empty() const;
basic_partition_map &operator=(const basic_partition_map &map);
basic_partition_map& operator=(const basic_partition_map& map);
bool operator==(const basic_partition_map &other) const;
bool operator!=(const basic_partition_map &other) const;
bool operator==(const basic_partition_map& other) const;
bool operator!=(const basic_partition_map& other) const;
bool operator!() const;
explicit operator bool() const;
Info operator[](int index) const;
BasicInf operator[](const std::string_view &name) const;
BasicInf operator[](const std::string_view& name) const;
explicit operator std::vector<Info>() const;
explicit operator int() const;
class iterator {
public:
_entry *ptr;
public:
_entry* ptr;
explicit iterator(_entry *p);
explicit iterator(_entry* p);
auto operator*() const
-> std::pair<std::string &, decltype(_entry::props) &>;
_entry *operator->() const;
iterator &operator++();
auto operator*() const -> std::pair<std::string&, decltype(_entry::props)&>;
_entry* operator->() const;
iterator& operator++();
iterator operator++(int);
bool operator!=(const iterator &other) const;
bool operator==(const iterator &other) const;
bool operator!=(const iterator& other) const;
bool operator==(const iterator& other) const;
};
class constant_iterator {
public:
const _entry *ptr;
public:
const _entry* ptr;
explicit constant_iterator(const _entry *p);
explicit constant_iterator(const _entry* p);
auto operator*() const
-> std::pair<const std::string &, const decltype(_entry::props) &>;
const _entry *operator->() const;
constant_iterator &operator++();
-> std::pair<const std::string&, const decltype(_entry::props)&>;
const _entry* operator->() const;
constant_iterator& operator++();
constant_iterator operator++(int);
bool operator!=(const constant_iterator &other) const;
bool operator==(const constant_iterator &other) const;
bool operator!=(const constant_iterator& other) const;
bool operator==(const constant_iterator& other) const;
};
/* for-each support */
@@ -133,20 +132,20 @@ using Partition_t = _entry;
using Map_t = basic_partition_map;
class basic_partition_map_builder final {
private:
private:
Map_t _current_map;
std::string _workdir;
bool _any_generating_error, _map_builded;
Map_t _build_map(std::string_view path, bool logical = false);
void _insert_logicals(Map_t &&logicals);
void _insert_logicals(Map_t&& logicals);
void _map_build_check() const;
[[nodiscard]] static bool _is_real_block_dir(std::string_view path);
[[nodiscard]] uint64_t _get_size(const std::string &path);
[[nodiscard]] uint64_t _get_size(const std::string& path);
public:
public:
/**
* By default, it searches the directories in the
* defaultEntryList in PartitionMap.cpp in order and
@@ -162,7 +161,7 @@ public:
/**
* Move constructor
*/
basic_partition_map_builder(basic_partition_map_builder &&other) noexcept;
basic_partition_map_builder(basic_partition_map_builder&& other) noexcept;
/**
* Returns the current list content in Map_t type.
@@ -174,8 +173,8 @@ public:
* Map_temp_t type. If the partition is not in the
* currently created list, returns std::nullopt.
*/
[[nodiscard]] std::optional<std::pair<uint64_t, bool>>
get(std::string_view name) const;
[[nodiscard]] std::optional<std::pair<uint64_t, bool>> get(
std::string_view name) const;
/**
* If there is a logical partition(s) in the created
@@ -183,16 +182,16 @@ public:
* data of type std::string). If there is no logical
* partition in the created list, it returns std::nullopt.
*/
[[nodiscard]] std::optional<std::list<std::string>>
getLogicalPartitionList() const;
[[nodiscard]] std::optional<std::list<std::string>> getLogicalPartitionList()
const;
/**
* The physical partitions in the created list are
* returned as std::list type. If there is no content
* due to any problem, returns std::nullopt.
*/
[[nodiscard]] std::optional<std::list<std::string>>
getPhysicalPartitionList() const;
[[nodiscard]] std::optional<std::list<std::string>> getPhysicalPartitionList()
const;
/**
* The partitions in the created list are returned as std::list
@@ -244,17 +243,17 @@ public:
/**
* Copy partition list to vec, current vec contents are cleaned
*/
bool copyPartitionsToVector(std::vector<std::string> &vec) const;
bool copyPartitionsToVector(std::vector<std::string>& vec) const;
/**
* Copy logical partition list to vec, current vec contents are cleaned
*/
bool copyLogicalPartitionsToVector(std::vector<std::string> &vec) const;
bool copyLogicalPartitionsToVector(std::vector<std::string>& vec) const;
/**
* Copy physical partition list to vec, current vec contents are cleaned
*/
bool copyPhysicalPartitionsToVector(std::vector<std::string> &vec) const;
bool copyPhysicalPartitionsToVector(std::vector<std::string>& vec) const;
/**
* The created list and the current search index name are cleared.
@@ -265,26 +264,26 @@ public:
* Do input function (lambda) for all partitions.
*/
bool doForAllPartitions(
const std::function<bool(std::string, BasicInf)> &func) const;
const std::function<bool(std::string, BasicInf)>& func) const;
/**
* Do input function (lambda) for physical partitions.
*/
bool doForPhysicalPartitions(
const std::function<bool(std::string, BasicInf)> &func) const;
const std::function<bool(std::string, BasicInf)>& func) const;
/**
* Do input function (lambda) for logical partitions.
*/
bool doForLogicalPartitions(
const std::function<bool(std::string, BasicInf)> &func) const;
const std::function<bool(std::string, BasicInf)>& func) const;
/**
* Do input function (lambda) for input partition list.
*/
bool doForPartitionList(
const std::vector<std::string> &partitions,
const std::function<bool(std::string, BasicInf)> &func) const;
const std::vector<std::string>& partitions,
const std::function<bool(std::string, BasicInf)>& func) const;
/**
* The entered path is defined as the new search
@@ -317,14 +316,14 @@ public:
* the same (checked only according to the partition
* names), true is returned, otherwise false is returned
*/
friend bool operator==(const basic_partition_map_builder &lhs,
const basic_partition_map_builder &rhs);
friend bool operator==(const basic_partition_map_builder& lhs,
const basic_partition_map_builder& rhs);
/**
* The opposite logic of the == operator.
*/
friend bool operator!=(const basic_partition_map_builder &lhs,
const basic_partition_map_builder &rhs);
friend bool operator!=(const basic_partition_map_builder& lhs,
const basic_partition_map_builder& rhs);
/**
* You can check whether the object was created
@@ -347,12 +346,12 @@ public:
/**
* Get Map_t object reference
*/
Map_t &operator*();
Map_t& operator*();
/**
* Get constant Map_t object reference
*/
const Map_t &operator*() const;
const Map_t& operator*() const;
/**
* Get Info structure with given index
@@ -362,7 +361,7 @@ public:
/**
* Get BasicInfo structure with given index
*/
BasicInf operator[](const std::string_view &name) const;
BasicInf operator[](const std::string_view& name) const;
/**
* Get map contents as vector (PartitionManager::Info type).
@@ -402,7 +401,7 @@ constexpr uint64_t FAT16_FS = 0x3631544146;
constexpr uint64_t FAT32_FS = 0x3233544146;
constexpr uint64_t NTFS_FS = 0x5346544E;
constexpr uint64_t MSDOS_FS = 0x4d44;
} // namespace FileSystemMagic
} // namespace FileSystemMagic
namespace AndroidMagic {
constexpr uint64_t BOOT_IMAGE = 0x2144494F52444E41;
@@ -413,23 +412,23 @@ constexpr uint64_t VBMETA_IMAGE = 0x425641;
constexpr uint64_t SUPER_IMAGE = 0x7265797573;
constexpr uint64_t SPARSE_IMAGE = 0x3AFF26ED;
constexpr uint64_t ELF =
0x464C457F; // It makes more sense than between file systems
0x464C457F; // It makes more sense than between file systems
constexpr uint64_t RAW = 0x00000000;
} // namespace AndroidMagic
} // namespace AndroidMagic
extern std::map<uint64_t, std::string> FileSystemMagicMap;
extern std::map<uint64_t, std::string> AndroidMagicMap;
extern std::map<uint64_t, std::string> MagicMap;
size_t getMagicLength(uint64_t magic);
bool hasMagic(uint64_t magic, ssize_t buf, const std::string &path);
bool hasMagic(uint64_t magic, ssize_t buf, const std::string& path);
std::string formatMagic(uint64_t magic);
} // namespace Extras
} // namespace PartitionMap
} // namespace Extras
} // namespace PartitionMap
#define MAP "libpartition_map"
#define COMMON_LAMBDA_PARAMS \
(const std::string &partition, const PartitionMap::BasicInf props)
#define COMMON_LAMBDA_PARAMS \
(const std::string& partition, const PartitionMap::BasicInf props)
#endif // #ifndef LIBPARTITION_MAP_LIB_HPP
#endif // #ifndef LIBPARTITION_MAP_LIB_HPP

17
srclib/libpartition_map/src/Getters.cpp
View File

@@ -25,8 +25,8 @@ Map_t basic_partition_map_builder::getAll() const {
return _current_map;
}
std::optional<std::pair<uint64_t, bool>>
basic_partition_map_builder::get(const std::string_view name) const {
std::optional<std::pair<uint64_t, bool>> basic_partition_map_builder::get(
const std::string_view name) const {
_map_build_check();
if (!_current_map.find(name)) return std::nullopt;
@@ -39,7 +39,7 @@ basic_partition_map_builder::getLogicalPartitionList() const {
_map_build_check();
std::list<std::string> logicals;
for (const auto &[name, props] : _current_map)
for (const auto& [name, props] : _current_map)
if (props.isLogical) logicals.push_back(name);
if (logicals.empty()) return std::nullopt;
@@ -51,7 +51,7 @@ basic_partition_map_builder::getPhysicalPartitionList() const {
_map_build_check();
std::list<std::string> physicals;
for (const auto &[name, props] : _current_map)
for (const auto& [name, props] : _current_map)
if (!props.isLogical) physicals.push_back(name);
if (physicals.empty()) return std::nullopt;
@@ -63,8 +63,7 @@ basic_partition_map_builder::getPartitionList() const {
_map_build_check();
std::list<std::string> partitions;
for (const auto &[name, props] : _current_map)
partitions.push_back(name);
for (const auto& [name, props] : _current_map) partitions.push_back(name);
if (partitions.empty()) return std::nullopt;
return partitions;
@@ -78,8 +77,8 @@ std::string basic_partition_map_builder::getRealLinkPathOf(
return std::string(_workdir + "/" + name.data());
}
std::string
basic_partition_map_builder::getRealPathOf(const std::string_view name) const {
std::string basic_partition_map_builder::getRealPathOf(
const std::string_view name) const {
_map_build_check();
const std::string full = (isLogical(name))
@@ -93,4 +92,4 @@ basic_partition_map_builder::getRealPathOf(const std::string_view name) const {
std::string basic_partition_map_builder::getCurrentWorkDir() const {
return _workdir;
}
} // namespace PartitionMap
} // namespace PartitionMap

9
srclib/libpartition_map/src/Magic.cpp
View File

@@ -15,12 +15,13 @@
*/
#include <fcntl.h>
#include <unistd.h>
#include <libhelper/lib.hpp>
#include <libpartition_map/lib.hpp>
#include <map>
#include <sstream>
#include <string>
#include <unistd.h>
#include "PartitionManager/PartitionManager.hpp"
@@ -76,7 +77,7 @@ size_t getMagicLength(const uint64_t magic) {
}
bool hasMagic(const uint64_t magic, const ssize_t buf,
const std::string &path) {
const std::string& path) {
LOGN(MAP, INFO) << "Checking magic of " << path << " with using " << buf
<< " byte buffer size (has magic 0x" << std::hex << magic
<< "?)" << std::endl;
@@ -89,7 +90,7 @@ bool hasMagic(const uint64_t magic, const ssize_t buf,
return false;
}
auto *buffer = new (std::nothrow) uint8_t[buf];
auto* buffer = new (std::nothrow) uint8_t[buf];
collector.delAfterProgress(buffer);
const ssize_t bytesRead = read(fd, buffer, buf);
@@ -120,4 +121,4 @@ std::string formatMagic(const uint64_t magic) {
<< magic;
return ss.str();
}
} // namespace PartitionMap::Extras
} // namespace PartitionMap::Extras

98
srclib/libpartition_map/src/PartitionMap.cpp
View File

@@ -14,24 +14,26 @@
limitations under the License.
*/
#include <fcntl.h>
#include <algorithm>
#include <array>
#include <cerrno>
#include <cstring>
#include <fcntl.h>
#include <filesystem>
#ifndef ANDROID_BUILD
#include <generated/buildInfo.hpp>
#endif
#include <iostream>
#include <libpartition_map/lib.hpp>
#include <linux/fs.h>
#include <memory>
#include <string>
#include <string_view>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <iostream>
#include <libpartition_map/lib.hpp>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
static constexpr std::array<std::string_view, 3> defaultEntryList = {
@@ -60,7 +62,7 @@ Map_t basic_partition_map_builder::_build_map(std::string_view path,
std::vector<std::filesystem::directory_entry> entries{
std::filesystem::directory_iterator(path),
std::filesystem::directory_iterator()};
std::sort(entries.begin(), entries.end(), [](const auto &a, const auto &b) {
std::sort(entries.begin(), entries.end(), [](const auto& a, const auto& b) {
return a.path().filename() < b.path().filename();
});
@@ -69,7 +71,7 @@ Map_t basic_partition_map_builder::_build_map(std::string_view path,
<< " is exists but generated vector is empty "
"(std::vector<std::filesystem::directory_entry>)."
<< std::endl;
for (const auto &entry : entries) {
for (const auto& entry : entries) {
if (entry.path().filename() != "by-uuid" &&
std::string(entry.path()).find("com.") == std::string::npos)
map.insert(entry.path().filename().string(), _get_size(entry.path()),
@@ -82,7 +84,7 @@ Map_t basic_partition_map_builder::_build_map(std::string_view path,
return map;
}
void basic_partition_map_builder::_insert_logicals(Map_t &&logicals) {
void basic_partition_map_builder::_insert_logicals(Map_t&& logicals) {
LOGN(MAP, INFO)
<< "merging created logical partition list to this object's variable."
<< std::endl;
@@ -96,7 +98,7 @@ void basic_partition_map_builder::_map_build_check() const {
if (!_map_builded) throw Error("Please build partition map before!");
}
uint64_t basic_partition_map_builder::_get_size(const std::string &path) {
uint64_t basic_partition_map_builder::_get_size(const std::string& path) {
const std::string real = std::filesystem::read_symlink(path);
Helper::garbageCollector collector;
@@ -120,7 +122,7 @@ uint64_t basic_partition_map_builder::_get_size(const std::string &path) {
basic_partition_map_builder::basic_partition_map_builder() {
LOGN(MAP, INFO) << "default constructor called. Starting build." << std::endl;
for (const auto &path : defaultEntryList) {
for (const auto& path : defaultEntryList) {
if (std::filesystem::exists(path)) {
_current_map = _build_map(path);
if (_current_map.empty()) {
@@ -149,8 +151,10 @@ basic_partition_map_builder::basic_partition_map_builder(
if (std::filesystem::exists(path)) {
if (!_is_real_block_dir(path)) return;
_current_map = _build_map(path);
if (_current_map.empty()) _any_generating_error = true;
else _workdir = path;
if (_current_map.empty())
_any_generating_error = true;
else
_workdir = path;
} else
throw Error("Cannot find directory: %s. Cannot build partition map!",
path.data());
@@ -162,7 +166,7 @@ basic_partition_map_builder::basic_partition_map_builder(
}
basic_partition_map_builder::basic_partition_map_builder(
basic_partition_map_builder &&other) noexcept {
basic_partition_map_builder&& other) noexcept {
_current_map = Map_t(std::move(other._current_map));
_workdir = std::move(other._workdir);
_any_generating_error = other._any_generating_error;
@@ -178,7 +182,7 @@ bool basic_partition_map_builder::hasPartition(
bool basic_partition_map_builder::hasLogicalPartitions() const {
_map_build_check();
for (const auto &[name, props] : _current_map)
for (const auto& [name, props] : _current_map)
if (props.isLogical) return true;
return false;
@@ -205,7 +209,8 @@ bool basic_partition_map_builder::readDirectory(const std::string_view path) {
if (_current_map.empty()) {
_any_generating_error = true;
return false;
} else _workdir = path;
} else
_workdir = path;
} else
throw Error("Cannot find directory: %s. Cannot build partition map!",
path.data());
@@ -220,7 +225,7 @@ bool basic_partition_map_builder::readDefaultDirectories() {
_map_builded = false;
LOGN(MAP, INFO) << "read default directories request." << std::endl;
for (const auto &path : defaultEntryList) {
for (const auto& path : defaultEntryList) {
if (std::filesystem::exists(path)) {
_current_map = _build_map(path);
if (_current_map.empty()) {
@@ -244,48 +249,49 @@ bool basic_partition_map_builder::readDefaultDirectories() {
}
bool basic_partition_map_builder::copyPartitionsToVector(
std::vector<std::string> &vec) const {
std::vector<std::string>& vec) const {
if (_current_map.empty()) {
LOGN(MAP, ERROR) << "Current map is empty.";
return false;
}
vec.clear();
for (const auto &[name, props] : _current_map)
vec.push_back(name);
for (const auto& [name, props] : _current_map) vec.push_back(name);
return true;
}
bool basic_partition_map_builder::copyLogicalPartitionsToVector(
std::vector<std::string> &vec) const {
std::vector<std::string>& vec) const {
if (_current_map.empty()) {
LOGN(MAP, ERROR) << "Current map is empty.";
return false;
}
std::vector<std::string> vec2;
for (const auto &[name, props] : _current_map)
for (const auto& [name, props] : _current_map)
if (props.isLogical) vec2.push_back(name);
if (vec2.empty()) {
LOGN(MAP, ERROR) << "Cannot find logical partitions in current map.";
return false;
} else vec = vec2;
} else
vec = vec2;
return true;
}
bool basic_partition_map_builder::copyPhysicalPartitionsToVector(
std::vector<std::string> &vec) const {
std::vector<std::string>& vec) const {
if (_current_map.empty()) {
LOGN(MAP, ERROR) << "Current map is empty.";
return false;
}
std::vector<std::string> vec2;
for (const auto &[name, props] : _current_map)
for (const auto& [name, props] : _current_map)
if (!props.isLogical) vec2.push_back(name);
if (vec2.empty()) {
LOGN(MAP, ERROR) << "Cannot find physical partitions in current map.";
return false;
} else vec = vec2;
} else
vec = vec2;
return true;
}
@@ -295,12 +301,12 @@ bool basic_partition_map_builder::empty() const {
}
bool basic_partition_map_builder::doForAllPartitions(
const std::function<bool(std::string, BasicInf)> &func) const {
const std::function<bool(std::string, BasicInf)>& func) const {
_map_build_check();
bool err = false;
LOGN(MAP, INFO) << "Doing input function for all partitions." << std::endl;
for (const auto &[name, props] : _current_map) {
for (const auto& [name, props] : _current_map) {
if (func(name, {props.size, props.isLogical}))
LOGN(MAP, INFO) << "Done progress for " << name << " partition."
<< std::endl;
@@ -315,13 +321,13 @@ bool basic_partition_map_builder::doForAllPartitions(
}
bool basic_partition_map_builder::doForPhysicalPartitions(
const std::function<bool(std::string, BasicInf)> &func) const {
const std::function<bool(std::string, BasicInf)>& func) const {
_map_build_check();
bool err = false;
LOGN(MAP, INFO) << "Doing input function for physical partitions."
<< std::endl;
for (const auto &[name, props] : _current_map) {
for (const auto& [name, props] : _current_map) {
if (props.isLogical) continue;
if (func(name, {props.size, props.isLogical}))
LOGN(MAP, INFO) << "Done progress for " << name << " partition."
@@ -337,13 +343,13 @@ bool basic_partition_map_builder::doForPhysicalPartitions(
}
bool basic_partition_map_builder::doForLogicalPartitions(
const std::function<bool(std::string, BasicInf)> &func) const {
const std::function<bool(std::string, BasicInf)>& func) const {
_map_build_check();
bool err = false;
LOGN(MAP, INFO) << "Doing input function for logical partitions."
<< std::endl;
for (const auto &[name, props] : _current_map) {
for (const auto& [name, props] : _current_map) {
if (!props.isLogical) continue;
if (func(name, {props.size, props.isLogical}))
LOGN(MAP, INFO) << "Done progress for " << name << " partition."
@@ -359,14 +365,14 @@ bool basic_partition_map_builder::doForLogicalPartitions(
}
bool basic_partition_map_builder::doForPartitionList(
const std::vector<std::string> &partitions,
const std::function<bool(std::string, BasicInf)> &func) const {
const std::vector<std::string>& partitions,
const std::function<bool(std::string, BasicInf)>& func) const {
_map_build_check();
bool err = false;
LOGN(MAP, INFO) << "Doing input function for input partition list."
<< std::endl;
for (const auto &partition : partitions) {
for (const auto& partition : partitions) {
if (!hasPartition(partition))
throw Error("Couldn't find partition: %s", partition.data());
if (!func(partition, _current_map[partition])) {
@@ -379,19 +385,19 @@ bool basic_partition_map_builder::doForPartitionList(
return err;
}
uint64_t
basic_partition_map_builder::sizeOf(const std::string_view name) const {
uint64_t basic_partition_map_builder::sizeOf(
const std::string_view name) const {
_map_build_check();
return _current_map.get_size(name);
}
bool operator==(const basic_partition_map_builder &lhs,
const basic_partition_map_builder &rhs) {
bool operator==(const basic_partition_map_builder& lhs,
const basic_partition_map_builder& rhs) {
return lhs._current_map == rhs._current_map;
}
bool operator!=(const basic_partition_map_builder &lhs,
const basic_partition_map_builder &rhs) {
bool operator!=(const basic_partition_map_builder& lhs,
const basic_partition_map_builder& rhs) {
return !(lhs == rhs);
}
@@ -409,9 +415,9 @@ bool basic_partition_map_builder::operator()(const std::string_view path) {
return readDirectory(path);
}
Map_t &basic_partition_map_builder::operator*() { return _current_map; }
Map_t& basic_partition_map_builder::operator*() { return _current_map; }
const Map_t &basic_partition_map_builder::operator*() const {
const Map_t& basic_partition_map_builder::operator*() const {
return _current_map;
}
@@ -419,8 +425,8 @@ Info basic_partition_map_builder::operator[](const int index) const {
return _current_map[index];
}
BasicInf
basic_partition_map_builder::operator[](const std::string_view &name) const {
BasicInf basic_partition_map_builder::operator[](
const std::string_view& name) const {
return _current_map[name];
}
@@ -435,4 +441,4 @@ basic_partition_map_builder::operator int() const {
basic_partition_map_builder::operator std::string() const { return _workdir; }
std::string getLibVersion() { MKVERSION("libpartition_map"); }
} // namespace PartitionMap
} // namespace PartitionMap

68
srclib/libpartition_map/src/Type.cpp
View File

@@ -20,16 +20,16 @@
#include <utility>
namespace PartitionMap {
basic_partition_map::iterator::iterator(_entry *p) : ptr(p) {}
basic_partition_map::iterator::iterator(_entry* p) : ptr(p) {}
auto basic_partition_map::iterator::operator*() const
-> std::pair<std::string &, decltype(_entry::props) &> {
-> std::pair<std::string&, decltype(_entry::props)&> {
return {ptr->name, ptr->props};
}
_entry *basic_partition_map::iterator::operator->() const { return ptr; }
_entry* basic_partition_map::iterator::operator->() const { return ptr; }
basic_partition_map::iterator &basic_partition_map::iterator::operator++() {
basic_partition_map::iterator& basic_partition_map::iterator::operator++() {
++ptr;
return *this;
}
@@ -40,27 +40,27 @@ basic_partition_map::iterator basic_partition_map::iterator::operator++(int) {
return tmp;
}
bool basic_partition_map::iterator::operator==(const iterator &other) const {
bool basic_partition_map::iterator::operator==(const iterator& other) const {
return ptr == other.ptr;
}
bool basic_partition_map::iterator::operator!=(const iterator &other) const {
bool basic_partition_map::iterator::operator!=(const iterator& other) const {
return ptr != other.ptr;
}
basic_partition_map::constant_iterator::constant_iterator(const _entry *p)
basic_partition_map::constant_iterator::constant_iterator(const _entry* p)
: ptr(p) {}
auto basic_partition_map::constant_iterator::operator*() const
-> std::pair<const std::string &, const decltype(_entry::props) &> {
-> std::pair<const std::string&, const decltype(_entry::props)&> {
return {ptr->name, ptr->props};
}
const _entry *basic_partition_map::constant_iterator::operator->() const {
const _entry* basic_partition_map::constant_iterator::operator->() const {
return ptr;
}
basic_partition_map::constant_iterator &
basic_partition_map::constant_iterator&
basic_partition_map::constant_iterator::operator++() {
++ptr;
return *this;
@@ -74,21 +74,20 @@ basic_partition_map::constant_iterator::operator++(int) {
}
bool basic_partition_map::constant_iterator::operator==(
const constant_iterator &other) const {
const constant_iterator& other) const {
return ptr == other.ptr;
}
bool basic_partition_map::constant_iterator::operator!=(
const constant_iterator &other) const {
const constant_iterator& other) const {
return ptr != other.ptr;
}
void basic_partition_map::_resize_map() {
const size_t new_capacity = _capacity * 2;
auto *new_data = new _entry[new_capacity];
auto* new_data = new _entry[new_capacity];
for (size_t i = 0; i < _count; i++)
new_data[i] = _data[i];
for (size_t i = 0; i < _count; i++) new_data[i] = _data[i];
delete[] _data;
_data = new_data;
@@ -103,21 +102,23 @@ int basic_partition_map::_index_of(const std::string_view name) const {
return 0;
}
basic_partition_map::basic_partition_map(const std::string &name,
basic_partition_map::basic_partition_map(const std::string& name,
const uint64_t size,
const bool logical) {
_data = new _entry[_capacity];
insert(name, size, logical);
}
basic_partition_map::basic_partition_map(const basic_partition_map &other)
: _data(new _entry[other._capacity]), _count(other._count),
basic_partition_map::basic_partition_map(const basic_partition_map& other)
: _data(new _entry[other._capacity]),
_count(other._count),
_capacity(other._capacity) {
std::copy(other._data, other._data + _count, _data);
}
basic_partition_map::basic_partition_map(basic_partition_map &&other) noexcept
: _data(new _entry[other._capacity]), _count(other._count),
basic_partition_map::basic_partition_map(basic_partition_map&& other) noexcept
: _data(new _entry[other._capacity]),
_count(other._count),
_capacity(other._capacity) {
std::copy(other._data, other._data + _count, _data);
other.clear();
@@ -129,7 +130,7 @@ basic_partition_map::basic_partition_map() : _capacity(6) {
basic_partition_map::~basic_partition_map() { delete[] _data; }
bool basic_partition_map::insert(const std::string &name, const uint64_t size,
bool basic_partition_map::insert(const std::string& name, const uint64_t size,
const bool logical) {
if (name == _data[_index_of(name)].name) return false;
if (_count == _capacity) _resize_map();
@@ -141,9 +142,9 @@ bool basic_partition_map::insert(const std::string &name, const uint64_t size,
return true;
}
void basic_partition_map::merge(const basic_partition_map &map) {
void basic_partition_map::merge(const basic_partition_map& map) {
LOGN(MAP, INFO) << "map merge request." << std::endl;
for (const auto &[name, props] : map)
for (const auto& [name, props] : map)
insert(name, props.size, props.isLogical);
LOGN(MAP, INFO) << "map merged successfully." << std::endl;
}
@@ -162,8 +163,8 @@ bool basic_partition_map::is_logical(const std::string_view name) const {
return false;
}
_returnable_entry
basic_partition_map::get_all(const std::string_view name) const {
_returnable_entry basic_partition_map::get_all(
const std::string_view name) const {
if (const int pos = _index_of(name); name == _data[pos].name)
return _returnable_entry{_data[pos].props.size, _data[pos].props.isLogical};
@@ -176,7 +177,7 @@ bool basic_partition_map::find(const std::string_view name) const {
return false;
}
std::string basic_partition_map::find_(const std::string &name) const {
std::string basic_partition_map::find_(const std::string& name) const {
if (name == _data[_index_of(name)].name) return name;
return {};
@@ -194,8 +195,8 @@ void basic_partition_map::clear() {
_data = new _entry[_capacity];
}
basic_partition_map &
basic_partition_map::operator=(const basic_partition_map &map) {
basic_partition_map& basic_partition_map::operator=(
const basic_partition_map& map) {
if (this != &map) {
delete[] _data;
@@ -208,7 +209,7 @@ basic_partition_map::operator=(const basic_partition_map &map) {
return *this;
}
bool basic_partition_map::operator==(const basic_partition_map &other) const {
bool basic_partition_map::operator==(const basic_partition_map& other) const {
if (this->_capacity != other._capacity || this->_count != other._count)
return false;
@@ -217,12 +218,13 @@ bool basic_partition_map::operator==(const basic_partition_map &other) const {
_data[i].props.size == other._data[i].props.size &&
_data[i].props.isLogical == other._data[i].props.isLogical)
continue;
else return false;
else
return false;
return true;
}
bool basic_partition_map::operator!=(const basic_partition_map &other) const {
bool basic_partition_map::operator!=(const basic_partition_map& other) const {
return !(*this == other);
}
@@ -235,7 +237,7 @@ Info basic_partition_map::operator[](const int index) const {
return _data[index];
}
BasicInf basic_partition_map::operator[](const std::string_view &name) const {
BasicInf basic_partition_map::operator[](const std::string_view& name) const {
if (_count == 0) return {};
if (const int i = _index_of(name); name == _data[i].name)
@@ -270,4 +272,4 @@ basic_partition_map::constant_iterator basic_partition_map::cbegin() const {
basic_partition_map::constant_iterator basic_partition_map::cend() const {
return constant_iterator(_data + _count);
}
} // namespace PartitionMap
} // namespace PartitionMap

15
srclib/libpartition_map/tests/test.cpp
View File

@@ -14,10 +14,11 @@
limitations under the License.
*/
#include <unistd.h>
#include <fstream>
#include <iostream>
#include <libpartition_map/lib.hpp>
#include <unistd.h>
int main() {
if (getuid() != 0) return 2;
@@ -31,7 +32,7 @@ int main() {
const auto map = MyMap.getAll();
if (map.empty()) throw PartitionMap::Error("getAll() empty");
for (const auto &[name, props] : map) {
for (const auto& [name, props] : map) {
std::cout << "Partition: " << name << ", size: " << props.size
<< ", logical: " << props.isLogical << std::endl;
}
@@ -45,14 +46,14 @@ int main() {
if (!logicals)
throw PartitionMap::Error("getLogicalPartitionList() returned nullopt");
std::cout << "Logical partitions: " << std::endl;
for (const auto &name : *logicals)
for (const auto& name : *logicals)
std::cout << " - " << name << std::endl;
const auto physicals = MyMap.getPhysicalPartitionList();
if (!physicals)
throw PartitionMap::Error("getPhysicalPartitionList() returned nullopt");
std::cout << "Physical partitions: " << std::endl;
for (const auto &name : *physicals)
for (const auto& name : *physicals)
std::cout << " - " << name << std::endl;
if (const std::vector<PartitionMap::Info> parts =
@@ -61,7 +62,7 @@ int main() {
throw PartitionMap::Error(
"operator std::vector<PartitionMap::Info>() returned empty vector");
auto func = [](const std::string &partition,
auto func = [](const std::string& partition,
const PartitionMap::BasicInf props) -> bool {
std::ofstream f("parts.txt");
f << "Partition: " << partition << ", size: " << props.size
@@ -96,10 +97,10 @@ int main() {
if (MyMap != MyMap2) std::cout << "map1 != map2" << std::endl;
std::cout << PartitionMap::getLibVersion() << std::endl;
} catch (PartitionMap::Error &error) {
} catch (PartitionMap::Error& error) {
std::cerr << error.what() << std::endl;
return 1;
} catch (std::ios_base::failure &error) {
} catch (std::ios_base::failure& error) {
std::cerr << "fstream error: " << error.what() << std::endl;
return 1;
}