src/network/nPriorizing.h File Reference

#include "defs.h"
#include "tHeap.h"

Include dependency graph for nPriorizing.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	nBandwidthTaskPriorizer
class	nBandwidthArbitrator
class	nBandwidthSceduler
class	nBandwidthTaskObject
class	nBandwidthTaskSync
class	nBandwidthTaskCreate
Functions
	tDECLARE_REFOBJ (nBandwidthTask) tDECLARE_REFOBJ(nBandwidthArbitrator) class nBandwidthTask

---

Function Documentation

tDECLARE_REFOBJ

(

nBandwidthTask

)

Definition at line 41 of file nPriorizing.h.

References buffer, dt, and REAL.

                    : public tHeapElement, public tReferencable< nBandwidthTask >
{
    friend class tReferencable< nBandwidthTask >;
    friend class nBandwidthTaskPriorizer;

public:
    enum nType
    {
        Type_System = 0,                                                        // extremely important task for the integrety of the connection
        Type_Vital  = 1,                                                        // task important for someone's survival in the game
        Type_Casual = 2,                                                        // not so important task
        Type_Count  = 3
    };

    void Execute( nSendBuffer& buffer, nBandwidthControl& control )             {       this->DoExecute( buffer, control );     }                               // executes the small task
    void Priorize()                                                                                                             {       if ( this->priorizer_ ) this->DoPriorize(); }           // rethinks priority

    int         EstimateSize    ( void          ) const {       return this->DoEstimateSize(); }        // estimate bandwidth usage

    nType       Type                    ( void          ) const {       return type_;           }                               // returns the type of task
    REAL        Priority                ( void          ) const {       return priority_;       }                               // returns the priority ( event gets important after 1/priority_ seconds )

    void        SetType                 ( nType t       );                                                                                              // sets the task type
    void        AddPriority             ( REAL add      )               { priority_ += add; this->Priorize(); } // adds priority
void    Timestep                ( REAL dt       )               { waiting_ += dt;       this->Priorize(); }     // adds time

protected:
    virtual void DoExecute( nSendBuffer& buffer, nBandwidthControl& control ) = 0;                              // executes whatever it has to do
    virtual int  DoEstimateSize() const = 0;                                                                                                    // estimate bandwidth usage
    virtual void DoPriorize();                                                                                                                                  // rethinks priority

    virtual tHeapBase *Heap() const;                                                                                                                    // in wich heap are we?

    virtual ~nBandwidthTask();
    nBandwidthTask( nType type );
private:
    nType type_;                                                                        // type of this task
    REAL priority_;                                                                     // something terrible happens if this task is not executed within 1/priority_ seconds
    REAL waiting_;                                                                      // time this task is already waiting ( plus small offset )
    nBandwidthTaskPriorizer* priorizer_;                        // the arbitrator taking care of this task
};

---