ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-06-13 01:21:38 -07:00
Code Issues Packages Projects Releases Wiki Activity

Update package io

Browse Source
This commit is contained in:
gingerBill
2021-01-09 00:30:10 +00:00
parent 37253f2621
commit 56980e51da
2 changed files with 69 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/io/conv.odin
+54 -60
View File
@@ -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
+15 -33
View File
@@ -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);
}