This is overkill

source/core/StarAssetPath.cpp

@@ -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) {

source/core/StarAssetPath.hpp

@@ -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;

source/core/StarDirectives.cpp

@@ -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()) {
+    if (!op.empty())
-      leaf.operations.append(imageOperationFromString(op));
+      leaf.entries.emplace_back(imageOperationFromString(op), op);
-      leaf.strings.append(move(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 (auto& entry : leaf.entries)
-      for (size_t i = 0; i != length; ++i)
+        callback(entry.operation, entry.string);
-        callback(leaf.operations.at(i), leaf.strings.at(i));
     };
     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 (auto& entry : leaf.entries) {
-      for (size_t i = 0; i != length; ++i) {
+        if (!callback(entry.operation, entry.string))
-        if (!callback(leaf.operations.at(i), leaf.strings.at(i)))
           return false;
       }
 
@@ -85,8 +95,8 @@ bool NestedDirectives::forEachPairAbortable(AbortableLeafPairCallback callback)
 
 Image NestedDirectives::apply(Image& image) const {
   Image current = image;
-  forEach([&](Leaf const& leaf) {
+  forEachPair([&](ImageOperation const& operation, String const& string) {
-    current = processImageOperations(leaf.operations, current);
+    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 {
+bool NestedDirectives::Leaf::Entry::operator==(NestedDirectives::Leaf::Entry const& other) const {
-  if (operations.size() != strings.size())
+  return string == other.string;
-    throw DirectivesException("NestedDirectives leaf has mismatching operation/string List sizes");
+}
 
-  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>())

source/core/StarDirectives.hpp

@@ -12,10 +12,19 @@ STAR_EXCEPTION(DirectivesException, StarException);
 class NestedDirectives {
 public:
   struct Leaf {
-    List<ImageOperation> operations;
+    struct Entry {
-    List<String> strings;
+      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;
 

source/core/StarImageProcessing.cpp

@@ -328,12 +328,23 @@ String imageOperationToString(ImageOperation const& operation) {
   return "";
 }
 
-List<ImageOperation> parseImageOperations(String const& params) {
+void parseImageOperations(String const& params, function<void(ImageOperation&&)> outputter) {
-  List<ImageOperation> operations;
   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) {
+void processImageOperation(ImageOperation const& operation, Image& image, ImageReferenceCallback refCallback) {
-  for (auto const& operation : operations) {
   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;
 }

source/core/StarImageProcessing.hpp

@@ -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 = {});
 
 }