2023-06-25 15:42:18 +00:00
|
|
|
#include "StarDirectives.hpp"
|
2023-06-23 15:30:55 +00:00
|
|
|
#include "StarImage.hpp"
|
|
|
|
#include "StarImageProcessing.hpp"
|
2023-06-24 03:06:13 +00:00
|
|
|
#include "StarXXHash.hpp"
|
2023-06-24 13:38:27 +00:00
|
|
|
#include "StarLogging.hpp"
|
2023-06-23 15:30:55 +00:00
|
|
|
|
|
|
|
namespace Star {
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
Directives::Entry::Entry(ImageOperation&& newOperation, size_t strBegin, size_t strLength) {
|
2023-06-24 10:10:53 +00:00
|
|
|
operation = move(newOperation);
|
2023-06-25 15:42:18 +00:00
|
|
|
begin = strBegin;
|
|
|
|
length = strLength;
|
2023-06-24 10:10:53 +00:00
|
|
|
}
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
Directives::Entry::Entry(ImageOperation const& newOperation, size_t strBegin, size_t strLength) {
|
2023-06-24 12:49:47 +00:00
|
|
|
operation = newOperation;
|
2023-06-25 15:42:18 +00:00
|
|
|
begin = strBegin;
|
|
|
|
length = strLength;
|
2023-06-24 12:49:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Directives::Entry::Entry(Entry const& other) {
|
|
|
|
operation = other.operation;
|
2023-06-25 15:42:18 +00:00
|
|
|
begin = other.begin;
|
|
|
|
length = other.length;
|
2023-06-24 12:49:47 +00:00
|
|
|
}
|
|
|
|
|
2023-06-26 17:38:57 +00:00
|
|
|
ImageOperation const& Directives::Entry::loadOperation(Shared const& parent) const {
|
|
|
|
if (operation.is<NullImageOperation>()) {
|
|
|
|
try { operation = imageOperationFromString(string(parent)); }
|
|
|
|
catch (StarException const& e) { operation = ErrorImageOperation{ std::current_exception() }; }
|
|
|
|
}
|
|
|
|
return operation;
|
|
|
|
}
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
StringView Directives::Entry::string(Shared const& parent) const {
|
2023-06-25 15:51:57 +00:00
|
|
|
StringView result = parent.string;
|
|
|
|
result = result.utf8().substr(begin, length);
|
2023-06-25 15:42:18 +00:00
|
|
|
return result;
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
bool Directives::Shared::empty() const {
|
|
|
|
return entries.empty();
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2023-06-26 05:34:41 +00:00
|
|
|
Directives::Shared::Shared(List<Entry>&& givenEntries, String&& givenString, StringView givenPrefix) {
|
2023-06-25 15:42:18 +00:00
|
|
|
entries = move(givenEntries);
|
|
|
|
string = move(givenString);
|
2023-06-26 05:34:41 +00:00
|
|
|
prefix = givenPrefix;
|
2023-06-25 15:42:18 +00:00
|
|
|
hash = XXH3_64bits(string.utf8Ptr(), string.utf8Size());
|
2023-06-24 12:49:47 +00:00
|
|
|
}
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
Directives::Directives() {}
|
2024-01-03 08:17:19 +00:00
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
Directives::Directives(String const& directives) {
|
|
|
|
parse(String(directives));
|
|
|
|
}
|
|
|
|
|
|
|
|
Directives::Directives(String&& directives) {
|
|
|
|
parse(move(directives));
|
2023-06-24 12:49:47 +00:00
|
|
|
}
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
Directives::Directives(const char* directives) {
|
|
|
|
parse(directives);
|
|
|
|
}
|
|
|
|
|
2024-01-03 08:17:19 +00:00
|
|
|
Directives::Directives(Directives&& directives) {
|
|
|
|
*this = move(directives);
|
|
|
|
}
|
|
|
|
|
|
|
|
Directives::Directives(Directives const& directives) {
|
|
|
|
*this = directives;
|
|
|
|
}
|
|
|
|
|
|
|
|
Directives::~Directives() {}
|
|
|
|
|
|
|
|
Directives& Directives::operator=(String const& s) {
|
|
|
|
if (shared && shared->string == s)
|
2023-08-30 17:14:48 +00:00
|
|
|
return *this;
|
|
|
|
|
2024-01-03 08:17:19 +00:00
|
|
|
parse(String(s));
|
2023-08-30 17:14:48 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2024-01-03 08:17:19 +00:00
|
|
|
Directives& Directives::operator=(String&& s) {
|
|
|
|
if (shared && shared->string == s) {
|
|
|
|
s.clear();
|
2023-08-30 17:14:48 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2024-01-03 08:17:19 +00:00
|
|
|
parse(move(s));
|
2023-08-30 17:14:48 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2024-01-03 08:17:19 +00:00
|
|
|
Directives& Directives::operator=(const char* s) {
|
|
|
|
if (shared && shared->string.utf8().compare(s) == 0)
|
2023-08-30 17:14:48 +00:00
|
|
|
return *this;
|
|
|
|
|
2024-01-03 08:17:19 +00:00
|
|
|
parse(s);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
Directives& Directives::operator=(Directives&& other) {
|
|
|
|
shared = move(other.shared);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
Directives& Directives::operator=(Directives const& other) {
|
|
|
|
shared = other.shared;
|
2023-08-30 17:14:48 +00:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2023-06-26 17:38:57 +00:00
|
|
|
void Directives::loadOperations() const {
|
|
|
|
if (!shared)
|
|
|
|
return;
|
|
|
|
|
|
|
|
MutexLocker lock(shared->mutex, true);
|
|
|
|
for (auto& entry : shared->entries)
|
|
|
|
entry.loadOperation(*shared);
|
|
|
|
}
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
void Directives::parse(String&& directives) {
|
2023-09-05 06:42:44 +00:00
|
|
|
if (directives.empty()) {
|
|
|
|
shared.reset();
|
2023-06-24 13:38:27 +00:00
|
|
|
return;
|
2023-09-05 06:42:44 +00:00
|
|
|
}
|
2023-06-24 13:38:27 +00:00
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
List<Entry> newList;
|
2023-06-26 05:34:41 +00:00
|
|
|
StringView view(directives);
|
|
|
|
StringView prefix = "";
|
|
|
|
view.forEachSplitView("?", [&](StringView split, size_t beg, size_t end) {
|
2023-06-25 15:42:18 +00:00
|
|
|
if (!split.empty()) {
|
2023-06-26 17:38:57 +00:00
|
|
|
if (beg == 0) {
|
|
|
|
try {
|
|
|
|
ImageOperation operation = imageOperationFromString(split);
|
|
|
|
newList.emplace_back(move(operation), beg, end);
|
|
|
|
}
|
|
|
|
catch (StarException const& e) {
|
2023-06-26 05:34:41 +00:00
|
|
|
prefix = split;
|
2023-06-26 17:38:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ImageOperation operation = NullImageOperation();
|
|
|
|
newList.emplace_back(move(operation), beg, end);
|
2023-06-24 15:16:40 +00:00
|
|
|
}
|
2023-06-24 09:41:52 +00:00
|
|
|
}
|
2023-06-25 15:42:18 +00:00
|
|
|
});
|
2023-06-24 13:38:27 +00:00
|
|
|
|
2023-09-05 06:42:44 +00:00
|
|
|
if (newList.empty() && !prefix.empty()) {
|
|
|
|
shared.reset();
|
2023-06-24 13:38:27 +00:00
|
|
|
return;
|
2023-09-05 06:42:44 +00:00
|
|
|
}
|
2023-06-24 13:38:27 +00:00
|
|
|
|
2023-06-26 05:34:41 +00:00
|
|
|
shared = std::make_shared<Shared const>(move(newList), move(directives), prefix);
|
2023-06-27 09:24:35 +00:00
|
|
|
if (view.size() < 1000) { // Pre-load short enough directives
|
|
|
|
for (auto& entry : shared->entries)
|
|
|
|
entry.loadOperation(*shared);
|
|
|
|
}
|
2023-06-25 15:42:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
String Directives::string() const {
|
|
|
|
if (!shared)
|
|
|
|
return "";
|
|
|
|
else
|
|
|
|
return shared->string;
|
|
|
|
}
|
|
|
|
|
2023-06-26 05:34:41 +00:00
|
|
|
StringView Directives::prefix() const {
|
|
|
|
if (!shared)
|
|
|
|
return "";
|
|
|
|
else
|
|
|
|
return shared->prefix;
|
|
|
|
}
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
String const* Directives::stringPtr() const {
|
|
|
|
if (!shared)
|
|
|
|
return nullptr;
|
|
|
|
else
|
|
|
|
return &shared->string;
|
2023-06-24 03:06:13 +00:00
|
|
|
}
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
|
|
|
|
String Directives::buildString() const {
|
|
|
|
if (shared) {
|
2023-06-26 05:34:41 +00:00
|
|
|
String built = shared->prefix;
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
for (auto& entry : shared->entries) {
|
|
|
|
built += "?";
|
|
|
|
built += entry.string(*shared);
|
2023-06-24 13:38:27 +00:00
|
|
|
}
|
2023-06-26 05:34:41 +00:00
|
|
|
|
|
|
|
return built;
|
2023-06-24 09:41:52 +00:00
|
|
|
}
|
2023-06-24 15:16:40 +00:00
|
|
|
|
2023-06-26 05:34:41 +00:00
|
|
|
return String();
|
2023-06-25 15:42:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
String& Directives::addToString(String& out) const {
|
|
|
|
if (!empty())
|
|
|
|
out += shared->string;
|
2023-06-24 15:16:40 +00:00
|
|
|
return out;
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
size_t Directives::hash() const {
|
|
|
|
return shared ? shared->hash : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t Directives::size() const {
|
|
|
|
return shared ? shared->entries.size() : 0;
|
2023-06-24 12:49:47 +00:00
|
|
|
}
|
|
|
|
|
2023-06-26 18:48:27 +00:00
|
|
|
bool Directives::empty() const {
|
2023-06-25 15:42:18 +00:00
|
|
|
return !shared || shared->empty();
|
2023-06-24 12:49:47 +00:00
|
|
|
}
|
|
|
|
|
2023-06-28 19:58:24 +00:00
|
|
|
Directives::operator bool() const { return !empty(); }
|
2023-06-24 12:49:47 +00:00
|
|
|
|
|
|
|
DataStream& operator>>(DataStream& ds, Directives& directives) {
|
|
|
|
String string;
|
|
|
|
ds.read(string);
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
directives.parse(move(string));
|
2023-06-24 12:49:47 +00:00
|
|
|
|
|
|
|
return ds;
|
|
|
|
}
|
|
|
|
|
2023-06-26 18:48:27 +00:00
|
|
|
DataStream& operator<<(DataStream & ds, Directives const& directives) {
|
2023-06-25 15:42:18 +00:00
|
|
|
if (directives)
|
|
|
|
ds.write(directives.shared->string);
|
|
|
|
else
|
|
|
|
ds.write(String());
|
2023-06-24 12:49:47 +00:00
|
|
|
|
|
|
|
return ds;
|
|
|
|
}
|
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
DirectivesGroup::DirectivesGroup() : m_count(0) {}
|
2023-06-24 15:16:40 +00:00
|
|
|
DirectivesGroup::DirectivesGroup(String const& directives) : m_count(0) {
|
|
|
|
if (directives.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
Directives parsed(directives);
|
|
|
|
if (parsed) {
|
|
|
|
m_directives.emplace_back(move(parsed));
|
2023-06-25 15:42:18 +00:00
|
|
|
m_count = m_directives.back().size();
|
2023-06-24 15:16:40 +00:00
|
|
|
}
|
2023-06-24 03:06:13 +00:00
|
|
|
}
|
2023-06-24 15:16:40 +00:00
|
|
|
DirectivesGroup::DirectivesGroup(String&& directives) : m_count(0) {
|
|
|
|
if (directives.empty()) {
|
|
|
|
directives.clear();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
Directives parsed(move(directives));
|
|
|
|
if (parsed) {
|
|
|
|
m_directives.emplace_back(move(parsed));
|
2023-06-25 15:42:18 +00:00
|
|
|
m_count = m_directives.back().size();
|
2023-06-24 15:16:40 +00:00
|
|
|
}
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2023-06-26 18:48:27 +00:00
|
|
|
bool DirectivesGroup::empty() const {
|
2023-06-24 09:41:52 +00:00
|
|
|
return m_count == 0;
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2023-06-26 18:48:27 +00:00
|
|
|
DirectivesGroup::operator bool() const {
|
2023-06-24 15:16:40 +00:00
|
|
|
return empty();
|
|
|
|
}
|
|
|
|
|
2023-06-25 08:24:54 +00:00
|
|
|
bool DirectivesGroup::compare(DirectivesGroup const& other) const {
|
2023-06-24 09:41:52 +00:00
|
|
|
if (m_count != other.m_count)
|
|
|
|
return false;
|
2023-06-23 15:30:55 +00:00
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
if (empty())
|
|
|
|
return true;
|
2023-06-23 15:30:55 +00:00
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
return hash() == other.hash();
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
void DirectivesGroup::append(Directives const& directives) {
|
2023-06-24 12:49:47 +00:00
|
|
|
m_directives.emplace_back(directives);
|
2023-06-25 15:42:18 +00:00
|
|
|
m_count += m_directives.back().size();
|
2023-06-24 12:49:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void DirectivesGroup::clear() {
|
|
|
|
m_directives.clear();
|
|
|
|
m_count = 0;
|
|
|
|
}
|
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
DirectivesGroup& DirectivesGroup::operator+=(Directives const& other) {
|
|
|
|
append(other);
|
|
|
|
return *this;
|
2023-06-24 03:06:13 +00:00
|
|
|
}
|
|
|
|
|
2023-06-26 18:48:27 +00:00
|
|
|
String DirectivesGroup::toString() const {
|
2023-06-24 09:41:52 +00:00
|
|
|
String string;
|
|
|
|
addToString(string);
|
|
|
|
return string;
|
2023-06-24 03:06:13 +00:00
|
|
|
}
|
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
void DirectivesGroup::addToString(String& string) const {
|
|
|
|
for (auto& directives : m_directives)
|
2023-11-25 12:03:46 +00:00
|
|
|
if (directives.shared) {
|
|
|
|
auto& dirString = directives.shared->string;
|
|
|
|
if (!dirString.empty()) {
|
|
|
|
if (dirString.utf8().front() != '?')
|
|
|
|
string += "?";
|
|
|
|
string += dirString;
|
|
|
|
}
|
|
|
|
}
|
2023-06-24 03:06:13 +00:00
|
|
|
}
|
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
void DirectivesGroup::forEach(DirectivesCallback callback) const {
|
|
|
|
for (auto& directives : m_directives) {
|
2023-06-25 15:42:18 +00:00
|
|
|
if (directives.shared) {
|
|
|
|
for (auto& entry : directives.shared->entries)
|
|
|
|
callback(entry, directives);
|
2023-06-24 13:38:27 +00:00
|
|
|
}
|
2023-06-24 03:06:13 +00:00
|
|
|
}
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
bool DirectivesGroup::forEachAbortable(AbortableDirectivesCallback callback) const {
|
|
|
|
for (auto& directives : m_directives) {
|
2023-06-25 15:42:18 +00:00
|
|
|
if (directives.shared) {
|
|
|
|
for (auto& entry : directives.shared->entries) {
|
|
|
|
if (!callback(entry, directives))
|
2023-06-24 13:38:27 +00:00
|
|
|
return false;
|
|
|
|
}
|
2023-06-24 03:06:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
return true;
|
2023-06-24 03:06:13 +00:00
|
|
|
}
|
|
|
|
|
2023-06-26 18:48:27 +00:00
|
|
|
Image DirectivesGroup::applyNewImage(Image const& image) const {
|
2023-06-24 09:41:52 +00:00
|
|
|
Image result = image;
|
|
|
|
applyExistingImage(result);
|
|
|
|
return result;
|
2023-06-24 03:06:13 +00:00
|
|
|
}
|
|
|
|
|
2023-06-24 09:41:52 +00:00
|
|
|
void DirectivesGroup::applyExistingImage(Image& image) const {
|
2023-06-25 15:42:18 +00:00
|
|
|
forEach([&](auto const& entry, Directives const& directives) {
|
2023-06-26 17:38:57 +00:00
|
|
|
ImageOperation const& operation = entry.loadOperation(*directives.shared);
|
|
|
|
if (auto error = operation.ptr<ErrorImageOperation>())
|
2023-06-25 04:00:20 +00:00
|
|
|
std::rethrow_exception(error->exception);
|
|
|
|
else
|
2023-06-26 17:38:57 +00:00
|
|
|
processImageOperation(operation, image);
|
2023-06-24 09:41:52 +00:00
|
|
|
});
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2023-06-26 18:48:27 +00:00
|
|
|
size_t DirectivesGroup::hash() const {
|
2023-06-24 09:41:52 +00:00
|
|
|
XXHash3 hasher;
|
2023-06-25 15:42:18 +00:00
|
|
|
for (auto& directives : m_directives) {
|
|
|
|
size_t hash = directives.hash();
|
|
|
|
hasher.push((const char*)&hash, sizeof(hash));
|
|
|
|
}
|
2023-06-24 09:41:52 +00:00
|
|
|
|
|
|
|
return hasher.digest();
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
2023-06-25 08:12:54 +00:00
|
|
|
const List<Directives>& DirectivesGroup::list() const {
|
|
|
|
return m_directives;
|
|
|
|
}
|
|
|
|
|
2023-06-24 10:10:53 +00:00
|
|
|
bool operator==(DirectivesGroup const& a, DirectivesGroup const& b) {
|
|
|
|
return a.compare(b);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator!=(DirectivesGroup const& a, DirectivesGroup const& b) {
|
|
|
|
return !a.compare(b);
|
|
|
|
}
|
|
|
|
|
2023-06-25 08:12:54 +00:00
|
|
|
DataStream& operator>>(DataStream& ds, DirectivesGroup& directivesGroup) {
|
|
|
|
String string;
|
|
|
|
ds.read(string);
|
|
|
|
|
2023-06-25 15:42:18 +00:00
|
|
|
directivesGroup = DirectivesGroup(move(string));
|
2023-06-25 08:12:54 +00:00
|
|
|
|
|
|
|
return ds;
|
|
|
|
}
|
|
|
|
|
|
|
|
DataStream& operator<<(DataStream& ds, DirectivesGroup const& directivesGroup) {
|
|
|
|
ds.write(directivesGroup.toString());
|
|
|
|
|
|
|
|
return ds;
|
|
|
|
}
|
|
|
|
|
2023-06-24 10:10:53 +00:00
|
|
|
size_t hash<DirectivesGroup>::operator()(DirectivesGroup const& s) const {
|
2023-06-24 09:41:52 +00:00
|
|
|
return s.hash();
|
2023-06-23 15:30:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|