ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-06 07:38:48 +00: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 package io
Conversion_Error :: enum { to_reader :: proc(s: Stream) -> (r: Reader, ok: bool = true) {
None,
Missing_Procedure,
Fallback_Possible,
}
to_reader :: proc(s: Stream) -> (r: Reader, err: Conversion_Error) {
r.stream = s; r.stream = s;
if s.stream_vtable == nil || s.impl_read == nil { if s.stream_vtable == nil || s.impl_read == nil {
err = .Missing_Procedure; ok = false;
} }
return; return;
} }
to_writer :: proc(s: Stream) -> (w: Writer, err: Conversion_Error) { to_writer :: proc(s: Stream) -> (w: Writer, ok: bool = true) {
w.stream = s; w.stream = s;
if s.stream_vtable == nil || s.impl_write == nil { if s.stream_vtable == nil || s.impl_write == nil {
err = .Missing_Procedure; ok = false;
} }
return; return;
} }
to_closer :: proc(s: Stream) -> (c: Closer, err: Conversion_Error) { to_closer :: proc(s: Stream) -> (c: Closer, ok: bool = true) {
c.stream = s; c.stream = s;
if s.stream_vtable == nil || s.impl_close == nil { if s.stream_vtable == nil || s.impl_close == nil {
err = .Missing_Procedure; ok = false;
} }
return; return;
} }
to_flusher :: proc(s: Stream) -> (f: Flusher, err: Conversion_Error) { to_flusher :: proc(s: Stream) -> (f: Flusher, ok: bool = true) {
f.stream = s; f.stream = s;
if s.stream_vtable == nil || s.impl_flush == nil { if s.stream_vtable == nil || s.impl_flush == nil {
err = .Missing_Procedure; ok = false;
} }
return; return;
} }
to_seeker :: proc(s: Stream) -> (seeker: Seeker, err: Conversion_Error) { to_seeker :: proc(s: Stream) -> (seeker: Seeker, ok: bool = true) {
seeker.stream = s; seeker.stream = s;
if s.stream_vtable == nil || s.impl_seek == nil { if s.stream_vtable == nil || s.impl_seek == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; r.stream = s;
if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil { if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; r.stream = s;
if s.stream_vtable == nil || s.impl_read == nil || s.impl_close == nil { if s.stream_vtable == nil || s.impl_read == nil || s.impl_close == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; r.stream = s;
if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_close == nil { if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_close == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; r.stream = s;
if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_seek == nil { if s.stream_vtable == nil || s.impl_read == nil || s.impl_write == nil || s.impl_seek == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; w.stream = s;
if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil { if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; w.stream = s;
if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil || s.impl_close == nil { if s.stream_vtable == nil || s.impl_write == nil || s.impl_flush == nil || s.impl_close == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; r.stream = s;
if s.stream_vtable == nil || s.impl_read_at == nil { if s.stream_vtable == nil || s.impl_read_at == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; w.stream = s;
if s.stream_vtable == nil || s.impl_write_at == nil { if s.stream_vtable == nil || s.impl_write_at == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; r.stream = s;
if s.stream_vtable == nil || s.impl_read_from == nil { if s.stream_vtable == nil || s.impl_read_from == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; w.stream = s;
if s.stream_vtable == nil || s.impl_write_to == nil { if s.stream_vtable == nil || s.impl_write_to == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; w.stream = s;
if s.stream_vtable == nil || s.impl_write == nil || s.impl_close == nil { if s.stream_vtable == nil || s.impl_write == nil || s.impl_close == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; w.stream = s;
if s.stream_vtable == nil || s.impl_write == nil || s.impl_seek == nil { if s.stream_vtable == nil || s.impl_write == nil || s.impl_seek == nil {
err = .Missing_Procedure; ok = false;
} }
return; 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; b.stream = s;
if s.stream_vtable == nil || s.impl_read_byte == nil { if s.stream_vtable == nil || s.impl_read_byte == nil {
err = .Missing_Procedure; ok = false;
if s.stream_vtable != nil && s.impl_read != nil { if s.stream_vtable != nil && s.impl_read != nil {
err = .Fallback_Possible; ok = true;
} }
} }
return; 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; b.stream = s;
if s.stream_vtable != nil { if s.stream_vtable != nil {
if s.impl_unread_byte == nil { if s.impl_unread_byte == nil {
err = .Missing_Procedure; ok = false;
return; return;
} }
if s.impl_read_byte != nil { if s.impl_read_byte != nil {
err = .None; ok = true;
} else if s.impl_read != nil { } else if s.impl_read != nil {
err = .Fallback_Possible; ok = true;
} else { } else {
err = .Missing_Procedure; ok = false;
} }
} }
return; 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; b.stream = s;
if s.stream_vtable == nil || s.impl_write_byte == nil { if s.stream_vtable == nil || s.impl_write_byte == nil {
err = .Missing_Procedure; ok = false;
if s.stream_vtable != nil && s.impl_write != nil { if s.stream_vtable != nil && s.impl_write != nil {
err = .Fallback_Possible; ok = true;
} }
} }
return; 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; r.stream = s;
if s.stream_vtable == nil || s.impl_read_rune == nil { if s.stream_vtable == nil || s.impl_read_rune == nil {
err = .Missing_Procedure; ok = false;
if s.stream_vtable != nil && s.impl_read != nil { if s.stream_vtable != nil && s.impl_read != nil {
err = .Fallback_Possible; ok = true;
} }
} }
return; 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; r.stream = s;
if s.stream_vtable != nil { if s.stream_vtable != nil {
if s.impl_unread_rune == nil { if s.impl_unread_rune == nil {
err = .Missing_Procedure; ok = false;
return; return;
} }
if s.impl_read_rune != nil { if s.impl_read_rune != nil {
err = .None; ok = true;
} else if s.impl_read != nil { } else if s.impl_read != nil {
err = .Fallback_Possible; ok = true;
} else { } else {
err = .Missing_Procedure; ok = false;
} }
} else { } else {
err = .Missing_Procedure; ok = false;
} }
return; return;
} }
core/io/multi.odin
+15 -33
View File
@@ -1,8 +1,5 @@
package io package io
import "core:runtime"
@(private)
Multi_Reader :: struct { Multi_Reader :: struct {
readers: [dynamic]Reader, readers: [dynamic]Reader,
} }
@@ -27,19 +24,10 @@ _multi_reader_vtable := &Stream_VTable{
} }
return 0, .EOF; 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) { multi_reader_init :: proc(mr: ^Multi_Reader, readers: ..Reader, allocator := context.allocator) -> (r: Reader) {
context.allocator = allocator; all_readers := make([dynamic]Reader, 0, len(readers), allocator);
mr := new(Multi_Reader);
all_readers := make([dynamic]Reader, 0, len(readers));
for w in readers { for w in readers {
if w.stream_vtable == _multi_reader_vtable { if w.stream_vtable == _multi_reader_vtable {
@@ -57,11 +45,13 @@ multi_reader :: proc(readers: ..Reader, allocator := context.allocator) -> (r: R
return; return;
} }
multi_reader_destroy :: proc(mr: ^Multi_Reader) {
delete(mr.readers);
}
@(private)
Multi_Writer :: struct { Multi_Writer :: struct {
writers: []Writer, writers: [dynamic]Writer,
allocator: runtime.Allocator,
} }
@(private) @(private)
@@ -81,33 +71,25 @@ _multi_writer_vtable := &Stream_VTable{
return len(p), nil; 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) { multi_writer_init :: proc(mw: ^Multi_Writer, writers: ..Writer, allocator := context.allocator) -> (out: Writer) {
context.allocator = allocator; mw.writers = make([dynamic]Writer, 0, len(writers), allocator);
mw := new(Multi_Writer);
mw.allocator = allocator;
all_writers := make([dynamic]Writer, 0, len(writers));
for w in writers { for w in writers {
if w.stream_vtable == _multi_writer_vtable { if w.stream_vtable == _multi_writer_vtable {
other := (^Multi_Writer)(w.stream_data); other := (^Multi_Writer)(w.stream_data);
append(&all_writers, ..other.writers); append(&mw.writers, ..other.writers[:]);
} else { } else {
append(&all_writers, w); append(&mw.writers, w);
} }
} }
mw.writers = all_writers[:];
out.stream_vtable = _multi_writer_vtable; out.stream_vtable = _multi_writer_vtable;
out.stream_data = mw; out.stream_data = mw;
return; return;
} }
multi_writer_destroy :: proc(mw: ^Multi_Writer) {
delete(mw.writers);
}