sortedchain.cpp

机甲指挥官2源代码

//
//###########################################################################
// FindImplementation
//###########################################################################
//
Plug*
	SortedChain::FindImplementation(
		const void *value
	)
{
	Check_Object(this);
	SortedChainLink *link;

	if ((link = SearchForValue(value)) != NULL)
	{
		Check_Object(link);
		return link->GetPlug();
	}
	return NULL;
}

//
//#############################################################################
// IsEmpty
//#############################################################################
//
bool
	SortedChain::IsEmpty()
{
	Check_Object(this);
	return (head == NULL);
}

//
//###########################################################################
// SearchForValue
//###########################################################################
//
SortedChainLink*
	SortedChain::SearchForValue(
		const void *value
	)
{
	Check_Object(this);
	SortedChainLink *link;
	int ret;
	
	for (link = head; link != NULL; link = link->next)
	{
		Check_Object(link);
		if ((ret = CompareValueToSortedChainLink(value, link)) == 0)
			break;
		if (ret < 0)
      	return(NULL);
	}
	return link;
}

//
//###########################################################################
// SortedChainIterator
//###########################################################################
//
SortedChainIterator::SortedChainIterator(SortedChain *vchain):
	SortedIterator(vchain)
{
	Check_Object(vchain);
	currentLink = vchain->head;
}

//
//###########################################################################
// SortedChainIterator
//###########################################################################
//
SortedChainIterator::SortedChainIterator(const SortedChainIterator *iterator):
	SortedIterator(Cast_Object(SortedChain*, iterator->socket))
{
	Check_Object(iterator);
	currentLink = iterator->currentLink;
}

Iterator*
	SortedChainIterator::MakeClone()
{
	Check_Object(this);
	return new SortedChainIterator(*this);
}

//
//###########################################################################
//###########################################################################
//
SortedChainIterator::~SortedChainIterator()
{
	Check_Object(this);
}

//
//###########################################################################
// TestInstance
//###########################################################################
//
void
	SortedChainIterator::TestInstance() const
{
	SortedIterator::TestInstance();
	
	if (currentLink != NULL)
	{
		Check_Object(currentLink);
	}
}

//
//###########################################################################
// First
//###########################################################################
//
void
	SortedChainIterator::First()
{
	Check_Object(this);
	currentLink = Cast_Object(SortedChain*, socket)->head;
}

//
//###########################################################################
// Last
//###########################################################################
//
void
	SortedChainIterator::Last()
{
	Check_Object(this);
	currentLink = Cast_Object(SortedChain*, socket)->tail;
}

//
//###########################################################################
// Next
//###########################################################################
//
void
	SortedChainIterator::Next()
{
	Check_Object(this);
	Check_Object(currentLink);
	currentLink = currentLink->next;
}

//
//###########################################################################
// Previous
//###########################################################################
//
void
	SortedChainIterator::Previous()
{
	Check_Object(this);
	Check_Object(currentLink);
	currentLink = currentLink->prev;
}

//
//###########################################################################
// ReadAndNextImplementation
//###########################################################################
//
void
	*SortedChainIterator::ReadAndNextImplementation()
{
	Check_Object(this);
	if (currentLink != NULL)
	{
		Plug *plug;

		Check_Object(currentLink);
		plug = currentLink->GetPlug();
		currentLink = currentLink->next;
		return plug;
	}
	return NULL;
}

//
//###########################################################################
// ReadAndPreviousImplementation
//###########################################################################
//
void
	*SortedChainIterator::ReadAndPreviousImplementation()
{
	Check_Object(this);
	if (currentLink != NULL) 
	{
		Plug *plug;
		
		Check_Object(currentLink);
		plug = currentLink->plug;
		currentLink = currentLink->prev;
		return plug;
	}
	return NULL;
}

//
//###########################################################################
// GetCurrentImplementation
//###########################################################################
//
void
	*SortedChainIterator::GetCurrentImplementation()
{
	Check_Object(this);
	if (currentLink != NULL) 
	{
		Check_Object(currentLink);
		return currentLink->GetPlug();
	}
	return NULL;
}

//
//###########################################################################
// GetSize
//###########################################################################
//
CollectionSize
	SortedChainIterator::GetSize()
{
	Check_Object(this);
	SortedChainLink *link;
	CollectionSize count;

	count = 0;
	for (
		link = Cast_Object(SortedChain*, socket)->head;
		link != NULL;
		link = link->next
	)
	{
		Check_Object(link);
		count++;
	}
	return count;
}

//
//###########################################################################
// GetNthImplementation
//###########################################################################
//
void
	*SortedChainIterator::GetNthImplementation(
		CollectionSize index
	)
{
	Check_Object(this);
	SortedChainLink *link;
	CollectionSize count;
	
	count = 0;
	for (
		link = Cast_Object(SortedChain*, socket)->head;
		link != NULL;
		link = link->next
	) 
	{
		Check_Object(link);
		if (count == index) 
		{
			currentLink = link;
			return currentLink->GetPlug();
		}
		count++;
	}
	return NULL;
}

//
//###########################################################################
// Remove
//###########################################################################
//
void
	SortedChainIterator::Remove()
{
	Check_Object(this);
	Check_Object(currentLink);
	Unregister_Object(currentLink);
	delete currentLink;
}

//
//###########################################################################
// FindImplementation
//###########################################################################
//
Plug*
	SortedChainIterator::FindImplementation(
		const void *value
	)
{
	Check_Object(this);
	SortedChainLink *link;
	
	if ((link = Cast_Object(SortedChain*, socket)->SearchForValue(value)) != NULL)
	{
		Check_Object(link);
		return (currentLink = link)->GetPlug();
	}
	return NULL;
}

//
//###########################################################################
// ReceiveMemo
//###########################################################################
//
void
	SortedChainIterator::ReceiveMemo(
		IteratorMemo memo,
		void *content
	)
{
	Check_Object(this);
	if (memo == PlugRemoved) 
	{
		if (content == currentLink)
		{
			Next();
		}
	}
}