OctreeEditPacketSender.h

//
//  OctreeEditPacketSender.h
//  libraries/octree/src
//
//  Created by Brad Hefta-Gaub on 8/12/13.
//  Copyright 2013 High Fidelity, Inc.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
 
#ifndef hifi_OctreeEditPacketSender_h
#define hifi_OctreeEditPacketSender_h
 
#include <unordered_map>
 
#include <PacketSender.h>
#include <udt/PacketHeaders.h>
 
#include "SentPacketHistory.h"
 
class OctreeEditPacketSender :  public PacketSender {
    Q_OBJECT
public:
    OctreeEditPacketSender();
    ~OctreeEditPacketSender();
 
    void queueOctreeEditMessage(PacketType type, QByteArray& editMessage);
 
    void releaseQueuedMessages();
 
 
 
    virtual bool process() override;
 
    void setMaxPendingMessages(int maxPendingMessages) { _maxPendingMessages = maxPendingMessages; }
 
    // the default number of pending messages we will store if no servers are available
    static const int DEFAULT_MAX_PENDING_MESSAGES;
 
    // is there an octree server available to send packets to
    bool serversExist() const;
 
    // you must override these...
    virtual char getMyNodeType() const = 0;
    virtual void adjustEditPacketForClockSkew(PacketType type, QByteArray& buffer, qint64 clockSkew) { }
 
    void processNackPacket(ReceivedMessage& message, SharedNodePointer sendingNode);
 
public slots:
    void nodeKilled(SharedNodePointer node);
 
protected:
    using EditMessagePair = std::pair<PacketType, QByteArray>;
 
    void queuePacketToNode(const QUuid& nodeID, std::unique_ptr<NLPacket> packet);
    void queuePacketListToNode(const QUuid& nodeUUID, std::unique_ptr<NLPacketList> packetList);
 
    void queuePendingPacketToNodes(std::unique_ptr<NLPacket> packet);
    void queuePacketToNodes(std::unique_ptr<NLPacket> packet);
    std::unique_ptr<NLPacket> initializePacket(PacketType type, qint64 nodeClockSkew);
    void releaseQueuedPacket(const QUuid& nodeUUID, std::unique_ptr<NLPacket> packetBuffer); // releases specific queued packet
    void releaseQueuedPacketList(const QUuid& nodeID, std::unique_ptr<NLPacketList> packetList);
 
    void processPreServerExistsPackets();
 
    // These are packets which are destined from know servers but haven't been released because they're still too small
    // protected by _packetsQueueLock
    std::unordered_map<QUuid, PacketOrPacketList> _pendingEditPackets;
 
    // These are packets that are waiting to be processed because we don't yet know if there are servers
    int _maxPendingMessages;
    bool _releaseQueuedMessagesPending;
    QMutex _pendingPacketsLock;
    QRecursiveMutex _packetsQueueLock; // don't let different threads release the queue while another thread is writing to it
    std::list<EditMessagePair> _preServerEdits; // these will get packed into other larger packets
    std::list<std::unique_ptr<NLPacket>> _preServerSingleMessagePackets; // these will go out as is
 
    QMutex _releaseQueuedPacketMutex;
 
    // protected by _packetsQueueLock
    std::unordered_map<QUuid, SentPacketHistory> _sentPacketHistories;
    std::unordered_map<QUuid, quint16> _outgoingSequenceNumbers;
};
#endif // hifi_OctreeEditPacketSender_h