#include <stdlib.h>
#include <semaphore.h>
#include <iostream>
int MaxLength[100];
int maxx[100];
int minx[100];
double maxp[100];
#define RAND_MAX 0x7fff
using namespace std;

int Test(int number,int PacketLength);
int RED(int number);
void Discard(char *packet);
double AverageRandom(double minx,double maxx);
void QueueManage(char *packet,int PacketLength,int number);

struct Cdata
{
char *ptrpacket;
int length;
};
class Cnode
{
public:
Cdata *pack;
Cnode *next;
public:
Cnode(Cdata *pData);
~Cnode();
};

Cnode::Cnode(Cdata *pData){
this->pack=pData;
this->next=NULL;
};
Cnode::~Cnode(){
this->pack=NULL;
delete this->pack;
this->next=NULL;
delete this->next;
};

class Clist
{
private:
sem_t* ptrSemaphore;
public:
Cnode* Head;
Cnode* Tail;
int QueueLength;
public:
void AddNodeEnd(char *packet,int PacketLength);
void DelNodeSta();
Clist ();
~ Clist ();
};

Clist:: Clist ()
{
Head=Tail=NULL;
sem_init(ptrSemaphore,0,1);
QueueLength=0;
};

Clist::~ Clist ()
{
Head=Tail=NULL;
sem_destroy(ptrSemaphore);
delete Head;
delete Tail;
QueueLength=0;
};
void Clist::AddNodeEnd(char *packet,int PacketLength)
{
//将收到的数据包指针和队列长度构成节点插在数组元素Tail[number]后
//用信号量进行互斥操作
sem_wait(ptrSemaphore);

if (Head==NULL && Tail==NULL)
{
Cdata *p=new Cdata;
p->ptrpacket=packet;
p->length=PacketLength;
// init data
Cnode *pNode ;
pNode=new Cnode(p);
Tail=pNode;
Head=pNode;
QueueLength=QueueLength+pNode->pack->length;
}
else
{
Cdata *p = new Cdata;
p->ptrpacket=packet;
p->length=PacketLength;
// init data
Cnode *pNode ;
pNode=new Cnode(p);
Tail->next=pNode;
Tail=pNode;
//改变当前队列长度数组ListArray[number]->QueueLength的值
QueueLength=QueueLength+pNode->pack->length;
};
sem_post(ptrSemaphore);
};

void Clist::  DelNodeSta()
{
//删除number所指向队列中的头节点
Cnode *x;
sem_wait(ptrSemaphore);
x=Head;
Head=x->next;
if (Head==NULL)
{
Tail=NULL;
};
x->next=NULL;
QueueLength= QueueLength-x->pack->length;
delete x;
sem_post(ptrSemaphore);
};

Clist *ListArray=new Clist[100];

void QueueManage(char *packet,int PacketLength,int number)
{
//本模块的主程序，由收发模块调用
//调用Test函数
//若Test返回值为真，调用RED算法函数，若返回真(1)则调用AddNodeEnd函数，返回假(0)则调用Discard函数

if (Test(number,PacketLength)==1)
{
if (RED(number)==1)
{
ListArray[number].AddNodeEnd(packet,PacketLength);
}
else Discard(packet);
}
//若Test返回值为假，则调用Discard函数
else Discard(packet);
};

int Test(int number,int PacketLength)
{
//由输入的队列号number获取最大的队列长度MaxLength
//若当前队列长度加上本次收到的包的长度即(ListArray[number]->QueueLength+PacketLength)大于最大队列长度(MaxLength)，则返回假
if ((ListArray[number].QueueLength+PacketLength)>MaxLength[number])
{
return 0;
}
//否则返回真
else return 1;
};

void Discard(char *packet)
{
//释放数据包的指针
delete packet;
};

int RED(int number)
{
double s,p;
//将当前队列长度ListArray[number]->QueueLength与maxx和minx进行比较，若〉maxx则调用Discard函数，若<则调用AddNodeEnd函数
if ((ListArray[number].QueueLength)>=(maxx[number]))
{return 0;}
if ((ListArray[number].QueueLength)<=(minx[number])) {return 1;}
//若minx[number]< ListArray[number]->QueueLength <maxx[number],则以概率p进行存储
if ((minx[number]< ListArray[number].QueueLength) && (ListArray[number].QueueLength<maxx[number]))
{
p=maxp[number]*(ListArray[number].QueueLength-minx[number])/(maxx[number]-minx[number]);

//生成（0，1）之间的随机数s
s= AverageRandom(0,1);
if (s>=p)
{return 0;}
else return 1;
}
//TODO::
return 0;
};

double AverageRandom(double minx,double maxx)
{
int minInteger=(int)(minx*10000);
int maxInteger=(int)(maxx*10000);
int randInteger=rand()*rand();
int diffInteger=maxInteger-minInteger;
int resultInteger=randInteger%diffInteger+minInteger;
return resultInteger/10000.0;
};
void PacketSwitching(int number)
{
ListArray[number].DelNodeSta();
}

void main(){
char *p=new char[255];
strcpy(p,"abc123");
char *q=new char[255];
strcpy(q,"abc");

ListArray[50].QueueLength=80;
minx[50]=20;
maxx[50]=70;
maxp[50]=0.9;
MaxLength[50]=200;
QueueManage(q,10,50);
QueueManage(p,10,50);

cout<<ListArray[50].QueueLength<<endl;
if( ListArray[50].Head )
cout<<ListArray[50].Head->pack->ptrpacket<<endl;
}

Head=Tail=NULL: