// Copyright (C) 2004-2005 Open Source Telecom Corporation.
//  
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software 
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however    
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.    
//
// This exception applies only to the code released under the name GNU
// Common C++.  If you copy code from other releases into a copy of GNU
// Common C++, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU Common C++, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#include <cc++/config.h>
#include <cc++/export.h>
#include <cc++/thread.h>
#include <cc++/misc.h>
#include "private.h"

#ifdef	CCXX_NAMESPACES
namespace ost {
#endif

Runlist::Runlist(unsigned count) :
Mutex()
{
	first = last = NULL;
	limit = count;
	used = 0;
}

void Runlist::del(Runable *run)
{
	enter();
	if(run->list != this)
	{
		leave();
		return;
	}

	if(!run->next && !run->prev)
	{
		if(first == run && last == run)
			first = last = NULL;
		else
			--used;
		run->list = NULL;
		leave();
		check();
		return;
	}

	if(run->next)
		run->next->prev = run->prev;
	else
		last = run->prev;

	if(run->prev)
		run->prev->next = run->next;
	else
		first = run->next;

	run->list = NULL;
	run->next = run->prev = NULL;
	leave();
	check();
	return;
}

void Runlist::set(unsigned count)
{
	limit = count;
	check();
}

bool Runlist::add(Runable *run)
{
	if(run->list)
		run->list->del(run);

	run->list = this;

	enter();
	if(used < limit)
	{
		++used;
		leave();
		return true;
	}
	run->next = NULL;
	if(last)
	{
		run->prev = last;
		last = run;
	}
	else		
	{
		run->prev = NULL;
		first = last = run;
	}
	leave();
	return false;
}

void Runlist::check(void)
{
	Runable *run;

	for(;;)
	{
		enter();
		if(used >= limit || !first)
		{
			leave();
			return;
		}
		run = first;
		first = run->next;
		if(first)
			first->prev = NULL;		
		else
			last = NULL;
		run->next = run->prev = NULL;
		if(run->list == this)
			++used;
		else 
			run = NULL;
		leave();
		if(run)
			run->ready();
	}
}

Runable::Runable()
{
	list = NULL;
	next = prev = NULL;
}

bool Runable::starting(Runlist *list)
{
	stoping();
	return list->add(this);
}

void Runable::stoping(void)
{
	if(list)
		list->del(this);
}

Runable::~Runable()
{
	stoping();
}

#ifdef	CCXX_NAMESPACES
}
#endif		
	
/** EMACS **
 * Local variables:
 * mode: c++
 * c-basic-offset: 8
 * End:
 */
