Add ByteBuffer and related interfaces

src/lib/DataStructures/ByteBuffer.vala

@@ -0,0 +1,12 @@
+
+namespace Invercargill.DataStructures {
+
+    public class ByteBuffer : Buffer<uint8>, ReadOnlyAddressableBytes, AddressableBytes {
+
+        public ByteBuffer(uint size) {
+            base(size);
+        }
+
+    }
+
+}

src/lib/Interfaces/AddressableBytes.vala

@@ -0,0 +1,182 @@
+
+namespace Invercargill {
+
+    [GenericAccessors]
+    public interface AddressableBytes : Addressable<uint8>, ReadOnlyAddressableBytes {
+
+        public virtual void set_int64(uint index, int64 value, Endianness endianness) throws IndexError {
+            var chunk = new uint8[sizeof(int64)];
+            int64 val;
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            }            
+            Memory.copy(chunk, &val, sizeof(int64));
+            set_data(index, chunk);
+        }
+
+        public virtual void set_all_int64(uint index, Enumerable<int64?> values, Endianness endianness) throws IndexError {
+            foreach(var value in values) {
+                set_int64(index, value, endianness);
+            }
+        }
+
+        public virtual void set_uint64(uint index, uint64 value, Endianness endianness) throws IndexError {
+            var chunk = new uint8[sizeof(uint64)];
+            uint64 val;
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            }            
+            Memory.copy(chunk, &val, sizeof(uint64));
+            set_data(index, chunk);
+        }
+
+        public virtual void set_all_uint64(uint index, Enumerable<uint64?> values, Endianness endianness) throws IndexError {
+            foreach(var value in values) {
+                set_uint64(index, value, endianness);
+            }
+        }
+
+        public virtual void set_int32(uint index, int32 value, Endianness endianness) throws IndexError {
+            var chunk = new uint8[sizeof(int32)];
+            int32 val;
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            }            
+            Memory.copy(chunk, &val, sizeof(int32));
+            set_data(index, chunk);
+        }
+
+
+        public virtual void set_all_int32(uint index, Enumerable<int32?> values, Endianness endianness) throws IndexError {
+            foreach(var value in values) {
+                set_int32(index, value, endianness);
+            }
+        }
+
+        public virtual void set_uint32(uint index, uint32 value, Endianness endianness) throws IndexError {
+            var chunk = new uint8[sizeof(uint32)];
+            uint32 val;
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            }            
+            Memory.copy(chunk, &val, sizeof(uint32));
+            set_data(index, chunk);
+        }
+
+        public virtual void set_all_uint32(uint index, Enumerable<uint32?> values, Endianness endianness) throws IndexError {
+            foreach(var value in values) {
+                set_uint32(index, value, endianness);
+            }
+        }
+
+        public virtual void set_int16(uint index, int16 value, Endianness endianness) throws IndexError {
+            var chunk = new uint8[sizeof(int16)];
+            int16 val;
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            }            
+            Memory.copy(chunk, &val, sizeof(int16));
+            set_data(index, chunk);
+        }
+
+        public virtual void set_all_int16(uint index, Enumerable<int16?> values, Endianness endianness) throws IndexError {
+            foreach(var value in values) {
+                set_int16(index, value, endianness);
+            }
+        }
+
+        public virtual void set_uint16(uint index, uint16 value, Endianness endianness) throws IndexError {
+            var chunk = new uint8[sizeof(uint16)];
+            uint16 val;
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            }            
+            Memory.copy(chunk, &val, sizeof(uint16));
+            set_data(index, chunk);
+        }
+
+        public virtual void set_all_uint16(uint index, Enumerable<uint16?> values, Endianness endianness) throws IndexError {
+            foreach(var value in values) {
+                set_uint16(index, value, endianness);
+            }
+        }
+
+        public virtual void set_int8(uint index, int8 value, Endianness endianness) throws IndexError {
+            var chunk = new uint8[sizeof(int8)];    
+            Memory.copy(chunk, &value, sizeof(int8));
+            set_data(index, chunk);
+        }
+
+        public virtual void set_all_int8(uint index, Enumerable<int8?> values, Endianness endianness) throws IndexError {
+            foreach(var value in values) {
+                set_int8(index, value, endianness);
+            }
+        }
+
+        public virtual void set_uint8(uint index, uint8 value, Endianness endianness) throws IndexError {
+            var chunk = new uint8[] { value };
+            set_data(index, chunk);
+        }
+
+        public virtual void set_all_uint8(uint index, Enumerable<uint8?> values, Endianness endianness) throws IndexError {
+            foreach(var value in values) {
+                set_uint8(index, value, endianness);
+            }
+        }
+
+        private void set_data(uint index, uint8[] data) throws IndexError {
+            for(int i = 0; i < data.length; i++) {
+                this[i + index] = data[i];
+            }
+        }
+    }
+
+}

