Example 17.1. The string in hexadecimal to be read

61 62 63 64 00 65 66 67 68 00 69 6A 6B 6C

Example 17.2. Read the string

SFXAnsiStringStreamReader reader;

SFXAnsiString string;

reader >> string; // get data string until '\0' is reached string = "abcd"
reader >> string; // get string up to next '\0'            string = "efgh"
reader >> string; // get until end                         string = "ijkl"
reader >> string; // get until end                         string = empty

Example 17.3. Write the string

SFXAnsiStringStreamWriter writer;
SFXAnsiString string("abcd");

writer << string;  // write string "abcd"
writer << "efgh";  // write string "efgh"
writer << string;  // write string "abcd"

Example 17.4. Write the '\0' character

writer << ends;

Example 17.5. The binary sequence in hexadecimal to be read

11 22 33 44 12 34 56 78 11 22 33 44 55

Example 17.6. Read the binary sequence

SFXBinaryStreamReader reader;  // input binary sequence

// part to obtain reader is omitted

// interpret binary sequence as little-endian
reader >> little;

UInt32 v;

reader >> v; // interpret 4 bytes from head as UInt32
             // since it is little endian, 0x78563412 is assigned to v

// the following binary sequence are interpreted as big-endian
reader >> big;

reader.ReadUInt32(&v); // interpret next 4 bytes as UInt32
                       // since it is big endian, v = 0x11223344
                       // same as reader >> v

UInt08 c;

reader >> c; // interpret 1 bytes from head as UInt08: c = 0x55

reader.ReadUInt08(&c); // c is not changed because it has come to end despite that it is tried to get 1 byte from head
                       // this function returns error

Example 17.7. Write the binary sequence

SFXBinaryStreamWriter writer;

// part to obtain writer is omitted

// interpret binary sequence as little-endian.
writer << little;

writer.WriteUInt08(0x22);  // write as UInt08
writer.WriteUInt16(0x22);  // write as UInt16
writer.WriteUInt32(0x22);  // write as UInt32

// writer << 0x22; causes error since it is ambigous
// writer << static_cast<UInt08>(0x22); is acceptable

// the following binary sequence is interpreted as big-endian
writer << big;

writer.WriteUInt32(0x22); // write as UInt32

writer.Flush();

Example 17.8. The written the binary sequence (hexadecimal)

22 22 00 22 00 00 00 00 00 00 22

Example 17.17. Input from the file with the buffer of fixed length

SFCError error;                   // error value
SFXFile file;                     // input file
SFXAnsiStringStreamReader reader; // input stream
SFXAnsiString stringFromFile;     // for storing data
SFXAnsiString tempString;

// open file in read only mode
if ((error = file.OpenReadOnly(SFXPath("/dir1/data.txt"))) == SFERR_NO_ERROR) {

    // get input stream (buffer size: 1024)
    if ((error = file.GetStreamReader(1024, &reader)) == SFERR_NO_ERROR) {

        while (!reader.Ends()) { // repeat until reaching end of stream.

            // read data from input stream to input stream buffer actually
            // since buffer size is fixed by 1024 bytes, more than 1024 bytes cannot be read per the fetch operation
            if ((error = reader.Fetch()) != SFERR_NO_ERROR) {
                // if error
                break; 
            }

            // read data from input stream buffer to a specified variable(tempString)
            if ((error = reader.ReadSFXAnsiString(&tempString))
                != SFERR_NO_ERROR) { 
                // if error
                break;
            }

            // append tempString to end of stringFromFile
            stringFromFile += tempString;
        }
        
        reader.Release();
    }
    file.Close();
}

Example 17.18. Output into the file with the buffer of fixed length

SFCError error;                                      // error value
SFXFile file;                                        // output file
SFXAnsiStringStreamWriter writer;                    // output stream
SFXAnsiString string("abcdefghijklmnopqrstuvwxyz");  // data to write
ACharConstPtr p = string.GetBuffer();                // pointer to string
ACharConstPtr endOfString = p + string.GetLength();  // end of string

SInt32 bufferSize = 1024;

// open file in read write mode
if ((error = file.OpenReadWrite(SFXPath("/dir1/data.txt")))
    == SFERR_NO_ERROR) {

    // get output stream
    if ((error = file.GetStreamWriter(bufferSize, &writer))
        == SFERR_NO_ERROR) {

        for (; p < endOfString; p += bufferSize) {

            // write size
            SInt32 size = (endOfString - p < bufferSize) ? endOfString - p : bufferSize;

            // write data to output stream buffer
            if ((error = writer.Write(p, size)) != SFERR_NO_ERROR) {
                break; // error
            }
            // write data from output stream buffer to output file actually
            if ((error = writer.Flush()) != SFERR_NO_ERROR) { 
                // if error
                break;
            }
        }
        writer.Release();
    }
    file.Close();
}

