Data

// Example program
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <stdexcept>
#include <cstring>
#include <memory>

void log(std::string location, std::string message) {
    std::cout << "[" << location << "] " << message << std::endl;
}

struct DataPacket {
    DataPacket(const unsigned int packetSize) {data=new char[packetSize];}
    ~DataPacket() {delete[] data;}
    char* data;
};

template<typename T>
struct DataView {
    DataView(T* pData, std::size_t pDataSize) : data(pData), dataSize(pDataSize) {}

    T& operator[](std::size_t pIndex) {
        if(pIndex>=dataSize) {
            throw std::runtime_error("DataView: Index out of bounds!");
        }
        return &data[pIndex];
    }

    const T* data;
    const std::size_t dataSize;
};

class DataReader {
public:
    DataReader(DataView<char> pDataView) : dataView(pDataView), currentIndex(0) {}

    void resetIndex(std::size_t pNewIndex=0) {
        currentIndex=pNewIndex;
        if(currentIndex>=dataView.dataSize) {
            throw std::runtime_error("DataReader: Set index out of DataView bounds!");
        }
    }
    void advanceIndex(std::size_t pOffset) {currentIndex+=pOffset;}
    bool hasMoreData() {return currentIndex<dataView.dataSize;}


    template<typename T>
    T read() {
        T result = *(reinterpret_cast<T*>(&dataView[currentIndex]));
        advanceIndex(sizeof(T));
        return result;
    }

private:
    DataView<char> dataView;
    std::size_t currentIndex;
};

class DataWriter {
public:
    DataWriter(DataView<char> pDataView) : dataView(pDataView), currentIndex(0) {}

    void resetIndex(std::size_t pNewIndex=0) {
        currentIndex=pNewIndex;
        if(currentIndex>=dataView.dataSize) {
            throw std::runtime_error("DataWriter: Set index out of DataView bounds!");
        }
    }
    void advanceIndex(std::size_t pOffset) {currentIndex+=pOffset;}
    bool hasMoreSpace() {return currentIndex<dataView.dataSize;}

    void writeBytes(const char* pData, std::size_t pNumBytes) {
        for(std::size_t byteIndex=0; byteIndex<pNumBytes; ++byteIndex) {
            dataView[currentIndex+byteIndex] = pData[byteIndex];
        }
        advanceIndex(pNumBytes);
    }

    template<typename T>
    void write(T pData) {
        writeBytes(reinterpret_cast<char*>(&pData), sizeof(T));
    }

    void write(std::string pStr) {
        writeBytes(pStr.c_str(), pStr.size());
    }

private:
    DataView<char> dataView;
    std::size_t currentIndex;
};

using ListenerId_t = unsigned int;
class NetworkListener {
public:
    NetworkListener(ListenerId_t pId) : id(pId) {}
    virtual void receiveMessage(DataPacket* pPacket) = 0;

    const ListenerId_t id;
};

class Network {
public:
    void addListener(NetworkListener* pListener) {listeners.push_back(pListener);}
    void sendMessage(ListenerId_t pId, DataPacket* pPacket) {
        for(auto listener : listeners) {
            if(listener->id==pId) {
                listener->receiveMessage(pPacket);
                return;
            }
        }
    }

private:
    std::list<NetworkListener*> listeners;
};

class Server : public NetworkListener {
    Server(ListenerId_t pId) : NetworkListener(pId) {}

    void receiveMessage(DataPacket* pPacket) override  {
        log("Server/receiveMessage", "Received Message!");
    }
};

class Client : public NetworkListener {
    Client(ListenerId_t pId) : NetworkListener(pId) {}

    void receiveMessage(DataPacket* pPacket) override {
        log("Client/receiveMessage", "Received Message!");
    }
};

void application() {
    constexpr std::size_t bufferSize = 1000;
    char buffer[bufferSize];
    std::memset(buffer, 0, bufferSize);
    DataView<char> bufferView(buffer, bufferSize);

}

int main()
{
    try {
        application();
    } catch(std::exception& e) {
        log("Exception: ", e.what());
    }
}