PacketHeader.h

Go to the documentation of this file.

//=============================================================================
//  Computational Process Networks class library
//  Copyright (C) 1997-2006  Gregory E. Allen and The University of Texas
//
//  This library is free software; you can redistribute it and/or modify it
//  under the terms of the GNU Library General Public License as published
//  by the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Library General Public License for more details.
//
//  The GNU Public License is available in the file LICENSE, or you
//  can write to the Free Software Foundation, Inc., 59 Temple Place -
//  Suite 330, Boston, MA 02111-1307, USA, or you can find it on the
//  World Wide Web at http://www.fsf.org.
//=============================================================================
#ifndef PACKET_H
#define PACKET_H
#pragma once

#include "common_priv.h"
#include <stdint.h>
#include <cstring>

namespace CPN {

    // All the packet headers are PODs so they can be unioned.

    enum {
        PACKET_SYNCWORD = 0xF1F0C0DE,
        PACKET_REVERSE_SYNCWORD  = 0xDEC0F0F1,
        PACKET_HEADERLENGTH = 64
    };

    enum PacketType_t {
        PACKET_ENQUEUE,
        PACKET_DEQUEUE,
        PACKET_READBLOCK,
        PACKET_WRITEBLOCK,
        PACKET_ENDOFWRITE,
        PACKET_ENDOFREAD,
        PACKET_GROW,
        PACKET_D4RTAG,
        PACKET_FLUSH,
        PACKET_RESET,

        PACKET_ID_READER,
        PACKET_ID_WRITER
    };

    struct CPN_LOCAL PacketHeader {
        union {
            struct {
                uint32_t syncWord;
                uint32_t dataLength;
                uint32_t dataType;

                union {
                    uint32_t requested; // read/write block packets
                    uint32_t maxThresh; // Only for grow packet
                    uint32_t count; // Enqueue/Dequeue packets
                };
                union {
                    struct { // For ID packet
                        uint64_t srckey;
                        uint64_t dstkey;
                    };
                    struct {
                        uint64_t readclock;
                        uint64_t writeclock;
                    };
                };

                uint32_t queueSize; // only used for grow packet
            };
            uint8_t pad[PACKET_HEADERLENGTH];
        };
    };

    inline bool ValidPacket(const PacketHeader *ph) CPN_LOCAL {
        return ph->syncWord == PACKET_SYNCWORD;
    }

    inline void InitPacket(PacketHeader *ph, uint32_t datalen, PacketType_t type) CPN_LOCAL {
        memset(ph, 0, sizeof(PacketHeader));
        ph->syncWord = PACKET_SYNCWORD;
        ph->dataLength = datalen;
        ph->dataType = type;
    }

    class CPN_LOCAL Packet {
    public:
        Packet() { memset(&header, 0, sizeof(header)); }
        Packet(uint32_t datalen, PacketType_t type) { Init(datalen, type); }
        Packet(PacketType_t type) { Init(0, type); }
        Packet(const PacketHeader &ph) : header(ph) {}

        Packet &Init(uint32_t datalen, PacketType_t type) {
            InitPacket(&header, datalen, type);
            return *this;
        }

        uint32_t DataLength() const { return header.dataLength; }
        PacketType_t Type() const { return static_cast<PacketType_t>(header.dataType); }
        uint32_t QueueSize() const { return header.queueSize; }
        uint64_t SourceKey() const { return header.srckey; }
        uint64_t DestinationKey() const { return header.dstkey; }
        uint32_t Requested() const { return header.requested; }
        uint32_t MaxThreshold() const { return header.maxThresh; }
        uint32_t Count() const { return header.count; }
        uint64_t ReadClock() const { return header.readclock; }
        uint64_t WriteClock() const { return header.writeclock; }
        bool Valid() const { return ValidPacket(&header); }

        Packet &DataLength(uint32_t dl) { header.dataLength = dl; return *this; }
        Packet &Type(PacketType_t t) { header.dataType = t; return *this; }
        Packet &QueueSize(uint32_t qs) { header.queueSize = qs; return *this; }
        Packet &SourceKey(uint64_t k) { header.srckey = k; return *this; }
        Packet &DestinationKey(uint64_t k) { header.dstkey = k; return *this; }
        Packet &Requested(uint32_t r) { header.requested = r; return *this; }
        Packet &MaxThreshold(uint32_t mt) { header.maxThresh = mt; return *this; }
        Packet &Count(uint32_t cnt) { header.count = cnt; return *this; }
        Packet &ReadClock(uint64_t c) { header.readclock = c; return *this; }
        Packet &WriteClock(uint64_t c) { header.writeclock = c; return *this; }

    public:
        PacketHeader header;
    };

    class CPN_LOCAL PacketHandler {
    public:
        virtual ~PacketHandler();
        void FirePacket(const Packet &packet);

        virtual void EnqueuePacket(const Packet &packet) = 0;
        virtual void DequeuePacket(const Packet &packet) = 0;
        virtual void ReadBlockPacket(const Packet &packet) = 0;
        virtual void WriteBlockPacket(const Packet &packet) = 0;
        virtual void EndOfWritePacket(const Packet &packet) = 0;
        virtual void EndOfReadPacket(const Packet &packet) = 0;
        virtual void GrowPacket(const Packet &packet) = 0;
        virtual void D4RTagPacket(const Packet &packet) = 0;
        virtual void FlushPacket(const Packet &packet) = 0;
        virtual void ResetPacket(const Packet &packet) = 0;
        virtual void IDReaderPacket(const Packet &packet) = 0;
        virtual void IDWriterPacket(const Packet &packet) = 0;
    };
}

#endif