More Packet class work + NLPacket shell

libraries/networking/src/LimitedNodeList.h

@@ -36,6 +36,7 @@
 
 #include "DomainHandler.h"
 #include "Node.h"
+#include "Packet.h"
 #include "PacketHeaders.h"
 #include "UUIDHasher.h"
 

libraries/networking/src/Packet.cpp

@@ -11,12 +11,60 @@
 
 #include "Packet.h"
 
-#include <QByteArray>
-
-std::unique_ptr<Packet> Packet::makePacket() {
-    return std::unique_ptr<Packet>(new Packet());
+int64_t Packet::headerSize() {
+    return sizeof(Packet::Header);
 }
 
-QByteArray Packet::payload() {
-    return QByteArray();
+int64_t Packet::maxPayloadSize() {
+    return MAX_PACKET_SIZE - Packet::headerSize();
+}
+
+std::unique_ptr<Packet> Packet::create(PacketType::Value type, int64_t size) {
+    if (size == -1) {
+        size = maxPayloadSize();
+    }
+    if (size <= 0 || size > maxPayloadSize()) {
+        return std::unique_ptr<Packet>();
+    }
+    
+    return std::unique_ptr<Packet>(new Packet(type, size));
+}
+
+Packet::Packet(PacketType::Value type, int64_t size) {
+    _packetSize = headerSize() + size;
+    _packet = std::unique_ptr<char>(new char(_packetSize));
+    _payloadStart = _packet.get() + headerSize();
+}
+
+const Packet::Header& Packet::getHeader() const {
+    return *reinterpret_cast<const Header*>(_packet.get());
+}
+
+Packet::Header& Packet::getHeader() {
+    return *reinterpret_cast<Header*>(_packet.get());
+}
+
+char* Packet::getPayload() {
+    return _payloadStart;
+}
+
+
+int64_t NodeListPacket::headerSize() {
+    return sizeof(NodeListPacket::Header);
+}
+
+int64_t NodeListPacket::maxPayloadSize() {
+    return Packet::maxPayloadSize() - NodeListPacket::headerSize();
+}
+
+std::unique_ptr<NodeListPacket> NodeListPacket::create(PacketType::Value type, int64_t size) {
+    if (size > maxPayloadSize()) {
+        return std::unique_ptr<NodeListPacket>();
+    }
+    
+    return std::unique_ptr<NodeListPacket>(new NodeListPacket(type, size));
+}
+
+NodeListPacket::NodeListPacket(PacketType::Value type, int64_t size) : Packet(type, headerSize() + size) {
+    
 }

libraries/networking/src/Packet.h

@@ -14,18 +14,61 @@
 
 #include <memory>
 
-class QByteArray;
+#include "LimitedNodeList.h"
+#include "PacketHeaders.h"
 
 class Packet {
-    std::unique_ptr<Packet> makePacket();
-    QByteArray payload();
+public:
+    struct Header {
+        // Required
+        uint8_t _type;
+        uint8_t _version;
+        
+        // Optionnal
+        uint16_t _messageNumber;
+        //   1st bit is the data/control bit, rest is the sequence number
+        uint32_t _controlBitAndSequenceNumber;
+    };
+    // TODO sanity check Header struct size
+    
+    static int64_t headerSize();
+    static int64_t maxPayloadSize();
+    
+    static std::unique_ptr<Packet> create(PacketType::Value type, int64_t size = -1);
+    
+    virtual const Header& getHeader() const;
+    virtual char* getPayload();
     
 protected:
-    Packet();
-    Packet(const Packet&) = delete;
+    Packet(PacketType::Value type, int64_t size);
     Packet(Packet&&) = delete;
-    Packet& operator=(const Packet&) = delete;
+    Packet(const Packet&) = delete;
     Packet& operator=(Packet&&) = delete;
+    Packet& operator=(const Packet&) = delete;
+    
+    Header& getHeader();
+    
+private:
+    int64_t _packetSize;
+    std::unique_ptr<char> _packet;
+    
+    char* _payloadStart;
+};
+
+class NodeListPacket : public Packet {
+public:
+    struct Header {
+        // Required
+        char _sourceUuid[NUM_BYTES_RFC4122_UUID];
+        char _connectionUuid[NUM_BYTES_RFC4122_UUID];
+    };
+    static int64_t headerSize();
+    static int64_t maxPayloadSize();
+    
+    static std::unique_ptr<NodeListPacket> create(PacketType::Value type, int64_t size = -1);
+    
+protected:
+    NodeListPacket(PacketType::Value type, int64_t size);
 };
 
 #endif // hifi_Packet_h