path.hpp

#pragma once
#include <ossia/detail/optional.hpp>
#include <ossia/detail/regex_fwd.hpp>
#include <ossia/network/base/address_scope.hpp>
#include <ossia/network/base/name_validation.hpp>
 
#include <smallfun.hpp>
 
#include <iosfwd>
#include <string>
 
namespace ossia
{
namespace net
{
 
class node_base;
}
namespace regex_path
{
struct OSSIA_EXPORT path_element
{
  std::string address;
  path_element(std::string s)
      : address{std::move(s)}
  {
  }
 
  template <int N>
  path_element(const char (&s)[N])
      : address(s, N - 1)
  {
  }
 
  operator std::string() const { return address; }
};
 
OSSIA_EXPORT
std::ostream& operator<<(std::ostream& s, const path_element& p);
 
struct OSSIA_EXPORT device : public path_element
{
  explicit device(std::string s)
      : path_element{"^" + std::move(s) + ":"}
  {
  }
};
 
struct OSSIA_EXPORT any_instance : public path_element
{
  static std::string instance_regex()
  {
    static const auto str
        = "(\\.[" + std::string(ossia::net::name_characters_no_instance()) + "]+)?";
    return str;
  }
  explicit any_instance(std::string s)
      : path_element{std::move(s) + instance_regex()}
  {
  }
};
 
struct OSSIA_EXPORT any_between : public path_element
{
  any_between(std::string s)
      : path_element{std::move(s)}
  {
  }
 
  any_between(std::initializer_list<std::string> args)
      : path_element{""}
  {
    const auto N = args.size();
    if(N > 0)
    {
      address += '(';
 
      auto it = args.begin();
      address += *it;
 
      for(std::size_t i = 1; i < N; i++)
      {
        ++it;
        address += '|';
        address += *it;
      }
 
      address += ')';
    }
  }
};
 
struct OSSIA_EXPORT any_node
{
};
 
struct OSSIA_EXPORT any_path
{
};
 
struct OSSIA_EXPORT stop
{
};
 
inline path_element operator/(const path_element& lhs, const path_element& rhs)
{
  return path_element{lhs.address + "\\/" + rhs.address};
}
 
inline path_element operator/(const path_element& lhs, const any_instance& rhs)
{
  return path_element{lhs.address + "\\/" + rhs.address};
}
 
inline path_element operator/(const path_element& lhs, const any_node&)
{
  return path_element{
      lhs.address + "\\/[" + std::string(ossia::net::name_characters()) + "]*"};
}
 
inline path_element operator/(const path_element& lhs, const any_path&)
{
  return path_element{
      lhs.address + "(\\/[" + std::string(ossia::net::name_characters()) + "]*)+"};
}
 
inline path_element operator/(const any_path&, const path_element& rhs)
{
  const std::string sub = std::string(ossia::net::name_characters());
  std::string sub2 = "^([";
  sub2 += sub;
  sub2 += "]*:)(\\/?[";
  sub2 += sub;
  sub2 += "]*)+\\/";
  sub2 += rhs.address;
  return path_element{std::move(sub2)};
}
 
inline path_element operator/(const path_element& lhs, const stop& rhs)
{
  return path_element{lhs.address + "$"};
}
}
 
namespace traversal
{
struct OSSIA_EXPORT path
{
  // Used for hashing
  std::string pattern;
  ossia::net::address_scope scope;
 
  using child_function = smallfun::function<
      void(std::vector<ossia::net::node_base*>&), sizeof_regex + sizeof(void*)>;
  std::vector<child_function> child_functions;
 
  friend bool operator==(const path& lhs, const path& rhs)
  {
    return lhs.pattern == rhs.pattern;
  }
  friend bool operator!=(const path& lhs, const path& rhs)
  {
    return lhs.pattern != rhs.pattern;
  }
};
 
OSSIA_EXPORT bool is_pattern(std::string_view address);
 
OSSIA_EXPORT std::optional<path> make_path(std::string_view address);
 
OSSIA_EXPORT void apply(const path& p, std::vector<ossia::net::node_base*>& nodes);
 
OSSIA_EXPORT bool match(const path& p, const ossia::net::node_base& node);
 
OSSIA_EXPORT bool
match(const path& p, const ossia::net::node_base& node, ossia::net::node_base& root);
 
OSSIA_EXPORT std::string substitute_characters(const std::string& path);
 
OSSIA_EXPORT bool match(std::string_view address, const regex_path::path_element& e);
 
}
}
 
namespace std
{
template <>
struct hash<ossia::traversal::path>
{
  std::size_t operator()(const ossia::traversal::path& p) const
  {
    return std::hash<std::string>{}(p.pattern);
  }
};
}