DataStructures::RangeList< range_type > Class Template Reference

#include <DS_RangeList.h>

Inheritance diagram for DataStructures::RangeList< range_type >:

List of all members.

Public Member Functions
void	Clear (void)
bool	Deserialize (RakNet::BitStream *out)
void	Insert (range_type index)
	RangeList ()
unsigned	RangeSum (void) const
RakNet::BitSize_t	Serialize (RakNet::BitStream *in, RakNet::BitSize_t maxBits, bool clearSerialized)
unsigned	Size (void) const
	~RangeList ()
Public Attributes
DataStructures::OrderedList < range_type, RangeNode < range_type >, RangeNodeComp < range_type > >	ranges

---

Detailed Description

template<class range_type>
class DataStructures::RangeList< range_type >

Definition at line 42 of file DS_RangeList.h.

---

Constructor & Destructor Documentation

template<class range_type >

DataStructures::RangeList< range_type >::RangeList

(

)

Definition at line 140 of file DS_RangeList.h.

    {
        RangeNodeComp<range_type>(0, RangeNode<range_type>());
    }

template<class range_type >

DataStructures::RangeList< range_type >::~RangeList

(

)

Definition at line 146 of file DS_RangeList.h.

    {
        Clear();
    }

---

Member Function Documentation

template<class range_type >

void DataStructures::RangeList< range_type >::Clear

(

void

)

Definition at line 214 of file DS_RangeList.h.

References _FILE_AND_LINE_.

    {
        ranges.Clear(true, _FILE_AND_LINE_);
    }

template<class range_type >

bool DataStructures::RangeList< range_type >::Deserialize

(

RakNet::BitStream *

out

)

Definition at line 108 of file DS_RangeList.h.

References _FILE_AND_LINE_, RakNet::BitStream::AlignReadToByteBoundary(), and RakNet::BitStream::Read().

    {
        ranges.Clear(true, _FILE_AND_LINE_);
        unsigned short count;
        out->AlignReadToByteBoundary();
        out->Read(count);
        unsigned short i;
        range_type min,max;
        unsigned char maxEqualToMin=0;

        for (i=0; i < count; i++)
        {
            out->Read(maxEqualToMin);
            if (out->Read(min)==false)
                return false;
            if (maxEqualToMin==false)
            {
                if (out->Read(max)==false)
                    return false;
                if (max<min)
                    return false;
            }
            else
                max=min;


            ranges.InsertAtEnd(RangeNode<range_type>(min,max), _FILE_AND_LINE_);
        }
        return true;
    }

template<class range_type>

void DataStructures::RangeList< range_type >::Insert

(

range_type

index

)

Definition at line 152 of file DS_RangeList.h.

References _FILE_AND_LINE_.

    {
        if (ranges.Size()==0)
        {
            ranges.Insert(index, RangeNode<range_type>(index, index), true, _FILE_AND_LINE_);
            return;
        }

        bool objectExists;
        unsigned insertionIndex=ranges.GetIndexFromKey(index, &objectExists);
        if (insertionIndex==ranges.Size())
        {
            if (index == ranges[insertionIndex-1].maxIndex+(range_type)1)
                ranges[insertionIndex-1].maxIndex++;
            else if (index > ranges[insertionIndex-1].maxIndex+(range_type)1)
            {
                // Insert at end
                ranges.Insert(index, RangeNode<range_type>(index, index), true, _FILE_AND_LINE_);
            }

            return;
        }

        if (index < ranges[insertionIndex].minIndex-(range_type)1)
        {
            // Insert here
            ranges.InsertAtIndex(RangeNode<range_type>(index, index), insertionIndex, _FILE_AND_LINE_);

            return;
        }
        else if (index == ranges[insertionIndex].minIndex-(range_type)1)
        {
            // Decrease minIndex and join left
            ranges[insertionIndex].minIndex--;
            if (insertionIndex>0 && ranges[insertionIndex-1].maxIndex+(range_type)1==ranges[insertionIndex].minIndex)
            {
                ranges[insertionIndex-1].maxIndex=ranges[insertionIndex].maxIndex;
                ranges.RemoveAtIndex(insertionIndex);
            }

            return;
        }
        else if (index >= ranges[insertionIndex].minIndex && index <= ranges[insertionIndex].maxIndex)
        {
            // Already exists
            return;
        }
        else if (index == ranges[insertionIndex].maxIndex+(range_type)1)
        {
            // Increase maxIndex and join right
            ranges[insertionIndex].maxIndex++;
            if (insertionIndex<ranges.Size()-1 && ranges[insertionIndex+(range_type)1].minIndex==ranges[insertionIndex].maxIndex+(range_type)1)
            {
                ranges[insertionIndex+1].minIndex=ranges[insertionIndex].minIndex;
                ranges.RemoveAtIndex(insertionIndex);
            }

            return;
        }
    }