Example 17.19. TCP socket communication with the buffer of fixed length

class MyClass {
private:
    SFXTCPSocket _socket;                // TCP Socket instance
    SFXAnsiStringStreamReader  _reader;  // input stream
    SFXAnsiStringStreamWriter  _writer;  // output stream
    SFXAnsiString _writingString;        // string to send
    ACharConstPtr _p;
    ACharConstPtr _end;
    SInt32 _bufferSize;
    SFXAnsiString _readingString;        // receiving string
public:
    Void Start(Void);
    CALLBACK_DECLARE_SFXTCPSOCKET(OnConnect)
    CALLBACK_DECLARE_SFXANSISTRINGSTREAMREADER(OnFetch)
    CALLBACK_DECLARE_SFXANSISTRINGSTREAMWRITER(OnFlush)
};

Void MyClass::Start(Void)
{
    // string to send
    _writingString = "GET / HTTP/1.1\r\n\r\n";
    _bufferSize = 1024;

    // initiation
    _socket.Open();

    // start to connect (connection establishment will be notified to OnConnect function)
    _socket.Connect(SFXSocketAddress("www.example.com:80"), CALLBACK_FUNCTION(OnConnect));
}

// callback function notified of connection establishment
CALLBACK_IMPLEMENT_SFXTCPSOCKET(MyClass, OnConnect, error)
{
    // get input stream
    _socket.GetStreamReader(1024, &_reader);

    // get output stream
    _socket.GetStreamWriter(_bufferSize, &_writer);

    _p = _writingString.GetBuffer();
    _end = _p + _writingString.GetLength();

    SInt32 size = (_end - _p < _bufferSize) ? _end - _p : _bufferSize;
    // write data
    _writer.Write(_p, size);

    _p += size;

    // send data actually (completion of sending data will be notified to OnFlush function)
    _writer.Flush(CALLBACK_FUNCTION(OnFlush));
}

// callback function called after sending data
CALLBACK_IMPLEMENT_SFXANSISTRINGSTREAMWRITER(MyClass, OnFlush, error)
{
    if (_p < _end) { // when there is data to be transmitted
        // write data to output stream again

        SInt32 size = (_end - _p < _bufferSize) ? _end - _p : _bufferSize;
        // write data
        _writer.Write(_p, size);

        _p += size;

        // send data actually again (completion of sending data will be notified to OnFlush function)
        _writer.Flush(CALLBACK_FUNCTION(OnFlush));
    }
    else { // receive data

        // receive data into input stream buffer (completion of receiving data will be notified to OnFecth function)
        _reader.Fetch(CALLBACK_FUNCTION(OnFetch));
        
        // if _reader.Read is called here, error will occur
    }
}

// callback function notified of completion of receiving data
CALLBACK_IMPLEMENT_SFXANSISTRINGSTREAMREADER(MyClass, OnFetch, error)
{
    SFXAnsiString temp;

    // read data from input stream buffer to specified variable(temp)
    _reader.ReadSFXAnsiString(&temp);

    _readingString += temp;

    if (!_reader.Ends()) { // when input stream does not end

        // receive data into input stream buffer again (completion of receiving data will be notified to OnFecth function)
        _reader.Fetch(CALLBACK_FUNCTION(OnFetch));

    }
}

Example 17.20. In the TCP socket communication, set the trigger that makes the callback function be called each time the linefeed "\r\n" appears.

// error handling is omitted

// callback function notified of connection establishment
CALLBACK_IMPLEMENT_SFXTCPSOCKET(MyClass, OnConnect, error)
{
    // get input stream
    _socket.GetStreamReader(&_reader);

    // specify timing
    _reader.SetTrigger("\r\n", 2);

    // receive data ( completion of receiving data will be notified to OnFetch function)
    _reader.Fetch(CALLBACK_FUNCTION(OnFetch));
}

// callback function notified of completion of receiving data
CALLBACK_IMPLEMENT_SFXANSISTRINGSTREAMREADER(MyClass, OnFetch, error)
{
    SFXAnsiString string;

    // whether or not this callback function is notified of the trigger that is set using the SetTrigger function
    // (in this case, triger is that line feed and carriage return characters appear)
    if (_reader.Triggers()) {
        TRACE("by CRLF");
    }

    //  read received string
    _reader.ReadSFXAnsiString(&string);

    while (!_reader.Ends()) { // while not reach end of stream
        // receive data (completion of receiving data will be notified to OnFetch function）
        _reader.Fetch(CALLBACK_FUNCTION(OnFetch));
    }
}