Changeset 2514

Timestamp:

03/03/10 19:52:08 (6 months ago)

Author:

drobilla

Message:

Remove Raul::Path::root, Raul::Path::prefix, and Raul:Path::scheme from public API.
Add ability to modify root path from application code (before any paths are created).

Location:

trunk

Files:

• ingen/src/client/ClientStore.cpp (modified) (1 diff)
• ingen/src/client/ObjectModel.cpp (modified) (1 diff)
• ingen/src/engine/events/RequestMetadata.cpp (modified) (1 diff)
• ingen/src/engine/events/SetMetadata.cpp (modified) (1 diff)
• ingen/src/engine/GraphObjectImpl.cpp (modified) (1 diff)
• ingen/src/engine/HTTPEngineReceiver.cpp (modified) (1 diff)
• ingen/src/serialisation/Parser.cpp (modified) (1 diff)
• ingen/src/shared/ClashAvoider.cpp (modified) (1 diff)
• raul/raul/Path.hpp (modified) (10 diffs)
• raul/src/Path.cpp (modified) (3 diffs)
• raul/wscript (modified) (2 diffs)

trunk/ingen/src/client/ClientStore.cpp

@@ -178 +178 @@
 ClientStore::resource(const URI& uri)
 {
-        if (uri.scheme() == Path::scheme && Path::is_valid(uri.str()))
+        if (Path::is_path(uri))
                 return object(uri.str());
         else

trunk/ingen/src/client/ObjectModel.cpp

@@ -32 +32 @@
         , _meta(ResourceImpl::meta_uri(path))
         , _path(path)
-        , _symbol((path == Path::root) ? "root" : path.symbol())
+        , _symbol((path == Path::root()) ? "root" : path.symbol())
 {
 }

trunk/ingen/src/engine/events/RequestMetadata.cpp

@@ -60 +60 @@
 RequestMetadata::pre_process()
 {
-        const bool is_object = (_uri.scheme() == Path::scheme && Path::is_valid(_uri.str()));
+        const bool is_object = Path::is_path(_uri);
         if (_request->client()) {
                 if (is_object)

trunk/ingen/src/engine/events/SetMetadata.cpp

@@ -100 +100 @@
         typedef Properties::const_iterator iterator;
 
-        bool is_graph_object = (_subject.scheme() == Path::scheme && Path::is_valid(_subject.str()));
+        const bool is_graph_object = Path::is_path(_subject);
 
         _object = is_graph_object

trunk/ingen/src/engine/GraphObjectImpl.cpp

@@ -30 +30 @@
 
 GraphObjectImpl::GraphObjectImpl(GraphObjectImpl* parent, const Symbol& symbol)
-        : ResourceImpl(parent ? parent->path().child(symbol) : Raul::Path::root.child(symbol))
+        : ResourceImpl(parent ? parent->path().child(symbol) : Raul::Path::root())
         , _parent(parent)
         , _path(parent ? parent->path().child(symbol) : "/")

trunk/ingen/src/engine/HTTPEngineReceiver.cpp

@@ -118 +118 @@
         // Special GET paths
         if (msg->method == SOUP_METHOD_GET) {
-                if (path == Path::root.str() || path.empty()) {
+                if (path == Path::root().str() || path.empty()) {
                         const string r = string("@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n")
                                 .append("\n<> rdfs:seeAlso <plugins> ;")

trunk/ingen/src/serialisation/Parser.cpp

@@ -300 +300 @@
                         if (URI::is_valid(subject_str)) {
                                 if (subject == document_uri)
-                                        subject_str = Path::root.str();
+                                        subject_str = Path::root().str();
                                 parse_properties(world, target, model, subject, subject_str);
                         }

trunk/ingen/src/shared/ClashAvoider.cpp

@@ -32 +32 @@
 ClashAvoider::map_uri(const Raul::URI& in)
 {
-        if (in.scheme() == Path::scheme && Path::is_valid(in.str()))
+        if (Path::is_path(in))
                 return map_path(in.str());
         else

trunk/raul/raul/Path.hpp

@@ -33 +33 @@
 /** A URI which is a path (for example a filesystem or OSC path).
  *
- * A Path always has the special URI scheme "path:".
- *
  * This enforces that a Path is a valid path, where each fragment is a valid
  * Symbol, separated by exactly one slash (/).
@@ -40 +38 @@
  * A path is divided by slashes (/).  The first character MUST be a slash, and
  * the last character MUST NOT be a slash (except in the special case of the
- * root path "/", which is the only valid single-character path).  The path:
- * scheme is added automatically (since a Patch is actually a URI).
+ * root path "/", which is the only valid single-character path).  A Path
+ * is actually a URI, the relative path is appended to the root URI
+ * automatically, so a Patch can always be used as a URI.
  *
  * \ingroup raul
@@ -56 +55 @@
         };
 
-        static const std::string scheme;
-        static const std::string prefix;
-        static const size_t      prefix_len;
-        static const Path        root;
+        /** Return the root path.
+         * The default root path is the URI "path:/"
+         *
+         * A Path is either the root path, or a child of a root path (i.e. the root
+         * path followed by a sequence of Symbols separated by '/')
+         */
+        static const Path root();
+
+        /** Set the root path.
+         * The default root path is the URI "path:/"
+         *
+         * Note this should be done on application start up.  Changing the root
+         * path while any Path objects exist will break things horribly; don't!
+         *
+         * The root can be set to any URI, there are no restrictions on valid
+         * characters and such like there are for relative paths (but it must be
+         * a valid URI, i.e. begin with a scheme, and in particular not begin
+         * with '/').  Relative paths are appended to the root path's URI,
+         * i.e. every Path, as a string, begins with the root URI.  The part after
+         * that is a strict path (a sequence of Symbols separated by '/').
+         */
+        static void set_root(const Raul::URI& uri);
+
+        static bool is_path(const Raul::URI& uri);
 
         /** Construct an uninitialzed path, because the STL is annoying. */
-        Path() : URI(root) {}
+        Path() : URI(root()) {}
 
         /** Construct a Path from an std::string.
@@ -69 +88 @@
          * use is_valid first to check.
          */
-        Path(const std::basic_string<char>& path)
-                : URI((path.find(":") == std::string::npos) ? prefix + path : path)
-        {
-                if (!is_valid(str()))
-                        throw BadPath(str());
-        }
+        Path(const std::basic_string<char>& path);
 
         /** Construct a Path from a C string.
@@ -81 +95 @@
          * use is_valid first to check.
          */
-        Path(const char* cpath)
-                : URI((std::string(cpath).find(":") == std::string::npos) ? prefix + cpath : cpath)
-        {
-                if (!is_valid(str()))
-                        throw BadPath(str());
-        }
+        Path(const char* cpath);
+
+
+        /** Construct a Path from another path.
+         *
+         * This is faster than constructing a path from the other path's string
+         * representation, since validity checking is avoided.
+         */
+        Path(const Path& copy) : URI(copy) {}
 
         static bool is_valid(const std::basic_string<char>& path);
@@ -100 +117 @@
         static void replace_invalid_chars(std::string& str, size_t start, bool replace_slash = false);
 
-        bool is_root() const { return (*this) == root; }
+        bool is_root() const { return (*this) == root(); }
 
         bool is_child_of(const Path& parent) const;
@@ -124 +141 @@
          */
         inline const char* symbol() const {
-                if ((*this) != root) {
+                if ((*this) != root()) {
                         const char* last_slash = strrchr(c_str(), '/');
                         if (last_slash) {
@@ -139 +156 @@
          */
         inline Path parent() const {
-                if ((*this) == root) {
+                if ((*this) == root()) {
                         return *this;
                 } else {
                         const std::string str(this->str());
-                        const size_t last_slash = str.find_last_of('/');
-                        return (last_slash == prefix_len) ? root : str.substr(0, last_slash);
+                        const size_t first_slash = str.find('/');
+                        const size_t last_slash  = str.find_last_of('/');
+                        return (first_slash == last_slash) ? root() : str.substr(0, last_slash);
                 }
         }
@@ -175 +193 @@
         inline const std::string base() const {
                 std::string ret = str();
-                if ((*this) == root && ret[ret.length() - 1] == '/')
+                if ((*this) == root() && ret[ret.length() - 1] == '/')
                         return ret;
                 else
@@ -195 +213 @@
                 return ( child == parent || (child.length() > parent.length() &&
                                 (!std::strncmp(parent.c_str(), child.c_str(), parent.length())
-                                                && (parent == root || child.str()[parent.length()] == '/'))) );
-        }
+                                                && (parent == root() || child.str()[parent.length()] == '/'))) );
+        }
+
+private:
+        inline Path(bool unchecked, const URI& uri) : URI(uri) {}
 };
 

trunk/raul/src/Path.cpp

@@ -22 +22 @@
 namespace Raul {
 
-const string Path::scheme     = "path";
-const string Path::prefix     = Path::scheme + ":";
-const size_t Path::prefix_len = prefix.length();
-const Path   Path::root   = Path::prefix + "/";
+static URI root_uri("path:/");
+
+const Path Path::root()                         { return Path(true, root_uri); }
+void       Path::set_root(const Raul::URI& uri) { root_uri = uri.str(); }
+
+bool
+Path::is_path(const Raul::URI& uri)
+{
+        return uri.length() >= root_uri.length()
+                        && uri.substr(0, root_uri.length()) == root_uri.str()
+                        && Path::is_valid(uri.str());
+}
+
+
+Path::Path(const std::basic_string<char>& path)
+        : URI(path[0] == '/' ? root_uri.str() + path.substr(1) : path)
+{
+        if (!is_valid(str()))
+                throw BadPath(str());
+}
+
+
+Path::Path(const char* cpath)
+        : URI(cpath[0] == '/' ? root_uri.str() + (cpath + 1) : cpath)
+{
+        if (!is_valid(str()))
+                throw BadPath(str());
+}
+
 
 bool
 Path::is_valid(const std::basic_string<char>& path_str)
 {
-        const size_t colon = path_str.find(":");
-        const string path = (colon == string::npos) ? path_str : path_str.substr(colon + 1);
-
-        if (path.length() == 0)
-                return false;
+        if (path_str.length() == 0)
+                return false;
+
+        if (path_str == root_uri.str())
+                return true;
+
+        if (path_str[0] != '/' &&
+                        (path_str.length() < root_uri.length()
+                                || path_str.substr(0, root_uri.length()) != root_uri.str()))
+                return false;
+
+        const string path = (path_str[0] == '/')
+                        ? path_str
+                        : path_str.substr(root_uri.length() - 1);
 
         // Must start with a /
@@ -67 +101 @@
 /** Convert a string to a valid full path.
  *
- * This will make a best effort at turning @a str into a complete, valid
- * Path, and will always return one.
+ * The returned string is a valid relative path without the root prefix,
+ * i.e. the returned string starts with '/' followed by valid symbols,
+ * each separated by '/'.
  */
 string
@@ -74 +109 @@
 {
         if (str.length() == 0)
-                return root.str(); // this might not be wise?
-
-        string path  = (str.substr(0, prefix_len) == prefix) ? str : prefix + str;
-        size_t start = prefix_len + 1;
+                return root().chop_scheme(); // this might not be wise?
+
+        const size_t first_slash = str.find('/');
+        string path = (first_slash == string::npos)
+                        ? string("/").append(str)
+                        : str.substr(first_slash);
 
         // Must start with a /
-        if (path.at(start) != '/')
+        if (path.empty() || path[0] != '/')
                 path = string("/").append(path);
 
         // Must not end with a slash unless "/"
-        if (path.length() > prefix_len + 1 && path.at(path.length()-1) == '/')
-                path = path.substr(0, path.length()-1); // chop trailing slash
-
-        assert(path.find_last_of("/") != string::npos);
-
-        replace_invalid_chars(path, start, false);
+        if (path != "/" && path[path.length() - 1] == '/')
+                path = path.substr(0, path.length() - 1); // chop trailing slash
+
+        assert(path.find_last_of('/') != string::npos);
+
+        replace_invalid_chars(path, 0, false);
 
         assert(is_valid(path));

trunk/raul/wscript

@@ -5 +5 @@
 
 # Version of this package (even if built as a child)
-RAUL_VERSION = '0.6.4'
+RAUL_VERSION = '0.6.5'
 
 # Library version (UNIX style major, minor, micro)
@@ -20 +20 @@
 #   0.6.3 = 6,0,0 (unreleased)
 #   0.6.4 = 7,0,0 (unreleased)
-RAUL_LIB_VERSION = '7.0.0'
+#   0.6.5 = 8,0,0 (unreleased)
+RAUL_LIB_VERSION = '8.0.0'
 
 # Variables for 'waf dist'