class TSharedTask;
//декларируем класс задания, т.к. мы будем работать с указателями на экземпляры этого класса
class TSharedLink;
//декларируем класс звена, т.к. мы будем работать с указателями на экземпляры этого класса

define PTSharedTask TSharedTask*;
define PTSharedLink TSharedLink*;

class TSharedLink{
//класс звена в очереди заданий
private:
 PTSharedTask pTask;
 //указатель на задание
 PTSharedLink pPrev;
 //указатель на предыдущее звено
 PTSharedLink pNext;
 //указатель на следующее звено
public:
 TSharedLink(void);
 ~TSharedLink(void);
 void SetTask(PTSharedTask pNewTask);
 void SetNext(PTSharedLink pNewNext);
 void SetPrev(PTSharedLink pNewPrev);
 PTSharedTask GetTask(void);
 PTSharedLink GetNext(void);
 PTSharedLink GetPrev(void);
};

class TSharedQueue:public TSharedLink{
private:
 PTSharedLink pFirst;
 //указатель на первое звено
 PTSharedLink pCurr;
 //указатель на текущее звено
public:
 TSharedQueue(void);
 ~TSharedQueue(void);
 void SetTask(PTSharedTask pNewTask);
 void AddPrevTask(PTSharedTask pNewTask);
 void AddNextTask(PTSharedTask pNewTask);
 void DelPrevTask();
 void DelCurrTask();
 void DelNextTask();
 void Reset();
 void GoNext();
 void GoPrev();
 PTSharedTask GetTask(void);
};


//Begin of TSharedLink implementation

TSharedLink::TSharedLink(void){
 //В принципе, в этом конструкторе ничего не нужно...
}

TSharedLink::~TSharedLink(void){
 //А вот тут нужно удалить само задание... Память высвобождать надо.
 delete pTask; 
}

void TSharedLink::SetTask(PTSharedTask pNewTask){
 pTask=pNewTask;
}

void TSharedLink::SetNext(PTSharedLink pNewNext){
 pNext=pNewNext;
}

void TSharedLink::SetPrev(PTSharedLink pNewPrev){
 pPrev=pNewPrev;
}

PTSharedTask TSharedLink::GetTask(void){
 return pTask;
}

PTSharedLink TSharedLink::GetNext(void){
 return pNext;
}

PTSharedLink TSharedLink::GetPrev(void){
 return pPrev;
}

//End of TSharedLink implementation

//Begin of TSharedQueue implementation

TSharedQueue::TSharedQueue(void){
 //Создаем служебное звено и "замыкаем" его на себя
 PTSharedTask pFirstTask;
 pFirstTask=new TSharedTask();
 pFirst=new TSharedLink();
 pFirst->pTask=pFirstTask;
 pFirst->pPrev=pFirst;
 pFirst->pNext=pFirst;
 pCurr=pFirst;
}

TSharedQueue::~TSharedQueue(void){
 PTSharedLink pTemp;
 pCurr=pFirst->pNext;
 while(pCurr!=pFirst){
  pTemp=pCurr->pNext;
  delete pCurr;
  pCurr=pTemp;
 }
 delete pFirst;
}

void TSharedQueue::SetTask(PTSharedTask pNewTask){
 pCurr->pTask=pNewTask;
}

void TSharedQueue::AddPrevTask(PTSharedTask pNewTask){
 PTSharedLink pTemp,pTemp2;
 pTemp=new TSharedLink();
 pTemp->pTask=pNewTask;
 pTemp2=pCurr->pPrev;
 pTemp2->pNext=pTemp;
 pCurr->pPrev=pTemp;
}

void TSharedQueue::AddNextTask(PTSharedTask pNewTask){
 PTSharedLink pTemp,pTemp2;
 pTemp=new TSharedLink();
 pTemp->pTask=pNewTask;
 pTemp2=pCurr->pNext;
 pTemp2->pPrev=pTemp;
 pCurr->pNext=pTemp;
}

void TSharedQueue::DelPrevTask(){
 PTSharedLink pTemp,pTemp2;
 pTemp=pCurr->pPrev;
 pTemp2=pTemp->pPrev;
 pTemp2->pNext=pCurr;
 pCurr->pPrev=pTemp2;
 delete pTemp;
}

void TSharedQueue::DelCurrTask(){
 PTSharedLink pTemp,pTemp2;
 pTemp=pCurr->pPrev;
 pTemp2=pCurr->pNext;
 pTemp2->pPrev=pTemp;
 pTemp->pNext=pTemp2;
 delete pCurr;
 pCurr=pTemp;
 //Тут спорная позиция. Если удаляем текущее задание,
 //то новым текущим может стать как предыдущее, так и
 //следующее. По умолчанию, поставим предыдущее.
}

void TSharedQueue::DelNextTask(){
 PTSharedLink pTemp,pTemp2;
 pTemp=pCurr->pNext;
 pTemp2=pTemp->pNext;
 pTemp2->pPrev=pCurr;
 pCurr->pNext=pTemp2;
 delete pTemp;
}

void TSharedQueue::Reset(){
 pCurr=pFirst;
}

void TSharedQueue::GoNext(){
 pCurr=pCurr->pNext;
}

void TSharedQueue::GoPrev(){
 pCurr=pCurr->pPrev;
}

PTSharedTask TSharedQueue::GetTask(void){
 return pCurr->pTask;
}

//End of TSharedQueue implementation