Update package io

core/io/conv.odin

@@ -1,200 +1,194 @@
 package io
 
-Conversion_Error :: enum {
-	None,
-	Missing_Procedure,
-	Fallback_Possible,
-}
-
-to_reader :: proc(s: Stream) -> (r: Reader, err: Conversion_Error) {
+to_reader :: proc(s: Stream) -> (r: Reader, ok: bool = true) {
 	r.stream = s;
 	if s.stream_vtable == nil || s.impl_read == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_writer :: proc(s: Stream) -> (w: Writer, err: Conversion_Error) {
+to_writer :: proc(s: Stream) -> (w: Writer, ok: bool = true) {
 	w.stream = s;
 	if s.stream_vtable == nil || s.impl_write == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
 
-to_closer :: proc(s: Stream) -> (c: Closer, err: Conversion_Error) {
+to_closer :: proc(s: Stream) -> (c: Closer, ok: bool = true) {
 	c.stream = s;
 	if s.stream_vtable == nil || s.impl_close == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_flusher :: proc(s: Stream) -> (f: Flusher, err: Conversion_Error) {
+to_flusher :: proc(s: Stream) -> (f: Flusher, ok: bool = true) {
 	f.stream = s;
 	if s.stream_vtable == nil || s.impl_flush == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_seeker :: proc(s: Stream) -> (seeker: Seeker, err: Conversion_Error) {
+to_seeker :: proc(s: Stream) -> (seeker: Seeker, ok: bool = true) {
 	seeker.stream = s;
 	if s.stream_vtable == nil || s.impl_seek == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
 
-to_read_writer :: proc(s: Stream) -> (r: Read_Writer, err: Conversion_Error) {
+to_read_writer :: proc(s: Stream) -> (r: Read_Writer, ok: bool = true) {
 	r.stream = s;
 	if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_read_closer :: proc(s: Stream) -> (r: Read_Closer, err: Conversion_Error) {
+to_read_closer :: proc(s: Stream) -> (r: Read_Closer, ok: bool = true) {
 	r.stream = s;
 	if s.stream_vtable == nil || s.impl_read == nil || s.impl_close == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_read_write_closer :: proc(s: Stream) -> (r: Read_Write_Closer, err: Conversion_Error) {
+to_read_write_closer :: proc(s: Stream) -> (r: Read_Write_Closer, ok: bool = true) {
 	r.stream = s;
 	if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_close == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_read_write_seeker :: proc(s: Stream) -> (r: Read_Write_Seeker, err: Conversion_Error) {
+to_read_write_seeker :: proc(s: Stream) -> (r: Read_Write_Seeker, ok: bool = true) {
 	r.stream = s;
 	if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_seek == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_write_flusher :: proc(s: Stream) -> (w: Write_Flusher, err: Conversion_Error) {
+to_write_flusher :: proc(s: Stream) -> (w: Write_Flusher, ok: bool = true) {
 	w.stream = s;
 	if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_write_flush_closer :: proc(s: Stream) -> (w: Write_Flush_Closer, err: Conversion_Error) {
+to_write_flush_closer :: proc(s: Stream) -> (w: Write_Flush_Closer, ok: bool = true) {
 	w.stream = s;
 	if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil || s.impl_close == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
 
-to_reader_at :: proc(s: Stream) -> (r: Reader_At, err: Conversion_Error) {
+to_reader_at :: proc(s: Stream) -> (r: Reader_At, ok: bool = true) {
 	r.stream = s;
 	if s.stream_vtable == nil || s.impl_read_at == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_writer_at :: proc(s: Stream) -> (w: Writer_At, err: Conversion_Error) {
+to_writer_at :: proc(s: Stream) -> (w: Writer_At, ok: bool = true) {
 	w.stream = s;
 	if s.stream_vtable == nil || s.impl_write_at == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_reader_from :: proc(s: Stream) -> (r: Reader_From, err: Conversion_Error) {
+to_reader_from :: proc(s: Stream) -> (r: Reader_From, ok: bool = true) {
 	r.stream = s;
 	if s.stream_vtable == nil || s.impl_read_from == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_writer_to :: proc(s: Stream) -> (w: Writer_To, err: Conversion_Error) {
+to_writer_to :: proc(s: Stream) -> (w: Writer_To, ok: bool = true) {
 	w.stream = s;
 	if s.stream_vtable == nil || s.impl_write_to == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_write_closer :: proc(s: Stream) -> (w: Write_Closer, err: Conversion_Error) {
+to_write_closer :: proc(s: Stream) -> (w: Write_Closer, ok: bool = true) {
 	w.stream = s;
 	if s.stream_vtable == nil || s.impl_write == nil || s.impl_close == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
-to_write_seeker :: proc(s: Stream) -> (w: Write_Seeker, err: Conversion_Error) {
+to_write_seeker :: proc(s: Stream) -> (w: Write_Seeker, ok: bool = true) {
 	w.stream = s;
 	if s.stream_vtable == nil || s.impl_write == nil || s.impl_seek == nil {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }
 
 
-to_byte_reader :: proc(s: Stream) -> (b: Byte_Reader, err: Conversion_Error) {
+to_byte_reader :: proc(s: Stream) -> (b: Byte_Reader, ok: bool = true) {
 	b.stream = s;
 	if s.stream_vtable == nil || s.impl_read_byte == nil {
-		err = .Missing_Procedure;
+		ok = false;
 		if s.stream_vtable != nil && s.impl_read != nil {
-			err = .Fallback_Possible;
+			ok = true;
 		}
 	}
 	return;
 }
-to_byte_scanner :: proc(s: Stream) -> (b: Byte_Scanner, err: Conversion_Error) {
+to_byte_scanner :: proc(s: Stream) -> (b: Byte_Scanner, ok: bool = true) {
 	b.stream = s;
 	if s.stream_vtable != nil {
 		if s.impl_unread_byte == nil {
-			err = .Missing_Procedure;
+			ok = false;
 			return;
 		}
 		if s.impl_read_byte != nil {
-			err = .None;
+			ok = true;
 		} else if s.impl_read != nil {
-			err = .Fallback_Possible;
+			ok = true;
 		} else {
-			err = .Missing_Procedure;
+			ok = false;
 		}
 	}
 	return;
 }
-to_byte_writer :: proc(s: Stream) -> (b: Byte_Writer, err: Conversion_Error) {
+to_byte_writer :: proc(s: Stream) -> (b: Byte_Writer, ok: bool = true) {
 	b.stream = s;
 	if s.stream_vtable == nil || s.impl_write_byte == nil {
-		err = .Missing_Procedure;
+		ok = false;
 		if s.stream_vtable != nil && s.impl_write != nil {
-			err = .Fallback_Possible;
+			ok = true;
 		}
 	}
 	return;
 }
 
-to_rune_reader :: proc(s: Stream) -> (r: Rune_Reader, err: Conversion_Error) {
+to_rune_reader :: proc(s: Stream) -> (r: Rune_Reader, ok: bool = true) {
 	r.stream = s;
 	if s.stream_vtable == nil || s.impl_read_rune == nil {
-		err = .Missing_Procedure;
+		ok = false;
 		if s.stream_vtable != nil && s.impl_read != nil {
-			err = .Fallback_Possible;
+			ok = true;
 		}
 	}
 	return;
 
 }
-to_rune_scanner :: proc(s: Stream) -> (r: Rune_Scanner, err: Conversion_Error) {
+to_rune_scanner :: proc(s: Stream) -> (r: Rune_Scanner, ok: bool = true) {
 	r.stream = s;
 	if s.stream_vtable != nil {
 		if s.impl_unread_rune == nil {
-			err = .Missing_Procedure;
+			ok = false;
 			return;
 		}
 		if s.impl_read_rune != nil {
-			err = .None;
+			ok = true;
 		} else if s.impl_read != nil {
-			err = .Fallback_Possible;
+			ok = true;
 		} else {
-			err = .Missing_Procedure;
+			ok = false;
 		}
 	} else {
-		err = .Missing_Procedure;
+		ok = false;
 	}
 	return;
 }

core/io/multi.odin

@@ -1,8 +1,5 @@
 package io
 
-import "core:runtime"
-
-@(private)
 Multi_Reader :: struct {
 	readers: [dynamic]Reader,
 }
@@ -27,19 +24,10 @@ _multi_reader_vtable := &Stream_VTable{
 		}
 		return 0, .EOF;
 	},
-	impl_destroy = proc(s: Stream) -> Error {
-		mr := (^Multi_Reader)(s.stream_data);
-		context.allocator = mr.readers.allocator;
-		delete(mr.readers);
-		free(mr);
-		return .None;
-	},
 };
 
-multi_reader :: proc(readers: ..Reader, allocator := context.allocator) -> (r: Reader) {
-	context.allocator = allocator;
-	mr := new(Multi_Reader);
-	all_readers := make([dynamic]Reader, 0, len(readers));
+multi_reader_init :: proc(mr: ^Multi_Reader, readers: ..Reader, allocator := context.allocator) -> (r: Reader) {
+	all_readers := make([dynamic]Reader, 0, len(readers), allocator);
 
 	for w in readers {
 		if w.stream_vtable == _multi_reader_vtable {
@@ -57,11 +45,13 @@ multi_reader :: proc(readers: ..Reader, allocator := context.allocator) -> (r: R
 	return;
 }
 
+multi_reader_destroy :: proc(mr: ^Multi_Reader) {
+	delete(mr.readers);
+}
+
 
-@(private)
 Multi_Writer :: struct {
-	writers:      []Writer,
-	allocator:    runtime.Allocator,
+	writers: [dynamic]Writer,
 }
 
 @(private)
@@ -81,33 +71,25 @@ _multi_writer_vtable := &Stream_VTable{
 
 		return len(p), nil;
 	},
-	impl_destroy = proc(s: Stream) -> Error {
-		mw := (^Multi_Writer)(s.stream_data);
-		context.allocator = mw.allocator;
-		delete(mw.writers);
-		free(mw);
-		return .None;
-	},
 };
 
-multi_writer :: proc(writers: ..Writer, allocator := context.allocator) -> (out: Writer) {
-	context.allocator = allocator;
-	mw := new(Multi_Writer);
-	mw.allocator = allocator;
-	all_writers := make([dynamic]Writer, 0, len(writers));
+multi_writer_init :: proc(mw: ^Multi_Writer, writers: ..Writer, allocator := context.allocator) -> (out: Writer) {
+	mw.writers = make([dynamic]Writer, 0, len(writers), allocator);
 
 	for w in writers {
 		if w.stream_vtable == _multi_writer_vtable {
 			other := (^Multi_Writer)(w.stream_data);
-			append(&all_writers, ..other.writers);
+			append(&mw.writers, ..other.writers[:]);
 		} else {
-			append(&all_writers, w);
+			append(&mw.writers, w);
 		}
 	}
 
-	mw.writers = all_writers[:];
-
 	out.stream_vtable = _multi_writer_vtable;
 	out.stream_data = mw;
 	return;
 }
+
+multi_writer_destroy :: proc(mw: ^Multi_Writer) {
+	delete(mw.writers);
+}