ModelSelect.cpp

#include "Headers.h"
#include "ModelSelect.h"

CModelSelect::CModelSelect(
    __uint32    numChannels,
    __uint32    numLayers,
    __uint32    numPeers
    )
{
    assert(numChannels);
    assert(numLayers);
    assert(numPeers);
    assert(peers);

    this->numChannels = numChannels;
    this->numLayers = numLayers;
    this->numPeers = numPeers;
    
    // Peers
    this->peers = new CPeer[this->numPeers];

    // Channels index
    this->index = new set<CPeer*>[numChannels];
}

CModelSelect::~CModelSelect()
{
    delete[] this->peers;
    delete[] this->index;
}

__uint32 CModelSelect::Add(__uint32 channel, __uint32 peer, __time timestamp, __time duration)
{
    assert(channel < this->numChannels);

    // Add peer to the index
    this->index[channel].insert(&this->peers[peer]);

    // Set the channel and return the session number
    return this->peers[peer].SetChannel(channel, timestamp, duration);
}

void CModelSelect::Add(__uint32 session, __uint32 channel, __uint32 peer)
{
    // Return, if the request is for a different session
    if(session != this->peers[peer].Session()) return;

    // Check the channel
    assert(channel == this->peers[peer].Channel());

    // Add peer to the index
    this->index[channel].insert(&this->peers[peer]);
}

void CModelSelect::Remove(__uint32 session, __uint32 channel, __uint32 peer)
{
    // Return, if the request is for a different session
    if(session != this->peers[peer].Session()) return;

    // Check the channel
    assert(channel == this->peers[peer].Channel());

    // Remove the peer from the index
    this->index[channel].erase(&this->peers[peer]);
}

void CModelSelect::Clear()
{
    for(__uint32 channel = 0; channel < this->numChannels; channel++)
        this->index[channel].clear();
}

CPeer** CModelSelect::SelectOptimal(__time time, __uint32 channel, __uint32 child)
{
    // Select the optimal parent based on child remaining time : 
    // Search for the parent with the maximum remaining time less that the child remaining time 
    // and the minimum remaining time greater that the child remaining time
    assert(channel < this->numChannels);
    assert(child < this->numPeers);

    CPeer* peerChild = &this->peers[child];

    for(__uint32 layer = 0; layer < this->numLayers; layer++)
    {
        __time remainingGreater = 1E300;
        __time remainingLess = 0;

        CPeer* peerGreater = NULL;
        CPeer* peerLess = NULL;

        for(set<CPeer*>::iterator iter = this->index[channel].begin(); iter != this->index[channel].end(); iter++)
        {
            // Get the parent peer
            CPeer* peerParent = *iter;
            
            if(!this->IsResult(peerParent, layer)) // Check the peer was not selected parent for a previous layers
            {   
                if(peerChild->VerifyParent(channel, layer, peerParent)) // Check the parent
                {
                    if(peerParent->Remaining(time, channel) >= peerChild->Remaining(time, channel))
                    {
                        // Found a peer with a remaining time greater or equal to the child remaining time
                        if(peerParent->Remaining(time, channel) < remainingGreater)
                        {
                            peerGreater = peerParent;
                            remainingGreater = peerParent->Remaining(time, channel);
                        }
                    }
                    else
                    {
                        // Found a peer with a remaining time less than the child remaining time
                        if(peerParent->Remaining(time, channel) > remainingLess)
                        {
                            peerLess = peerParent;
                            remainingLess = peerParent->Remaining(time, channel);
                        }
                    }
                }
            }
        }

        this->result[layer] = peerGreater ? peerGreater : peerLess;
    }

    return this->result;
}

CPeer* CModelSelect::SelectOptimal(__time time, __uint32 channel, __uint32 layer, __uint32 child)
{
    // Select the optimal parent based on child remaining time : 
    // Search for the parent with the maximum remaining time less that the child remaining time 
    // and the minimum remaining time greater that the child remaining time
    assert(channel < this->numChannels);
    assert(child < this->numPeers);

    CPeer* peerChild = &this->peers[child];

    __time remainingGreater = 1E300;
    __time remainingLess = 0;

    CPeer* peerGreater = NULL;
    CPeer* peerLess = NULL;

    for(set<CPeer*>::iterator iter = this->index[channel].begin(); iter != this->index[channel].end(); iter++)
    {
        // Get the parent peer
        CPeer* peerParent = *iter;
            
        if(!this->IsResult(peerParent, layer)) // Check the peer was not selected parent for a previous layers
        {   
            if(peerChild->VerifyParent(channel, layer, peerParent)) // Check the parent
            {
                if(peerParent->Remaining(time, channel) >= peerChild->Remaining(time, channel))
                {
                    // Found a peer with a remaining time greater or equal to the child remaining time
                    if(peerParent->Remaining(time, channel) < remainingGreater)
                    {
                        peerGreater = peerParent;
                        remainingGreater = peerParent->Remaining(time, channel);
                    }
                }
                else
                {
                    // Found a peer with a remaining time less than the child remaining time
                    if(peerParent->Remaining(time, channel) > remainingLess)
                    {
                        peerLess = peerParent;
                        remainingLess = peerParent->Remaining(time, channel);
                    }
                }
            }
        }
    }

    return peerGreater ? peerGreater : peerLess;
}

bool CModelSelect::IsResult(CPeer* peer, __uint32 layer)
{
    for(__uint32 idx = 0; idx < layer; idx++)
        if(this->result[idx] == peer)
            return true;
    return false;
}