Региональный поиск метод квадрантного дерева / src / CommonStructures

#include "stdafx.h"
#include "CommonStructures.h"

///////////////////////////////////////////////////////////
//Описание методов класса Point
///////////////////////////////////////////////////////////
//конструктор
Point::Point(POINTTYPE _x,POINTTYPE _y):
		x(_x),y(_y)
{
};

//индексное обращение к координате точки
POINTTYPE Point::operator[] (int i)
{
	if (i==0) return x;
		else 
			 return y;
}

//Операторы сравнения двух точек:
//на совпадение
int Point::operator== (Point &p)
{
	return (x==p.x) && (y==p.y);
}

//на несовпадение
int Point::operator!= (Point &p)
{
	return !(*this==p);
}

//операция "меньше"
int Point::operator< (Point &p)
{
	return ((x<p.x)||((x==p.x)&&(y<p.y)));
}

//операция "больше"
int Point::operator> (Point &p)
{
	return ((x>p.x)||((x==p.x)&&(y>p.y)));
}

Point Point::operator+(Point &p)
{
	return Point(x+p.x,y+p.y);
}


///////////////////////////////////////////////////////////
//Описание методов класса Rect
///////////////////////////////////////////////////////////
//конструктор
Rect::Rect(Point &_sw,Point &_ne):
		sw(_sw),ne(_ne)
{
};

//оператор преобразования
Rect::operator CRect()
{
	CRect rect((int)sw.x,(int)ne.y,(int)ne.x,(int)sw.y);

	return rect;
}


///////////////////////////////////////////////////////////
//Описание методов класса List
///////////////////////////////////////////////////////////

//конструктор
List::List(void):
	m_lenght(0)
{
	m_header=new ListNode(ELEMENT());
	m_current=m_header;
}

//конструктор копий
List::List(List &s):
	m_lenght(0)
{
	m_header=new ListNode(ELEMENT());
	for(s.First();!s.isHead();s.Next())
	{
		Append(ELEMENT(*s.Val()));
	};
}

//переопределение оператора присваивания
List& List::operator=(List &s)
{
	if (this==&s) return *this;

	while (Lenght()>0)
	{
		First();
		Remove();
	};
	delete m_header;

	m_header=new ListNode();
	for(s.First();!s.isHead();s.Next())
	{
		Append(ELEMENT(*s.Val()));
	};

	return *this;
}

//деструктор
List::~List(void)
{
	while (Lenght()>0) 
	{
	 First();
	 Remove();
	}
	delete m_header;
}

//оператор обращения к точке по индексу
ELEMENT List::operator[](int i)
{
	if ((i<0)||(i>Lenght())) return ELEMENT(0,0);
	First();
	for(int j=0;j<i;j++) Next();

	return *Val();
}


//вставка нового элемента
void List::Insert(ELEMENT& val)
{
	ListNode *tmp=new ListNode(val);
	m_current->Insert(tmp);
	++m_lenght;
}

//добавление нового элемента в конец списка
void List::Append(ELEMENT &val)
{
	m_header->Prev()->Insert(new ListNode(val));
	++m_lenght;
}

//добавление нового элемента в начало списка
void List::Prepend(ELEMENT& val)
{
	m_header->Insert(new ListNode(val));
	++m_lenght;
}

//удаление текущего элемента
void List::Remove(void)
{
	m_current=(ListNode*)m_current->Prev();
	delete (ListNode*)m_current->Next()->Remove();
	--m_lenght;
}

//инициализация текущего элемента списка
void List::Val(ELEMENT& val)
{
	if (m_current!=m_header)
	 m_current->m_val=val;
}

//получение значения текущего элемента списка
ELEMENT* List::Val(void)
{
	return &m_current->m_val;
}

//переход на следующий элемент списка
ELEMENT* List::Next(void)
{
	m_current=(ListNode*)m_current->Next();
	return &m_current->m_val;
}

//переход на предшествующий элемент списка
ELEMENT* List::Prev(void)
{
	m_current=(ListNode*)m_current->Prev();
	return &m_current->m_val;
}

//переход на первый элемент списка
ELEMENT* List::First(void)
{
	m_current=(ListNode*)m_header->Next();
	return &m_current->m_val;
}

//переход на последний элемент списка
ELEMENT* List::Last(void)
{
	m_current=(ListNode*)m_header->Prev();
	return &m_current->m_val;
}

//получение количества элементов в списке
int List::Lenght(void)
{
	return m_lenght;
}

//проверка: является ли текущий элемент списка первым
int List::isFirst(void)
{
	return ((m_current==m_header->Next())&&(m_lenght>0));
}

//проверка: является ли текущий элемент списка последним
int List::isLast(void)
{
	return ((m_current==m_header->Prev())&&(m_lenght>0));
}

//проверка: является ли текущий элемент списка головным
int List::isHead(void)
{
	return (m_current==m_header);
}

ListNode* List::GetCurrentNode()
{
	return m_current;
}


///////////////////////////////////////////////////////////
//Описание методов класса ListNode
///////////////////////////////////////////////////////////
//конструктор
ListNode::ListNode(ELEMENT& val):
	m_val(val),
	m_next(this),
	m_prev(this)
{
}

//деструктор
ListNode::~ListNode()
{
}

//переход на следующий элемент
ListNode* ListNode::Next(void)
{
	return m_next;
}

//переход на предшествующий элемент
ListNode* ListNode::Prev(void)
{
	return m_prev;
}

//вставка нового элемента
ListNode* ListNode::Insert(ListNode *Ins)
{
	ListNode *Tmp=m_next;
	Ins->m_prev=this;
	Ins->m_next=Tmp;
	m_next=Ins;
	Tmp->m_prev=Ins;

	return Tmp;
}

//удаление элемента
ListNode* ListNode::Remove(void)
{
	m_prev->m_next=m_next;
	m_next->m_prev=m_prev;
	m_next=m_prev=this;

	return this;
};