path: root/indra/llcommon/llregistry.h

/**
 * @file llregistry.h
 * @brief template classes for registering name, value pairs in nested scopes, statically, etc.
 *
 * $LicenseInfo:firstyear=2001&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#ifndef LL_LLREGISTRY_H
#define LL_LLREGISTRY_H

#include <list>

#include "llsingleton.h"
#include "llstl.h"

template <typename T>
struct LLRegistryDefaultComparator
{
    bool operator()(const T& lhs, const T& rhs) const
    {
        using std::less;
        return less<T>()(lhs, rhs);
    }
};

template <typename KEY, typename VALUE, typename COMPARATOR = LLRegistryDefaultComparator<KEY> >
class LLRegistry
{
public:
    typedef LLRegistry<KEY, VALUE, COMPARATOR>      registry_t;
    typedef const KEY&                              ref_const_key_t;
    typedef const VALUE&                            ref_const_value_t;
    typedef const VALUE*                            ptr_const_value_t;
    typedef VALUE*                                  ptr_value_t;

    class Registrar
    {
        friend class LLRegistry<KEY, VALUE, COMPARATOR>;
    public:
        typedef std::map<KEY, VALUE, COMPARATOR> registry_map_t;

        bool add(ref_const_key_t key, ref_const_value_t value)
        {
            if (!mMap.insert(std::make_pair(key, value)).second)
            {
                LL_WARNS() << "Tried to register " << key << " but it was already registered!" << LL_ENDL;
                return false;
            }
            return true;
        }

        void remove(ref_const_key_t key)
        {
            mMap.erase(key);
        }

        void replace(ref_const_key_t key, ref_const_value_t value)
        {
            mMap[key] = value;
        }

        typename registry_map_t::const_iterator beginItems() const
        {
            return mMap.begin();
        }

        typename registry_map_t::const_iterator endItems() const
        {
            return mMap.end();
        }

    protected:
        ptr_value_t getValue(ref_const_key_t key)
        {
            typename registry_map_t::iterator found_it = mMap.find(key);
            if (found_it != mMap.end())
            {
                return &(found_it->second);
            }
            return NULL;
        }

        ptr_const_value_t getValue(ref_const_key_t key) const
        {
            typename registry_map_t::const_iterator found_it = mMap.find(key);
            if (found_it != mMap.end())
            {
                return &(found_it->second);
            }
            return NULL;
        }

        // if the registry is used to store pointers, and null values are valid entries
        // then use this function to check the existence of an entry
        bool exists(ref_const_key_t key) const
        {
            return mMap.find(key) != mMap.end();
        }

        bool empty() const
        {
            return mMap.empty();
        }

    protected:
        // use currentRegistrar() or defaultRegistrar()
        Registrar() {}
        ~Registrar() {}

    private:
        registry_map_t                                          mMap;
    };

    typedef typename std::list<Registrar*> scope_list_t;
    typedef typename std::list<Registrar*>::iterator scope_list_iterator_t;
    typedef typename std::list<Registrar*>::const_iterator scope_list_const_iterator_t;

    LLRegistry()
    {}

    ~LLRegistry() {}

    ptr_value_t getValue(ref_const_key_t key)
    {
        for(Registrar* scope : mActiveScopes)
        {
            ptr_value_t valuep = scope->getValue(key);
            if (valuep != NULL) return valuep;
        }
        return mDefaultRegistrar.getValue(key);
    }

    ptr_const_value_t getValue(ref_const_key_t key) const
    {
        for(const Registrar* scope : mActiveScopes)
        {
            ptr_const_value_t valuep = scope->getValue(key);
            if (valuep != NULL) return valuep;
        }
        return mDefaultRegistrar.getValue(key);
    }

    bool exists(ref_const_key_t key) const
    {
        for(const Registrar* scope : mActiveScopes)
        {
            if (scope->exists(key)) return true;
        }

        return mDefaultRegistrar.exists(key);
    }

    bool empty() const
    {
        for(const Registrar* scope : mActiveScopes)
        {
            if (!scope->empty()) return false;
        }

        return mDefaultRegistrar.empty();
    }


    Registrar& defaultRegistrar()
    {
        return mDefaultRegistrar;
    }

    const Registrar& defaultRegistrar() const
    {
        return mDefaultRegistrar;
    }


    Registrar& currentRegistrar()
    {
        if (!mActiveScopes.empty())
        {
            return *mActiveScopes.front();
        }

        return mDefaultRegistrar;
    }

    const Registrar& currentRegistrar() const
    {
        if (!mActiveScopes.empty())
        {
            return *mActiveScopes.front();
        }

        return mDefaultRegistrar;
    }


protected:
    void addScope(Registrar* scope)
    {
        // newer scopes go up front
        mActiveScopes.insert(mActiveScopes.begin(), scope);
    }

    void removeScope(Registrar* scope)
    {
        // O(N) but should be near the beggining and N should be small and this is safer than storing iterators
        scope_list_iterator_t iter = std::find(mActiveScopes.begin(), mActiveScopes.end(), scope);
        if (iter != mActiveScopes.end())
        {
            mActiveScopes.erase(iter);
        }
    }

private:
    scope_list_t    mActiveScopes;
    Registrar       mDefaultRegistrar;
};

template <typename KEY, typename VALUE, typename DERIVED_TYPE, typename COMPARATOR = LLRegistryDefaultComparator<KEY> >
class LLRegistrySingleton
    :   public LLRegistry<KEY, VALUE, COMPARATOR>,
        public LLSingleton<DERIVED_TYPE>
{
    // This LLRegistrySingleton doesn't use LLSINGLETON(LLRegistrySingleton)
    // because the concrete class is actually DERIVED_TYPE, not
    // LLRegistrySingleton. So each concrete subclass needs
    // LLSINGLETON(whatever) -- not this intermediate base class.
public:
    typedef LLRegistry<KEY, VALUE, COMPARATOR>      registry_t;
    typedef const KEY&                              ref_const_key_t;
    typedef const VALUE&                            ref_const_value_t;
    typedef VALUE*                                  ptr_value_t;
    typedef const VALUE*                            ptr_const_value_t;
    typedef LLSingleton<DERIVED_TYPE>               singleton_t;

    class ScopedRegistrar : public registry_t::Registrar
    {
    public:
        ScopedRegistrar(bool push_scope = true)
        {
            if (push_scope)
            {
                pushScope();
            }
        }

        ~ScopedRegistrar()
        {
            if (singleton_t::instanceExists())
            {
                popScope();
            }
        }

        void pushScope()
        {
            singleton_t::instance().addScope(this);
        }

        void popScope()
        {
            singleton_t::instance().removeScope(this);
        }

        ptr_value_t getValueFromScope(ref_const_key_t key)
        {
            return getValue(key);
        }

        ptr_const_value_t getValueFromScope(ref_const_key_t key) const
        {
            return getValue(key);
        }

    private:
        typename std::list<typename registry_t::Registrar*>::iterator   mListIt;
    };

    class StaticRegistrar : public registry_t::Registrar
    {
    public:
        virtual ~StaticRegistrar() {}
        StaticRegistrar(ref_const_key_t key, ref_const_value_t value)
        {
            if (singleton_t::instance().exists(key))
            {
                LL_ERRS() << "Duplicate registry entry under key \"" << key << "\"" << LL_ENDL;
            }
            singleton_t::instance().mStaticScope->add(key, value);
        }
    };

    // convenience functions
    typedef typename LLRegistry<KEY, VALUE, COMPARATOR>::Registrar& ref_registrar_t;
    static ref_registrar_t currentRegistrar()
    {
        return singleton_t::instance().registry_t::currentRegistrar();
    }

    static ref_registrar_t defaultRegistrar()
    {
        return singleton_t::instance().registry_t::defaultRegistrar();
    }

    static ptr_value_t getValue(ref_const_key_t key)
    {
        return singleton_t::instance().registry_t::getValue(key);
    }

protected:
    // DERIVED_TYPE needs to derive from LLRegistrySingleton
    LLRegistrySingleton()
        : mStaticScope(NULL)
    {}

    virtual void initSingleton()
    {
        mStaticScope = new ScopedRegistrar();
    }

    virtual ~LLRegistrySingleton()
    {
        delete mStaticScope;
    }

private:
    ScopedRegistrar*    mStaticScope;
};

// helper macro for doing static registration
#define GLUED_TOKEN(x, y) x ## y
#define GLUE_TOKENS(x, y) GLUED_TOKEN(x, y)
#define LLREGISTER_STATIC(REGISTRY, KEY, VALUE) static REGISTRY::StaticRegistrar GLUE_TOKENS(reg, __LINE__)(KEY, VALUE);

#endif