src/lib/Interfaces/ReadOnlyAddressableBytes.vala

@@ -0,0 +1,152 @@
+
+namespace Invercargill {
+
+    public enum Endianness {
+        Native,
+        BigEndian,
+        LittleEndian,
+    }
+
+
+    [GenericAccessors]
+    public interface ReadOnlyAddressableBytes : ReadOnlyAddressable<uint8> {
+
+        public virtual int64? get_int64(int index, Endianness endianness = Endianness.Native) throws IndexError {
+            var data = get_slice(index, sizeof(int64));
+            int64 value = 0;
+            int64 val = 0;
+            Memory.copy(&value, data, sizeof(int64));
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            } 
+            return val;           
+        }
+
+        public virtual uint64? get_uint64(int index, Endianness endianness = Endianness.Native) throws IndexError {
+            var data = get_slice(index, sizeof(uint64));
+            uint64 value = 0;
+            uint64 val = 0;
+            Memory.copy(&value, data, sizeof(uint64));
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            } 
+            return val;
+        }
+
+
+        public virtual int32? get_int32(int index, Endianness endianness = Endianness.Native) throws IndexError {
+            var data = get_slice(index, sizeof(int32));
+            int32 value = 0;
+            int32 val = 0;
+            Memory.copy(&value, data, sizeof(int32));
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            } 
+            return val;           
+        }
+
+        public virtual uint32? get_uint32(int index, Endianness endianness = Endianness.Native) throws IndexError {
+            var data = get_slice(index, sizeof(uint32));
+            uint32 value = 0;
+            uint32 val = 0;
+            Memory.copy(&value, data, sizeof(uint32));
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            } 
+            return val;           
+        }
+
+        public virtual int16? get_int16(int index, Endianness endianness = Endianness.Native) throws IndexError {
+            var data = get_slice(index, sizeof(int16));
+            int16 value = 0;
+            int16 val = 0;
+            Memory.copy(&value, data, sizeof(int16));
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            } 
+            return val;           
+        }
+
+        public virtual uint16? get_uint16(int index, Endianness endianness = Endianness.Native) throws IndexError {
+            var data = get_slice(index, sizeof(uint16));
+            uint16 value = 0;
+            uint16 val = 0;
+            Memory.copy(&value, data, sizeof(uint16));
+            switch (endianness) {
+                case Endianness.Native:
+                    val = value;
+                    break;
+                case Endianness.BigEndian:
+                    val = value.to_big_endian();
+                    break;
+                case Endianness.LittleEndian:
+                    val = value.to_little_endian();
+                    break;
+            } 
+            return val;           
+        }
+
+        public virtual int8? get_int8(int index) throws IndexError {
+            var data = get_slice(index, sizeof(int8));
+            int8 value = 0;
+            Memory.copy(&value, data, sizeof(int8));
+            return value;           
+        }
+
+        public virtual uint8? get_uint8(int index) throws IndexError {
+            var data = get_slice(index, sizeof(uint8));
+            uint8 value = 0;
+            Memory.copy(&value, data, sizeof(uint8));
+            return value;           
+        }
+
+        private uint8[] get_slice(uint index, ulong size) throws IndexError {
+            var slice = new uint8[size];
+            for(int i = 0; i < size; i++) {
+                slice[i] = this[i + index];
+            }
+            return slice;
+        }
+    }
+
+}

src/lib/meson.build

@@ -76,6 +76,7 @@ sources += files('Interfaces/ImmutableLot.vala')
 sources += files('Interfaces/ReadOnlyCollection.vala')
 sources += files('Interfaces/ReadOnlyAssociative.vala')
 sources += files('Interfaces/ReadOnlyAddressable.vala')
+sources += files('Interfaces/ReadOnlyAddressableBytes.vala')
 sources += files('Interfaces/ReadOnlySet.vala')
 sources += files('Interfaces/Collection.vala')
 sources += files('Interfaces/Associative.vala')
@@ -84,6 +85,7 @@ sources += files('Interfaces/Set.vala')
 sources += files('Interfaces/Properties.vala')
 sources += files('Interfaces/Elements.vala')
 sources += files('Interfaces/AddressableCollection.vala')
+sources += files('Interfaces/AddressableBytes.vala')
 
 sources += files('DataStructures/Series.vala')
 sources += files('DataStructures/Fifo.vala')
@@ -97,6 +99,7 @@ sources += files('DataStructures/SortedSeries.vala')
 sources += files('DataStructures/Buffer.vala')
 sources += files('DataStructures/RingBuffer.vala')
 sources += files('DataStructures/ImmutableBuffer.vala')
+sources += files('DataStructures/ByteBuffer.vala')
 
 sources += files('Mapping/Mapper.vala')
 sources += files('Mapping/PropertyMapper.vala')