lib/file: revamp `poll_in` to use in `FileReader`

[nit.git] / lib / standard / bytes.nit

diff --git a/lib/standard/bytes.nit b/lib/standard/bytes.nit
index b300298..9843ddc 100644 (file)
--- a/lib/standard/bytes.nit
+++ b/lib/standard/bytes.nit
@@ -17,21 +17,19 @@ module bytes
 
 import kernel
 import collection::array
-intrude import string
+intrude import text::flat
 
 # A buffer containing Byte-manipulation facilities
 #
 # Uses Copy-On-Write when persisted
-#
-# TODO: Change the bound to Byte when available in stdlib and bootstrap
 class Bytes
-       super AbstractArray[Int]
+       super AbstractArray[Byte]
 
        # A NativeString being a char*, it can be used as underlying representation here.
        private var items: NativeString
 
        # Number of bytes in the array
-       redef var length: Int
+       redef var length
 
        # Capacity of the array
        private var capacity: Int
@@ -48,6 +46,7 @@ class Bytes
                init(ns, 0, 0)
        end
 
+       # Init a `Bytes` with capacity `cap`
        init with_capacity(cap: Int) do
                var ns = new NativeString(cap)
                init(ns, 0, cap)
@@ -56,41 +55,41 @@ class Bytes
        redef fun is_empty do return length != 0
 
        #     var b = new Bytes.empty
-       #     b.add 101
-       #     assert b[0] == 101
-       redef fun [](i: Int): Int do
+       #     b.add 101u8
+       #     assert b[0] == 101u8
+       redef fun [](i) do
                assert i >= 0
                assert i < length
-               return items[i].ascii
+               return items[i]
        end
 
        #     var b = new Bytes.with_capacity(1)
-       #     b[0] = 101
+       #     b[0] = 101u8
        #     assert b.to_s == "e"
-       redef fun []=(i: Int, v: Int) do
+       redef fun []=(i, v) do
                if persisted then regen
                assert i >= 0
                assert i <= length
                if i == length then add(v)
-               items[i] = v.ascii
+               items[i] = v
        end
 
        #     var b = new Bytes.empty
-       #     b.add 101
+       #     b.add 101u8
        #     assert b.to_s == "e"
-       redef fun add(c: Int) do
+       redef fun add(c) do
                if persisted then regen
                if length >= capacity then
                        enlarge(length)
                end
-               items[length] = c.ascii
+               items[length] = c
                length += 1
        end
 
        #     var b = new Bytes.empty
-       #     b.append([104, 101, 108, 108, 111])
+       #     b.append([104u8, 101u8, 108u8, 108u8, 111u8])
        #     assert b.to_s == "hello"
-       redef fun append(arr: Collection[Int]) do
+       redef fun append(arr) do
                if arr isa Bytes then
                        append_ns(arr.items, arr.length)
                else
@@ -98,6 +97,16 @@ class Bytes
                end
        end
 
+       #     var b = new Bytes.empty
+       #     b.append([0x41u8, 0x41u8, 0x18u8])
+       #     b.pop
+       #     assert b.to_s == "AA"
+       redef fun pop do
+               assert length >= 1
+               length -= 1
+               return items[length]
+       end
+
        redef fun clear do length = 0
 
        # Regenerates the buffer, necessary when it was persisted
@@ -143,11 +152,11 @@ class Bytes
 end
 
 private class BytesIterator
-       super IndexedIterator[Int]
+       super IndexedIterator[Byte]
 
        var tgt: NativeString
 
-       redef var index: Int
+       redef var index
 
        var max: Int
 
@@ -157,10 +166,11 @@ private class BytesIterator
 
        redef fun next do index += 1
 
-       redef fun item do return tgt[index].ascii
+       redef fun item do return tgt[index]
 end
 
 redef class NativeString
+       # Creates a new `Bytes` object from `self` with `strlen` as length
        fun to_bytes: Bytes do
                var len = cstring_length
                return new Bytes(self, len, len)