Changeset 493

Timestamp:

11/18/07 19:51:21 (1 year ago)

Author:

andrei

Message:

Made std.string.munch more general and added function chompPrefix

Files:

• candidate/phobos/std/string.d (modified) (4 diffs)

candidate/phobos/std/string.d

@@ -40 +40 @@
-private import std.ctype;
-private import std.stdarg;
-
+, std.typetuple, std.conv, std.traits
-
-extern (C)
@@ -1540 +1540 @@
-}
-
+/**
+ * Returns $(D_PARAM true) if and only if the array $(D_PARAM longer)
+ * starts with array $(D_PARAM shorter).
+ */
+bool startsWith(A1, A2)(A1 longer, A2 shorter)
+{
+    static if (is(typeof(longer[0 .. shorter.length] == shorter)))
+    {
+        // the easy way: arrays, directly comparable
+        return longer.length >= shorter.length &&
+            longer[0 .. shorter.length] == shorter;
+    }
+    else
+    {
+        // different element types, etc.
+        static if (isSomeString!(A1) && isSomeString!(A2))
+        {
+            // UTF-informed comparison
+            // find the largest character of the two
+            static if (longer[0].sizeof > shorter[0].sizeof)
+            {
+                alias typeof(longer[0]) Char;
+                if (shorter.length / Char.sizeof > longer.length) return false;
+                size_t i = 0;
+                foreach (Char c; shorter)
+                {
+                    if (i == longer.length || longer[i] != c) return false;
+                    ++i;
+                }
+            }
+            else
+            {
+                static assert(longer[0].sizeof < shorter[0].sizeof,
+                    "Looks like there's a bug in the compiler");
+                alias typeof(shorter[0]) Char;
+                if (shorter.length > longer.length) return false;
+                size_t i = 0;
+                foreach (Char c; longer)
+                {
+                    if (i == shorter.length) return true;
+                    if (shorter[i] != c) return false;
+                    ++i;
+                }
+            }
+        }
+        else
+        {
+            // raw element-by-element comparison
+            if (longer.length < shorter.length) return false;
+            foreach (i, e; shorter)
+            {
+                if (longer[i] != e) return false;
+            }
+        }
+    }
+    return true;
+}
+
+unittest
+{
+    alias TypeTuple!(string, wstring, dstring, char[], wchar[], dchar[])
+        StringTypes;
+    alias TypeTuple!(ubyte[], int[], double[]) OtherTypes;
+    foreach (T1 ; StringTypes)
+    {
+        foreach (T2 ; StringTypes)
+        {
+            foreach (T3 ; OtherTypes)
+            {
+                auto a = to!(T1)("abcde"), b = to!(T2)("abcdefgh"),
+                    c = to!(T2)("");
+                auto d = to!(T3)([2, 3]);
+                assert(startsWith(b, a));
+                assert(!startsWith(a, b));
+                assert(startsWith(b, c));
+                assert(startsWith(a, c));
+                assert(!startsWith(c, b));
+                assert(!startsWith(c, a));
+                assert(!startsWith(a, d));
+                assert(!startsWith(d, a));
+                assert(!startsWith(b, d));
+                assert(!startsWith(d, b));
+                assert(!startsWith(c, d));
+                assert(startsWith(d, c));
+            }
+        }
+    }
+}
+
+/**
+ * Returns $(D_PARAM true) if and only if the array $(D_PARAM longer)
+ * ends with array $(D_PARAM shorter).
+ */
+bool endsWith(A1, A2)(A1 longer, A2 shorter)
+{
+    static if (is(typeof(longer[$ - shorter.length .. $] == shorter)))
+    {
+        // the easy way: arrays, directly comparable
+        return longer.length >= shorter.length &&
+            longer[$ - shorter.length .. $] == shorter;
+    }
+    else
+    {
+        // different element types, etc.
+        static if (isSomeString!(A1) && isSomeString!(A2))
+        {
+            // UTF-informed comparison
+            // find the largest character of the two
+            static if (longer[0].sizeof > shorter[0].sizeof)
+            {
+                alias typeof(longer[0]) Char;
+                if (shorter.length > longer.length * Char.sizeof) return false;
+                size_t i = longer.length - 1;
+                foreach_reverse (Char c; shorter)
+                {
+                    if (i == 0 || longer[i] != c) return false;
+                    --i;
+                }
+            }
+            else
+            {
+                static assert(longer[0].sizeof < shorter[0].sizeof,
+                    "Looks like there's a bug in the compiler");
+                alias typeof(shorter[0]) Char;
+                if (shorter.length > longer.length) return false;
+                if (!shorter.length) return true;
+                size_t i = shorter.length - 1;
+                foreach_reverse (Char c; longer)
+                {
+                    if (i == 0) return true;
+                    if (shorter[i] != c) return false;
+                    --i;
+                }
+            }
+        }
+        else
+        {
+            // raw element-by-element comparison
+            if (longer.length < shorter.length) return false;
+            foreach (i, e; longer[$ - shorter.length .. $])
+            {
+                if (longer[i] != e) return false;
+            }
+        }
+    }
+    return true;
+}
+
+unittest
+{
+    alias TypeTuple!(string, wstring, dstring, char[], wchar[], dchar[])
+        TestTypes;
+    alias TypeTuple!(ubyte[], int[], double[]) OtherTypes;
+    foreach (T1 ; TestTypes)
+    {
+        foreach (T2 ; TestTypes)
+        {
+            foreach (T3 ; OtherTypes)
+            {
+                auto a = to!(T1)("efgh"), b = to!(T2)("abcdefgh"),
+                    c = to!(T2)(""), d = to!(T3)([1, 2]);
+                assert(endsWith(b, a));
+                assert(!endsWith(a, b));
+                assert(endsWith(b, c));
+                assert(endsWith(a, c));
+                assert(!endsWith(c, b));
+                assert(!endsWith(c, a));
+                assert(!endsWith(a, d));
+                assert(!endsWith(d, a));
+                assert(!endsWith(b, d));
+                assert(!endsWith(d, b));
+                assert(!endsWith(c, d));
+                assert(endsWith(d, c));
+            }
+        }
+    }
+}
+
-/*******************************************
- * Returns s[] sans trailing delimiter[], if any.
@@ -1609 +1787 @@
-}
-
+/**
+ * If $(D_PARAM longer.startsWith(shorter)), returns $(D_PARAM
+ * longer[shorter.length .. $]). Otherwise, returns $(D_PARAM longer).
+ */
+
+C1[] chompPrefix(C1, C2)(C1[] longer, C2[] shorter)
+{
+    return startsWith(longer, shorter) ? longer[shorter.length .. $]
+        : longer;
+}
+
+unittest
+{
+    auto a = "abcde", b = "abcdefgh";
+    assert(chompPrefix(b, a) == "fgh");
+    assert(chompPrefix(a, b) == "abcde");
+}
-
-/***********************************************
@@ -3019 +3214 @@
- */
-
- munch(S)(ref S s, S
+1 munch(S1, S2)(ref S1 s, S2
-{
-    size_t j = s.length;