/*
 * Copyright (c) 2008,2011-2012 Apple Inc. All Rights Reserved.
 * 
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */


//
// Templates to support HandleObject-like objects
//
#ifndef _H_HANDLETEMPLATES
#define _H_HANDLETEMPLATES

#include <security_utilities/refcount.h>
#include <security_utilities/threading.h>
#include <security_utilities/globalizer.h>
#include <security_cdsa_utilities/cssmerrors.h>
#include <vector>

#if __GNUC__ > 2
#include <ext/hash_map>
using __gnu_cxx::hash_map;
#else
#include <hash_map>
#endif

namespace Security
{

//
// A TypedHandle is a trivial mixin class whose only feature is that
// it has a *handle* whose type is of the caller's choosing.  Subclasses 
// need to assign such a handle during creation.
//
template <class _Handle>
struct TypedHandle
{
public:
    typedef _Handle Handle;
    
    static const _Handle invalidHandle = 0;

    _Handle handle() const     { return mMyHandle; }
    bool validHandle() const  { return mValid; }

protected:
    TypedHandle(_Handle h);
    TypedHandle();

    void setHandle(_Handle h)
    {
        assert(!mValid);    // guard against redefinition
        mMyHandle = h;
        mValid = true;
    }
    void clearHandle()
    {
        assert(mValid);
        mValid = false;
    }
    
private:
    _Handle mMyHandle;           // our handle value
    bool mValid;                // is the handle (still) valid?
};

//
// MappingHandle wraps a map indexed by handles of the chosen type.  
// A MappingHandle makes up its own handle based on some mechanism that you 
// know nothing about.
//
// Please be very careful about the limits of the object contract here.
// We promise to invent a suitable, unique handle for each MappingHandle in
// existence within one address space. We promise that if you hand that 
// handle to the various MappingHandle<>::find() variants, we will give you 
// back the MappingHandle that created it. We promise to throw if you pass
// a bad handle to those MappingHandle<>::find() variants. This is the
// entire contract. 
//
template <class _Handle>
class MappingHandle : public TypedHandle<_Handle>
{
protected:
    class State;
    
public: 
    typedef typename TypedHandle<_Handle>::Handle Handle;
    virtual ~MappingHandle()
    {
        State &st = state();
        StLock<Mutex> _(st);
        st.erase(this);
    }

    template <class SubType>
    static SubType &find(_Handle handle, CSSM_RETURN error);

	template <class Subtype>
	static Subtype &findAndLock(_Handle handle, CSSM_RETURN error);
	
	template <class Subtype>
	static Subtype &findAndKill(_Handle handle, CSSM_RETURN error);
	
	template <class Subtype>
	static RefPointer<Subtype> findRef(_Handle handle, CSSM_RETURN error);

	template <class Subtype>
	static RefPointer<Subtype> findRefAndLock(_Handle handle, CSSM_RETURN error);

	template <class Subtype>
	static RefPointer<Subtype> findRefAndKill(_Handle handle, CSSM_RETURN error);
    
    // @@@  Remove when 4003540 is fixed
    template <class Subtype>
    static void findAllRefs(std::vector<_Handle> &refs) {
        state().template findAllRefs<Subtype>(refs);
    }
    
protected:
    virtual void lock();
    virtual bool tryLock();
    
    typedef hash_map<_Handle, MappingHandle<_Handle> *> HandleMap;

    MappingHandle();

    class State : public Mutex, public HandleMap
    {
    public:
        State();
        uint32_t nextSeq()  { return ++sequence; }

        bool handleInUse(_Handle h);
        MappingHandle<_Handle> *find(_Handle h, CSSM_RETURN error);
        typename HandleMap::iterator locate(_Handle h, CSSM_RETURN error);
        void add(_Handle h, MappingHandle<_Handle> *obj);
        void erase(MappingHandle<_Handle> *obj);
        void erase(typename HandleMap::iterator &it);
        // @@@  Remove when 4003540 is fixed
        template <class SubType> void findAllRefs(std::vector<_Handle> &refs);

    private:
        uint32_t sequence;
    };
    
private:
    // 
    // Create the handle to be used by the map
    //
    void make();

