Faster conversion of sbufs, vectors and byte-vectors to their corresponding fixed...

diff --git a/core/arrays/arrays.factor b/core/arrays/arrays.factor
index 74bc57e9db80c80940e44df38831ffffdfac3e8a..157ac013e3308b0ad384290e5e2b12083906050a 100644 (file)
--- a/core/arrays/arrays.factor
+++ b/core/arrays/arrays.factor
@@ -16,8 +16,6 @@ M: object new-sequence drop f <array> ;
 
 M: f new-sequence drop dup zero? [ drop f ] [ f <array> ] if ;
 
-M: array like drop dup array? [ >array ] unless ;
-
 M: array equal?
     over array? [ sequence= ] [ 2drop f ] if ;
 

diff --git a/core/byte-arrays/byte-arrays.factor b/core/byte-arrays/byte-arrays.factor
index 50ea4b32ba3cf9f106c45eb5b88adbaa7fe3b2c1..f981e758d79e3bd3c76613a74405033c9df3ca8b 100644 (file)
--- a/core/byte-arrays/byte-arrays.factor
+++ b/core/byte-arrays/byte-arrays.factor
@@ -9,7 +9,6 @@ M: byte-array length length>> ;
 M: byte-array nth-unsafe swap >fixnum alien-unsigned-1 ;
 M: byte-array set-nth-unsafe swap >fixnum set-alien-unsigned-1 ;
 : >byte-array ( seq -- byte-array ) B{ } clone-like ; inline
-M: byte-array like drop dup byte-array? [ >byte-array ] unless ;
 M: byte-array new-sequence drop <byte-array> ;
 
 M: byte-array equal?

diff --git a/core/byte-vectors/byte-vectors.factor b/core/byte-vectors/byte-vectors.factor
index 5d337cb028992afcd0e09d46863437cc8ba4b8b0..6938d02b2f0d79b1c5483a867589110052529889 100644 (file)
--- a/core/byte-vectors/byte-vectors.factor
+++ b/core/byte-vectors/byte-vectors.factor
@@ -1,7 +1,7 @@
 ! Copyright (C) 2008 Slava Pestov.\r
 ! See http://factorcode.org/license.txt for BSD license.\r
 USING: arrays kernel kernel.private math sequences\r
-sequences.private growable byte-arrays ;\r
+sequences.private growable byte-arrays accessors ;\r
 IN: byte-vectors\r
 \r
 TUPLE: byte-vector\r
@@ -26,6 +26,19 @@ M: byte-vector new-sequence
 M: byte-vector equal?\r
     over byte-vector? [ sequence= ] [ 2drop f ] if ;\r
 \r
+M: byte-array like\r
+    #! If we have an byte-array, we're done.\r
+    #! If we have a byte-vector, and it's at full capacity,\r
+    #! we're done. Otherwise, call resize-byte-array, which is a\r
+    #! relatively fast primitive.\r
+    drop dup byte-array? [\r
+        dup byte-vector? [\r
+            [ length ] [ underlying>> ] bi\r
+            2dup length eq?\r
+            [ nip ] [ resize-byte-array ] if\r
+        ] [ >byte-array ] if\r
+    ] unless ;\r
+\r
 M: byte-array new-resizable drop <byte-vector> ;\r
 \r
 INSTANCE: byte-vector growable\r

diff --git a/core/sbufs/sbufs.factor b/core/sbufs/sbufs.factor
index 5a30654f03677a00c34a14ea3b6d97c9a01a0c62..5590432ef4ca3908facee7aadd6fb31fcb704b26 100644 (file)
--- a/core/sbufs/sbufs.factor
+++ b/core/sbufs/sbufs.factor
@@ -31,16 +31,16 @@ M: sbuf equal?
 M: string new-resizable drop <sbuf> ;
 
 M: string like
+    #! If we have a string, we're done.
+    #! If we have an sbuf, and it's at full capacity, we're done.
+    #! Otherwise, call resize-string, which is a relatively
+    #! fast primitive.
     drop dup string? [
         dup sbuf? [
-            dup length over underlying>> length eq? [
-                underlying>> dup reset-string-hashcode
-            ] [
-                >string
-            ] if
-        ] [
-            >string
-        ] if
+            [ length ] [ underlying>> ] bi
+            2dup length eq?
+            [ nip dup reset-string-hashcode ] [ resize-string ] if
+        ] [ >string ] if
     ] unless ;
 
 INSTANCE: sbuf growable

diff --git a/core/vectors/vectors.factor b/core/vectors/vectors.factor
index dab30f306f2c41eecd967d170671db6cc647d24f..b4cade44db6d0e2ac567251e6c5bce27ab38ce62 100644 (file)
--- a/core/vectors/vectors.factor
+++ b/core/vectors/vectors.factor
@@ -1,6 +1,7 @@
 ! Copyright (C) 2004, 2008 Slava Pestov.
 ! See http://factorcode.org/license.txt for BSD license.
-USING: arrays kernel math sequences sequences.private growable ;
+USING: arrays kernel math sequences sequences.private growable
+accessors ;
 IN: vectors
 
 TUPLE: vector
@@ -22,6 +23,19 @@ M: vector new-sequence
 M: vector equal?
     over vector? [ sequence= ] [ 2drop f ] if ;
 
+M: array like
+    #! If we have an array, we're done.
+    #! If we have a vector, and it's at full capacity, we're done.
+    #! Otherwise, call resize-array, which is a relatively
+    #! fast primitive.
+    drop dup array? [
+        dup vector? [
+            [ length ] [ underlying>> ] bi
+            2dup length eq?
+            [ nip ] [ resize-array ] if
+        ] [ >array ] if
+    ] unless ;
+
 M: sequence new-resizable drop <vector> ;
 
 INSTANCE: vector growable