#include "munga.h"
#pragma hdrstop

#include "socket.h"

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Socket ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//
//#############################################################################
// Socket
//#############################################################################
//
Socket::Socket(Node *node)
{
	socketsNode = node;
   // Warn(socketsNode == NULL);
}

//
//#############################################################################
// ~Socket
//#############################################################################
//
Socket::~Socket()
{
}

//
//#############################################################################
// TestInstance
//#############################################################################
//
Logical
	Socket::TestInstance() const
{
	return True;
}

//
//#############################################################################
// AddImplementation
//#############################################################################
//
void
   Socket::AddImplementation(Plug*)
{
	Fail("Socket::AddImplementation - Should never reach here");
}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ SocketIterator ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

//
//#############################################################################
//#############################################################################
//
SocketIterator::SocketIterator(Socket *socket)
{
	this->socket = socket;
}

//
//#############################################################################
//#############################################################################
//
SocketIterator::~SocketIterator()
{
}

//
//#############################################################################
// TestInstance
//#############################################################################
//
Logical
	SocketIterator::TestInstance() const
{
	return True;
}

//
//#############################################################################
// Remove
//#############################################################################
//
void
	SocketIterator::Remove()
{
	Fail("SocketIterator::Remove - Should never reach here");
}

//
//#############################################################################
// IsPlugMember
//#############################################################################
//
Logical
	SocketIterator::IsPlugMember(
		Plug *find_plug
	)
{
	Plug *plug;

	First();
	while ((plug = ReadAndNextPlug()) != NULL)
	{
		Check(plug);
		if (plug == find_plug)
			return True;
	}
	return False;
}

//
//#############################################################################
// RemovePlug
//#############################################################################
//
void
	SocketIterator::RemovePlug(
		Plug *find_plug
	)
{
	Plug *plug;

	Check(find_plug);
	First();
	while ((plug = GetCurrentPlug()) != NULL)
	{
		Check(plug);
		if (plug == find_plug)
		{
			Remove();
			return;
		}
		Next();
	}
}

//
//#############################################################################
// DeletePlugs
//#############################################################################
//
void
	SocketIterator::DeletePlugs(Logical defeat_release_node)
{
	Plug *plug;
	Node *save_release_node;

	if (defeat_release_node)
	{
   	Check(socket);
		save_release_node = socket->GetReleaseNode();
		socket->SetReleaseNode(NULL);
	}

	First();
	while ((plug = ReadAndNextPlug()) != NULL)
	{
		Unregister_Object(plug);
		delete plug;
	}
	#if 0
	while ((plug = GetCurrentPlug()) != NULL)
	{
		Unregister_Object(plug);
		delete plug;
	}
	#endif

	if (defeat_release_node)
	{
   	Check(socket);
		socket->SetReleaseNode(save_release_node);
	}
}

//
//#############################################################################
// SendPlugCommand
//#############################################################################
//

// Considering removal
#if 0
int
	SocketIterator::SendPlugCommand(
		Plug::CommandID plugCommand,
		void *info
	)
{
	int ret;
	Plug *plug;

	First();
	while ((plug = GetCurrentPlug()) != NULL)
	{
		Check(plug);
		if (
			(ret = plug->ReceivePlugCommand(plugCommand, info)) !=
			IteratorFunctionNullReturn
		)
			return ret;
		Next();
	}
	return IteratorFunctionNullReturn;
}
#endif

//
//#############################################################################
// RunIteratorFunction
//#############################################################################
//

// Considering removal
#if 0
int
	SocketIterator::RunIteratorFunction(
		IteratorFunction iteratorFunction,
		void *info
	)
{
	int ret;
	Plug *plug;

	Check_Pointer(iteratorFunction);

	First();
	while ((plug = GetCurrentPlug()) != NULL)
	{
		Check(plug);
		if (
			(ret = (*iteratorFunction)(plug, info)) !=
			IteratorFunctionNullReturn
		)
			return ret;
		Next();
	}
	return IteratorFunctionNullReturn;
}
#endif

//
//#############################################################################
// InsertImplementation
//#############################################################################
//
void
	SocketIterator::InsertImplementation(Plug*)
{
	//
	// Should never reach here
	//
	Fail("SocketIterator::InsertImplementation - Should never reach here");
}