/*
 * 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