Accessor.cpp

/*********************************************************************** Author: Zihan Chen (vczh) Licensed under https://github.com/vczh-libraries/License ***********************************************************************/

#include <string.h>

#include "Accessor.h"

namespace

{

namespace

stream

{

using

namespace

collections

;

/*********************************************************************** TextReader ***********************************************************************/

WString

TextReader

ReadString

(

vint

length

) {

wchar_t

buffer

new

wchar_t

[

length

];

vint

;

for

(;

length

;

++) {

((

buffer

[

ReadChar

())==

L'\0'

) {

break

; } }

buffer

[

L'\0'

;

WString

result

(

buffer

);

delete

[]

buffer

;

return

result

; }

WString

TextReader

ReadLine

() {

WString

result

;

auto

buffer

new

wchar_t

[

65537

];

buffer

[

L'\0'

;

vint

;

while

(

true

) {

wchar_t

ReadChar

();

(

L'\n'

L'\0'

) {

buffer

[

L'\0'

;

result

buffer

;

buffer

[

L'\0'

;

break

; }

else

{

(

65536

) {

buffer

[

L'\0'

;

result

buffer

;

buffer

[

L'\0'

;

; }

buffer

[

++]=

; } }

result

buffer

;

delete

[]

buffer

;

(

result

Length

()>

result

[

result

Length

()-

]==

L'\r'

) {

return

result

Left

(

result

Length

()-

); }

else

{

return

result

; } }

WString

TextReader

ReadToEnd

() {

WString

result

;

auto

buffer

new

wchar_t

[

65537

];

buffer

[

L'\0'

;

vint

;

while

(

true

) {

wchar_t

ReadChar

();

(

L'\0'

) {

buffer

[

L'\0'

;

result

buffer

;

buffer

[

L'\0'

;

break

; }

else

{

(

65536

) {

buffer

[

L'\0'

;

result

buffer

;

buffer

[

L'\0'

;

; }

buffer

[

++]=

; } }

result

buffer

;

delete

[]

buffer

;

return

result

; }

/*********************************************************************** TextWriter ***********************************************************************/

void

TextWriter

WriteString

(

const

wchar_t

string

vint

charCount

) {

while

string

) {

WriteChar

string

++); } }

void

TextWriter

WriteString

(

const

wchar_t

string

) {

WriteString

(

string

, (

vint

)

wcslen

(

string

)); }

void

TextWriter

WriteString

(

const

WString

string

) {

(

string

Length

()) {

WriteString

(

string

Buffer

(),

string

Length

()); } }

void

TextWriter

WriteLine

(

const

wchar_t

string

vint

charCount

) {

WriteString

(

string

charCount

);

WriteString

(

L"\r\n"

); }

void

TextWriter

WriteLine

(

const

wchar_t

string

) {

WriteString

(

string

);

WriteString

(

L"\r\n"

); }

void

TextWriter

WriteLine

(

const

WString

string

) {

WriteString

(

string

);

WriteString

(

L"\r\n"

); }

namespace

monospace_tabling

{

void

WriteBorderLine

(

TextWriter

writer

Array

vint

columnWidths

vint

columns

) {

writer

WriteChar

(

L'+'

);

for

(

vint

;

columns

;

++) {

vint

columnWidths

[

];

for

(

vint

;

++) {

writer

WriteChar

(

L'-'

); }

writer

WriteChar

(

L'+'

); }

writer

WriteLine

(

L""

); }

void

WriteContentLine

(

TextWriter

writer

Array

vint

columnWidths

vint

rowHeight

vint

columns

Array

WString

tableByRow

vint

startRow

) {

vint

cellStart

startRow

columns

;

for

(

vint

;

rowHeight

;

++) {

writer

WriteChar

(

L'|'

);

for

(

vint

;

columns

;

++) {

const

wchar_t

cell

tableByRow

[

cellStart

Buffer

();

for

(

vint

;

++) {

(

cell

)

cell

=::

wcsstr

(

cell

L"\r\n"

);

(

cell

)

cell

; }

writer

WriteChar

(

L' '

);

vint

length

;

(

cell

) {

const

wchar_t

end

=::

wcsstr

(

cell

L"\r\n"

);

length

end

cell

vint

)

wcslen

(

cell

);

writer

WriteString

(

cell

length

); }

for

(

vint

columnWidths

[

;

length

;

--) {

writer

WriteChar

(

L' '

); }

writer

WriteChar

(

L'|'

); }

writer

WriteLine

(

L""

); } } }

using

namespace

monospace_tabling

;

void

TextWriter

WriteMonospacedEnglishTable

(

collections

Array

WString

tableByRow

vint

rows

vint

columns

) {

Array

vint

rowHeights

(

rows

);

Array

vint

columnWidths

(

columns

);

for

(

vint

;

rows

;

++)

rowHeights

[

;

for

(

vint

;

columns

;

++)

columnWidths

[

;

for

(

vint

;

rows

;

++) {

for

(

vint

;

columns

;

++) {

WString

text

tableByRow

[

columns

];

const

wchar_t

reading

text

Buffer

();

vint

width

;

vint

height

;

while

(

reading

) {

height

++;

const

wchar_t

crlf

=::

wcsstr

(

reading

L"\r\n"

);

(

crlf

) {

vint

length

crlf

reading

;

(

width

length

)

width

length

;

reading

crlf

; }

else

{

vint

length

vint

)

wcslen

(

reading

;

(

width

length

)

width

length

;

reading

; } }

(

rowHeights

[

height

)

rowHeights

[

height

;

(

columnWidths

[

width

)

columnWidths

[

width

; } }

WriteBorderLine

this

columnWidths

columns

);

for

(

vint

;

rows

;

++) {

WriteContentLine

this

columnWidths

rowHeights

[

columns

tableByRow

);

WriteBorderLine

this

columnWidths

columns

); } }

/*********************************************************************** StringReader ***********************************************************************/

void

StringReader

PrepareIfLastCallIsReadLine

() {

(

lastCallIsReadLine

) {

lastCallIsReadLine

false

;

(

current

string

Length

() &&

string

[

current

]==

L'\r'

)

current

++;

(

current

string

Length

() &&

string

[

current

]==

L'\n'

)

current

++; } }

StringReader

(

const

WString

_string

) :string(

_string

) ,current(

) ,lastCallIsReadLine(

false

) { }

bool

StringReader

IsEnd

() {

return

current

string

Length

(); }

wchar_t

StringReader

ReadChar

() {

PrepareIfLastCallIsReadLine

();

(

IsEnd

()) {

return

L'\0'

; }

else

{

return

string

[

current

++]; } }

WString

StringReader

ReadString

(

vint

length

) {

PrepareIfLastCallIsReadLine

();

(

IsEnd

()) {

return

L""

; }

else

{

vint

remain

string

Length

()-

current

;

(

length

remain

)

length

remain

;

WString

result

string

Sub

(

current

length

);

current

length

;

return

result

; } }

WString

StringReader

ReadLine

() {

PrepareIfLastCallIsReadLine

();

(

IsEnd

()) {

return

L""

; }

else

{

vint

lineEnd

current

;

while

(

lineEnd

string

Length

()) {

wchar_t

string

[

lineEnd

];

(

L'\r'

L'\n'

)

break

;

lineEnd

++; }

WString

result

string

Sub

(

current

lineEnd

current

);

current

lineEnd

;

lastCallIsReadLine

true

;

return

result

; } }

WString

StringReader

ReadToEnd

() {

return

ReadString

(

string

Length

()-

current

); }

/*********************************************************************** StreamReader ***********************************************************************/

StreamReader

(

IStream

_stream

) :stream(&

_stream

) { }

bool

StreamReader

IsEnd

() {

return

stream

; }

wchar_t

StreamReader

ReadChar

() {

(

stream

) {

wchar_t

buffer

;

(

stream

Read

buffer

sizeof

(

buffer

))==

) {

stream

;

return

; }

else

{

return

buffer

; } }

else

{

return

L'\0'

; } }

/*********************************************************************** StreamWriter ***********************************************************************/

StreamWriter

(

IStream

_stream

) :stream(&

_stream

) { }

void

StreamWriter

WriteChar

(

wchar_t

) {

stream

Write

sizeof

(

)); }

void

StreamWriter

WriteString

(

const

wchar_t

string

vint

charCount

) {

stream

Write

((

void

string

charCount

sizeof

string

)); }

/*********************************************************************** EncoderStream ***********************************************************************/

EncoderStream

(

IStream

_stream

IEncoder

_encoder

) :stream(&

_stream

) ,encoder(&

_encoder

) ,position(

) {

encoder

Setup

(

stream

); }

EncoderStream

() {

(); }

bool

EncoderStream

CanRead

()

const

{

return

false

; }

bool

EncoderStream

CanWrite

()

const

{

return

IsAvailable

(); }

bool

EncoderStream

CanSeek

()

const

{

return

false

; }

bool

EncoderStream

CanPeek

()

const

{

return

false

; }

bool

EncoderStream

IsLimited

()

const

{

return

stream

IsLimited

(); }

bool

EncoderStream

IsAvailable

()

const

{

return

stream

IsAvailable

(); }

void

EncoderStream

() {

encoder

();

stream

; }

pos_t

EncoderStream

Position

()

const

{

return

IsAvailable

()?

position

; }

pos_t

EncoderStream

Size

()

const

{

return

; }

void

EncoderStream

Seek

(

pos_t

_size

) {

CHECK_FAIL(L"EncoderStream::Seek(pos_t)#Operation not supported.");

{

throw

Error

(

L"EncoderStream::Seek(pos_t)#Operation not supported."

);}

while

(

);

}

void

EncoderStream

SeekFromBegin

(

pos_t

_size

) {

CHECK_FAIL(L"EncoderStream::SeekFromBegin(pos_t)#Operation not supported.");

{

throw

Error

(

L"EncoderStream::SeekFromBegin(pos_t)#Operation not supported."

);}

while

(

);

}

void

EncoderStream

SeekFromEnd

(

pos_t

_size

) {

CHECK_FAIL(L"EncoderStream::SeekFromEnd(pos_t)#Operation not supported.");

{

throw

Error

(

L"EncoderStream::SeekFromEnd(pos_t)#Operation not supported."

);}

while

(

);

}

vint

EncoderStream

Read

(

void

_buffer

vint

_size

) {

CHECK_FAIL(L"EncoderStream::Read(void*, vint)#Operation not supported.");

{

throw

Error

(

L"EncoderStream::Read(void*, vint)#Operation not supported."

);}

while

(

);

}

vint

EncoderStream

Write

(

void

_buffer

vint

_size

) {

vint

result

encoder

Write

(

_buffer

_size

);

(

result

) {

position

result

; }

return

result

; }

vint

EncoderStream

Peek

(

void

_buffer

vint

_size

) {

CHECK_FAIL(L"EncoderStream::Peek(void*, vint)#Operation not supported.");

{

throw

Error

(

L"EncoderStream::Peek(void*, vint)#Operation not supported."

);}

while

(

);

}

/*********************************************************************** DecoderStream ***********************************************************************/

DecoderStream

(

IStream

_stream

IDecoder

_decoder

) :stream(&

_stream

) ,decoder(&

_decoder

) ,position(

) {

decoder

Setup

(

stream

); }

DecoderStream

() {

(); }

bool

DecoderStream

CanRead

()

const

{

return

IsAvailable

(); }

bool

DecoderStream

CanWrite

()

const

{

return

false

; }

bool

DecoderStream

CanSeek

()

const

{

return

false

; }

bool

DecoderStream

CanPeek

()

const

{

return

false

; }

bool

DecoderStream

IsLimited

()

const

{

return

stream

IsLimited

(); }

bool

DecoderStream

IsAvailable

()

const

{

return

stream

IsAvailable

(); }

void

DecoderStream

() {

decoder

();

stream

; }

pos_t

DecoderStream

Position

()

const

{

return

IsAvailable

()?

position

; }

pos_t

DecoderStream

Size

()

const

{

return

; }

void

DecoderStream

Seek

(

pos_t

_size

) {

CHECK_FAIL(L"DecoderStream::Seek(pos_t)#Operation not supported.");

{

throw

Error

(

L"DecoderStream::Seek(pos_t)#Operation not supported."

);}

while

(

);

}

void

DecoderStream

SeekFromBegin

(

pos_t

_size

) {

CHECK_FAIL(L"DecoderStream::SeekFromBegin(pos_t)#Operation not supported.");

{

throw

Error

(

L"DecoderStream::SeekFromBegin(pos_t)#Operation not supported."

);}

while

(

);

}

void

DecoderStream

SeekFromEnd

(

pos_t

_size

) {

CHECK_FAIL(L"DecoderStream::SeekFromEnd(pos_t)#Operation not supported.");

{

throw

Error

(

L"DecoderStream::SeekFromEnd(pos_t)#Operation not supported."

);}

while

(

);

}

vint

DecoderStream

Read

(

void

_buffer

vint

_size

) {

vint

result

decoder

Read

(

_buffer

_size

);

(

result

) {

position

result

; }

return

result

; }

vint

DecoderStream

Write

(

void

_buffer

vint

_size

) {

CHECK_FAIL(L"DecoderStream::Write(void*, vint)#Operation not supported.");

{

throw

Error

(

L"DecoderStream::Write(void*, vint)#Operation not supported."

);}

while

(

);

}

vint

DecoderStream

Peek

(

void

_buffer

vint

_size

) {

CHECK_FAIL(L"DecoderStream::Peek(void*, vint)#Operation not supported.");

{

throw

Error

(

L"DecoderStream::Peek(void*, vint)#Operation not supported."

);}

while

(

);

} } }