template<class range_type >

unsigned DataStructures::RangeList< range_type >::RangeSum

(

void

)

const

Definition at line 226 of file DS_RangeList.h.

    {
        unsigned sum=0,i;
        for (i=0; i < ranges.Size(); i++)
            sum+=ranges[i].maxIndex-ranges[i].minIndex+1;
        return sum;
    }

template<class range_type >

RakNet::BitSize_t DataStructures::RangeList< range_type >::Serialize	(	RakNet::BitStream *	in,
		RakNet::BitSize_t	maxBits,
		bool	clearSerialized
	)

Definition at line 58 of file DS_RangeList.h.

References RakNet::BitStream::AlignWriteToByteBoundary(), RakNet::BitStream::GetNumberOfBitsUsed(), RakNet::BitStream::GetWriteOffset(), RakAssert, and RakNet::BitStream::Write().

    {
        RakAssert(ranges.Size() < (unsigned short)-1);
        RakNet::BitStream tempBS;
        RakNet::BitSize_t bitsWritten;
        unsigned short countWritten;
        unsigned i;
        countWritten=0;
        bitsWritten=0;
        for (i=0; i < ranges.Size(); i++)
        {
            if ((int)sizeof(unsigned short)*8+bitsWritten+(int)sizeof(range_type)*8*2+1>maxBits)
                break;
            unsigned char minEqualsMax;
            if (ranges[i].minIndex==ranges[i].maxIndex)
                minEqualsMax=1;
            else
                minEqualsMax=0;
            tempBS.Write(minEqualsMax); // Use one byte, intead of one bit, for speed, as this is done a lot
            tempBS.Write(ranges[i].minIndex);
            bitsWritten+=sizeof(range_type)*8+8;
            if (ranges[i].minIndex!=ranges[i].maxIndex)
            {
                tempBS.Write(ranges[i].maxIndex);
                bitsWritten+=sizeof(range_type)*8;
            }
            countWritten++;
        }

        in->AlignWriteToByteBoundary();
        RakNet::BitSize_t before=in->GetWriteOffset();
        in->Write(countWritten);
        bitsWritten+=in->GetWriteOffset()-before;
    //  RAKNET_DEBUG_PRINTF("%i ", in->GetNumberOfBitsUsed());
        in->Write(&tempBS, tempBS.GetNumberOfBitsUsed());
    //  RAKNET_DEBUG_PRINTF("%i %i \n", tempBS.GetNumberOfBitsUsed(),in->GetNumberOfBitsUsed());

        if (clearSerialized && countWritten)
        {
            unsigned rangeSize=ranges.Size();
            for (i=0; i < rangeSize-countWritten; i++)
            {
                ranges[i]=ranges[i+countWritten];
            }
            ranges.RemoveFromEnd(countWritten);
        }

        return bitsWritten;
    }

template<class range_type >

unsigned DataStructures::RangeList< range_type >::Size

(

void

)

const

Definition at line 220 of file DS_RangeList.h.

    {
        return ranges.Size();
    }

---

Member Data Documentation

template<class range_type>

DataStructures::OrderedList<range_type, RangeNode<range_type> , RangeNodeComp<range_type> > DataStructures::RangeList< range_type >::ranges

Definition at line 54 of file DS_RangeList.h.

---

The documentation for this class was generated from the following file:

• DS_RangeList.h