    static ModuleNexus<typename MappingHandle<_Handle>::State> state;
};

//
// MappingHandle class methods
// Type-specific ways to access the map in various ways
//
template <class _Handle>
template <class Subclass>
inline Subclass &MappingHandle<_Handle>::find(_Handle handle, CSSM_RETURN error)
{
    Subclass *sub;
    if (!(sub = dynamic_cast<Subclass *>(state().find(handle, error))))
        CssmError::throwMe(error);
    return *sub;
}

template <class _Handle>
template <class Subclass>
inline Subclass &MappingHandle<_Handle>::findAndLock(_Handle handle,
                                             CSSM_RETURN error)
{
    for (;;) {
        typename HandleMap::iterator it = state().locate(handle, error);
        StLock<Mutex> _(state(), true);	// locate() locked it
        Subclass *sub;
        if (!(sub = dynamic_cast<Subclass *>(it->second)))
            CssmError::throwMe(error);	// bad type
        if (it->second->tryLock())		// try to lock it
            return *sub;				// okay, go
        Thread::yield();				// object lock failed, backoff and retry
    }
}

template <class _Handle>
template <class Subclass>
inline Subclass &MappingHandle<_Handle>::findAndKill(_Handle handle,
                                             CSSM_RETURN error)
{
    for (;;) {
        typename HandleMap::iterator it = state().locate(handle, error);
        StLock<Mutex> _(state(), true);	// locate() locked it
        Subclass *sub;
        if (!(sub = dynamic_cast<Subclass *>(it->second)))
            CssmError::throwMe(error);	// bad type
        if (it->second->tryLock()) {	// try to lock it
            state().erase(it);			// kill the handle
            return *sub;				// okay, go
        }
        Thread::yield();				// object lock failed, backoff and retry
    }
}

template <class _Handle>
template <class Subclass>
inline RefPointer<Subclass> MappingHandle<_Handle>::findRef(_Handle handle,
                                                    CSSM_RETURN error)
{
    typename HandleMap::iterator it = state().locate(handle, error);
    StLock<Mutex> _(state(), true); // locate() locked it
    Subclass *sub;
    if (!(sub = dynamic_cast<Subclass *>(it->second)))
        CssmError::throwMe(error);
    return sub;
}

template <class _Handle>
template <class Subclass>
inline RefPointer<Subclass> MappingHandle<_Handle>::findRefAndLock(_Handle handle,
                                                           CSSM_RETURN error)
{
    for (;;) {
        typename HandleMap::iterator it = state().locate(handle, error);
        StLock<Mutex> _(state(), true);	// locate() locked it
        Subclass *sub;
        if (!(sub = dynamic_cast<Subclass *>(it->second)))
            CssmError::throwMe(error);	// bad type
        if (it->second->tryLock())		// try to lock it
            return sub;				// okay, go
        Thread::yield();				// object lock failed, backoff and retry
    }
}

template <class _Handle>
template <class Subclass>
inline RefPointer<Subclass> MappingHandle<_Handle>::findRefAndKill(_Handle handle,
                                                           CSSM_RETURN error)
{
    for (;;) {
        typename HandleMap::iterator it = state().locate(handle, error);
        StLock<Mutex> _(state(), true);	// locate() locked it
        Subclass *sub;
        if (!(sub = dynamic_cast<Subclass *>(it->second)))
            CssmError::throwMe(error);	// bad type
        if (it->second->tryLock()) {	// try to lock it
            state().erase(it);			// kill the handle
            return sub;					// okay, go
        }
        Thread::yield();				// object lock failed, backoff and retry
    }
}
    
//
// @@@  Remove when 4003540 is fixed
//
// This is a hack to fix 3981388 and should NOT be used elsewhere.  
// Also, do not follow this code's example: State methods should not 
// implement type-specific behavior.  
//
template <class _Handle>
template <class Subtype>
void MappingHandle<_Handle>::State::findAllRefs(std::vector<_Handle> &refs)
{
    StLock<Mutex> _(*this);
    typename HandleMap::iterator it = (*this).begin();
    for (; it != (*this).end(); ++it)
    {
        Subtype *obj = dynamic_cast<Subtype *>(it->second);
        if (obj)
            refs.push_back(it->first);
    }
}


} // end namespace Security

#endif //_H_HANDLETEMPLATES