This is overkill

This commit is contained in:
Kae 2023-06-24 13:06:13 +10:00
parent 2798d4bf66
commit 51a9de3af3
6 changed files with 312 additions and 220 deletions

View File

@ -147,6 +147,10 @@ bool AssetPath::operator==(AssetPath const& rhs) const {
return tie(basePath, subPath, directives) == tie(rhs.basePath, rhs.subPath, rhs.directives);
}
AssetPath::AssetPath(String const& path) {
*this = move(AssetPath::split(path)); // split code should probably be in here, but whatever
}
std::ostream& operator<<(std::ostream& os, AssetPath const& rhs) {
os << rhs.basePath;
if (rhs.subPath) {

View File

@ -51,6 +51,9 @@ struct AssetPath {
// sourcePath.
static String relativeTo(String const& sourcePath, String const& givenPath);
AssetPath() = default;
AssetPath(String const& path);
String basePath;
Maybe<String> subPath;
NestedDirectives directives;

View File

@ -1,6 +1,8 @@
#include "StarImage.hpp"
#include "StarImageProcessing.hpp"
#include "StarDirectives.hpp"
#include "StarXXHash.hpp"
#include "StarHash.hpp"
namespace Star {
@ -16,22 +18,32 @@ NestedDirectives::NestedDirectives(String&& directives) {
void NestedDirectives::parseDirectivesIntoLeaf(String const& directives) {
Leaf leaf;
for (String& op : directives.split('?')) {
if (!op.empty()) {
leaf.operations.append(imageOperationFromString(op));
leaf.strings.append(move(op));
}
if (!op.empty())
leaf.entries.emplace_back(imageOperationFromString(op), op);
}
m_root = std::make_shared<Cell>(move(leaf));
}
bool NestedDirectives::empty() const {
inline bool NestedDirectives::empty() const {
return (bool)m_root;
}
void NestedDirectives::append(const NestedDirectives& other) {
inline bool NestedDirectives::compare(NestedDirectives const& other) const {
if (m_root == other.m_root)
return true;
return false;
}
void NestedDirectives::append(NestedDirectives const& other) {
convertToBranches().emplace_back(other.branch());
}
NestedDirectives& NestedDirectives::operator+=(NestedDirectives const& other) {
append(other);
return *this;
}
String NestedDirectives::toString() const {
String string;
addToString(string);
@ -51,9 +63,8 @@ void NestedDirectives::forEach(LeafCallback callback) const {
void NestedDirectives::forEachPair(LeafPairCallback callback) const {
if (m_root) {
LeafCallback pairCallback = [&](Leaf const& leaf) {
size_t length = leaf.length();
for (size_t i = 0; i != length; ++i)
callback(leaf.operations.at(i), leaf.strings.at(i));
for (auto& entry : leaf.entries)
callback(entry.operation, entry.string);
};
m_root->forEach(pairCallback);
}
@ -71,9 +82,8 @@ bool NestedDirectives::forEachPairAbortable(AbortableLeafPairCallback callback)
return false;
else {
AbortableLeafCallback pairCallback = [&](Leaf const& leaf) -> bool {
size_t length = leaf.length();
for (size_t i = 0; i != length; ++i) {
if (!callback(leaf.operations.at(i), leaf.strings.at(i)))
for (auto& entry : leaf.entries) {
if (!callback(entry.operation, entry.string))
return false;
}
@ -85,8 +95,8 @@ bool NestedDirectives::forEachPairAbortable(AbortableLeafPairCallback callback)
Image NestedDirectives::apply(Image& image) const {
Image current = image;
forEach([&](Leaf const& leaf) {
current = processImageOperations(leaf.operations, current);
forEachPair([&](ImageOperation const& operation, String const& string) {
processImageOperation(operation, current);
});
return current;
}
@ -105,11 +115,33 @@ NestedDirectives::Branches& NestedDirectives::convertToBranches() {
return m_root->value.get<Branches>();
}
size_t NestedDirectives::Leaf::length() const {
if (operations.size() != strings.size())
throw DirectivesException("NestedDirectives leaf has mismatching operation/string List sizes");
bool NestedDirectives::Leaf::Entry::operator==(NestedDirectives::Leaf::Entry const& other) const {
return string == other.string;
}
return operations.size();
bool NestedDirectives::Leaf::Entry::operator!=(NestedDirectives::Leaf::Entry const& other) const {
return string != other.string;
}
size_t NestedDirectives::Leaf::length() const {
return entries.size();
}
bool NestedDirectives::Leaf::operator==(NestedDirectives::Leaf const& other) const {
size_t len = length();
if (len != other.length())
return false;
for (size_t i = 0; i != len; ++i) {
if (entries[i] != other.entries[i])
return false;
}
return true;
}
bool NestedDirectives::Leaf::operator!=(NestedDirectives::Leaf const& other) const {
return !(*this == other);
}
NestedDirectives::Cell::Cell() : value(Leaf()) {};
@ -118,11 +150,33 @@ NestedDirectives::Cell::Cell(Branches&& branches) : value(move(branches)) {};
NestedDirectives::Cell::Cell(const Leaf& leaf) : value(leaf) {};
NestedDirectives::Cell::Cell(const Branches& branches) : value(branches) {};
/*
bool NestedDirectives::Cell::operator==(NestedDirectives::Cell const& other) const {
if (auto leaf = value.ptr<Leaf>()) {
if (auto otherLeaf = other.value.ptr<Leaf>())
return *leaf == *otherLeaf;
else {
}
}
else {
for (auto& branch : value.get<Branches>()) {
}
}
}
bool NestedDirectives::Cell::operator!=(NestedDirectives::Cell const& other) const {
return !(*this == other);
}
//*/
void NestedDirectives::Cell::buildString(String& string) const {
if (auto leaf = value.ptr<Leaf>())
for (auto& leafString : leaf->strings) {
for (auto& entry : leaf->entries) {
string += "?";
string += leafString;
string += entry.string;
}
else {
for (auto& branch : value.get<Branches>())

View File

@ -12,10 +12,19 @@ STAR_EXCEPTION(DirectivesException, StarException);
class NestedDirectives {
public:
struct Leaf {
List<ImageOperation> operations;
List<String> strings;
struct Entry {
ImageOperation operation;
String string;
bool operator==(Entry const& other) const;
bool operator!=(Entry const& other) const;
Entry(ImageOperation&& operation, String&& string);
};
List<Entry> entries;
size_t length() const;
bool operator==(NestedDirectives::Leaf const& other) const;
bool operator!=(NestedDirectives::Leaf const& other) const;
};
typedef function<void(Leaf const&)> LeafCallback;
@ -51,7 +60,11 @@ public:
void parseDirectivesIntoLeaf(String const& directives);
bool empty() const;
void append(const NestedDirectives& other);
bool compare(NestedDirectives const& other) const;
void append(NestedDirectives const& other);
NestedDirectives& operator+=(NestedDirectives const& other);
bool operator==(NestedDirectives const& other) const;
bool operator!=(NestedDirectives const& other) const;
const ConstBranch& branch() const;

View File

@ -328,12 +328,23 @@ String imageOperationToString(ImageOperation const& operation) {
return "";
}
List<ImageOperation> parseImageOperations(String const& params) {
List<ImageOperation> operations;
void parseImageOperations(String const& params, function<void(ImageOperation&&)> outputter) {
for (auto const& op : params.split('?')) {
if (!op.empty())
outputter(imageOperationFromString(op));
}
}
List<ImageOperation> parseImageOperations(String const& params) {
auto split = params.split('?');
List<ImageOperation> operations;
operations.reserve(split.size());
for (auto const& op : split) {
if (!op.empty())
operations.append(imageOperationFromString(op));
}
return operations;
}
@ -352,8 +363,7 @@ StringList imageOperationReferences(List<ImageOperation> const& operations) {
return references;
}
Image processImageOperations(List<ImageOperation> const& operations, Image image, ImageReferenceCallback refCallback) {
for (auto const& operation : operations) {
void processImageOperation(ImageOperation const& operation, Image& image, ImageReferenceCallback refCallback) {
if (auto op = operation.ptr<HueShiftImageOperation>()) {
image.forEachPixel([&op](unsigned, unsigned, Vec4B& pixel) {
if (pixel[3] != 0)
@ -561,7 +571,11 @@ Image processImageOperations(List<ImageOperation> const& operations, Image image
}
}
}
}
}
Image processImageOperations(List<ImageOperation> const& operations, Image image, ImageReferenceCallback refCallback) {
for (auto const& operation : operations)
processImageOperation(operation, image, refCallback);
return image;
}

View File

@ -136,6 +136,8 @@ typedef Variant<HueShiftImageOperation, SaturationShiftImageOperation, Brightnes
ImageOperation imageOperationFromString(String const& string);
String imageOperationToString(ImageOperation const& operation);
void parseImageOperations(String const& params, function<void(ImageOperation&&)> outputter);
// Each operation is assumed to be separated by '?', with parameters
// separated by ';' or '='
List<ImageOperation> parseImageOperations(String const& params);
@ -147,6 +149,8 @@ StringList imageOperationReferences(List<ImageOperation> const& operations);
typedef function<Image const*(String const& refName)> ImageReferenceCallback;
void processImageOperation(ImageOperation const& operation, Image& input, ImageReferenceCallback refCallback = {});
Image processImageOperations(List<ImageOperation> const& operations, Image input, ImageReferenceCallback refCallback = {});
}