/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef UNIX_ADDRESS_MANAGER_H
#define UNIX_ADDRESS_MANAGER_H

#include <lock.h>
#include <util/OpenHashTable.h>

#include "UnixAddress.h"
#include "UnixEndpoint.h"


struct UnixAddressHashDefinition {
	typedef UnixAddress		KeyType;
	typedef UnixEndpoint	ValueType;

	size_t HashKey(const KeyType& key) const
	{
		return key.HashCode();
	}

	size_t Hash(UnixEndpoint* endpoint) const
	{
		return HashKey(endpoint->Address());
	}

	bool Compare(const KeyType& key, UnixEndpoint* endpoint) const
	{
		return key == endpoint->Address();
	}

	UnixEndpoint*& GetLink(UnixEndpoint* endpoint) const
	{
		return endpoint->HashTableLink();
	}
};


class UnixAddressManager {
public:
	UnixAddressManager()
	{
		mutex_init(&fLock, "unix address manager");
	}

	~UnixAddressManager()
	{
		mutex_destroy(&fLock);
	}

	status_t Init()
	{
		return fBoundEndpoints.Init();
	}

	bool Lock()
	{
		return mutex_lock(&fLock) == B_OK;
	}

	void Unlock()
	{
		mutex_unlock(&fLock);
	}

	UnixEndpoint* Lookup(const UnixAddress& address) const
	{
		return fBoundEndpoints.Lookup(address);
	}

	void Add(UnixEndpoint* endpoint)
	{
		fBoundEndpoints.Insert(endpoint);
	}

	void Remove(UnixEndpoint* endpoint)
	{
		fBoundEndpoints.Remove(endpoint);
	}

	int32 NextInternalID()
	{
		int32 id = fNextInternalID;
		fNextInternalID = (id + 1) & 0xfffff;
		return id;
	}

	int32 NextUnusedInternalID()
	{
		for (int32 i = 0xfffff; i >= 0; i--) {
			int32 id = NextInternalID();
			UnixAddress address(id);
			if (Lookup(address) == NULL)
				return id;
		}

		return ENOBUFS;
	}

private:
	typedef BOpenHashTable<UnixAddressHashDefinition, false> EndpointTable;

	mutex			fLock;
	EndpointTable	fBoundEndpoints;
	int32			fNextInternalID;
};


typedef AutoLocker<UnixAddressManager> UnixAddressManagerLocker;


#endif	// UNIX_ADDRESS_MANAGER_H