bytestream.hpp

#pragma once

#include <cstdint>
#include <condition_variable>
#include <list>
#include <memory>
#include <mutex>
#include <string>
#include <vector>

namespace dangerous { namespace snmp {

class ByteStream {
public:
    enum Access {
        READ_ONLY,
        READ_WRITE
    };

public:
    ByteStream();

    ~ByteStream();

    void copyFrom( const std::string& bytes, Access access );
    
    void copyFrom( const std::vector<char>& bytes, Access access );
    
    void copyFrom( const ByteStream& byteStream, Access access );

    void linkFrom( char* bytes, unsigned int bytesSize, Access access );

    void copyTo( std::vector<char>& buffer ) const;

    void copyTo( std::string& buffer ) const;

    int compareWith( const char* buffer, unsigned int bufferLength ) const;

    inline const bool isErrored() const { return _isErrored; }

    inline const bool lastReadTimedOut() const { return _lastReadTimedOut; }

    inline const bool isLive() const { return _isLive; }

    void setLive( bool isLive );

    inline std::chrono::milliseconds readTimeout() const { return _readTimeout; }

    inline void readTimeout( const std::chrono::milliseconds& timeout ) { _readTimeout = timeout; }

    unsigned int remainingReadLength() const;
    
    unsigned int remainingWriteLength() const;

    void reset();

    /*
     * Peek functions.
     */

    bool peekByte( char& byte );

    /*
     * Read functions.
     */

    bool readByte( char& byte );

    bool readBytes( char* buffer, unsigned int bufferSize, unsigned int& bytesRead );

    /*
     * Write functions.
     * All of these functions will advance the write head.
     */

    bool writeByte( char byte );

    bool writeBytes( const char* buffer, unsigned int bufferSize, unsigned int& bytesWritten );

    /*
     * Packet functions.
     */

    void endPacket();

    bool hasNextPacket();

    bool nextPacket();

    /*
     * Debugging functions.
     */

    std::string debugString();

protected:
    bool _isErrored;

    bool _lastReadTimedOut;

    bool _isLive;
    mutable std::mutex liveLock;
    mutable std::condition_variable liveConditionVariable;

    bool ownBytes;
    char* bytes;
    unsigned int bytesSize;
    unsigned int readIndex;
    unsigned int writeIndex;

    std::list<unsigned int> boundaries;

    std::chrono::milliseconds _readTimeout;

    void freeBytes();

    unsigned int remainingReadLength_nolock() const;
    
    unsigned int remainingWriteLength_nolock() const;

    bool waitForReading( unsigned int increment );
    
    bool grow( unsigned int increment );
    
};

} }