/home/raskolnikov/dev/psynth/trunk/src/psynth/base/singleton.hpp

Go to the documentation of this file.

/*
 *  File:       singleton.hpp
 *  Author:     Juan Pedro Bolívar Puente <raskolnikov@es.gnu.org>
 *  Date:       2007
 *  Time-stamp: <2011-06-13 11:12:20 raskolnikov>
 *
 *  This file implements a policy-based generic singleton. It is a
 *  simplification (less policy implementations are provided) of
 *  Loki singleton_holder class.
 *
 *  @todo Add more longetvity policies. The follow-to-death policy
 *        in the current Loki implementation seems interesting, as
 *        most singletons actually depend indirectly
 *        (through psynth::error) on Logger.
 */

/*
 *  Copyright (C) 2007, 2009 Juan Pedro Bolívar Puente
 *  
 *  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 3 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, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef PSYNTH_SINGLETON_H
#define PSYNTH_SINGLETON_H

#include <new>

#include <psynth/base/exception.hpp>
#include <psynth/base/threads.hpp>

namespace psynth
{
namespace base
{

/* Default parameters forward declaration. */
template <class T>
class create_with_new;
template <class T>
class lifetime_atexit;

template <
    class T,
    template <class> class CreationPolicy  = create_with_new,
    template <class> class LifetimePolicy  = lifetime_atexit,
    template <class> class ThreadingPolicy = PSYNTH_DEFAULT_NONOBJ_THREADING
    >
class singleton_holder : private boost::noncopyable
{
public:
    typedef T type;
    
    static T& self ();
    
private:
    singleton_holder () = delete;
    ~singleton_holder () {};
    
    typedef typename ThreadingPolicy<T*>::volatile_type instance_type;
    static instance_type m_instance;
    static bool m_destroyed;
    
    static void destroy_singleton ();
};

template <typename T>
struct create_with_new
{
    static T* create ()
    {
        return new T;
    }
    
    static void destroy (T* var)
    {
        delete var;
    }
};

template <typename T>
struct create_with_malloc
{
    static T* create ()
    {
        T* mem = std::malloc (sizeof (T));
        if (!mem)
            return 0;
        mem = new (mem) T;
        return mem;
    }

    static void destroy (T* obj)
    {
        obj->~T ();
        std::free (obj);
    }
};

template <typename T>
struct create_with_static
{
    static T* create ()
    {
        static T object; /* Should we use Loki's MaxAlign trick? */
        return &object;
    }

    static void destroy (T* obj)
    {
        obj->~T ();
    }
};

template<template<class> class Alloc>
struct create_with
{
    template <class T>
    struct alloc
    {
        static Alloc<T> allocator;

        static T* create()
        {
            return new (allocator.allocate (1)) T;
        }

        static void destroy(T* p)
        {
            p->~T();
            allocator.deallocate (p, 1);
        }
    };
};

typedef void (*destroy_func_t)();

PSYNTH_DECLARE_ERROR (error, singleton_error);

template <class T>
struct lifetime_atexit
{
    static void schedule (T*, destroy_func_t fun)
    {
        std::atexit (fun);
    }

    static void on_dead_reference ()
    {
        throw singleton_error ();
    }
};

template <class T>
struct lifetime_static_dtor
{
    static void schedule (T*, destroy_func_t fun)
    {
        static scheduler sched (fun);
    }

    static void on_dead_reference ()
    {
        throw singleton_error ();
    }

private:
    struct scheduler
    {
        scheduler (destroy_func_t fun)
            : m_fun (fun)
        {}

        ~scheduler ()
        {
            m_fun ();
        }

        destroy_func_t m_fun;
    };
};

template <class T>
class lifetime_phoenix
{
public:
    static void schedule (T*, destroy_func_t pFun)
    {
#ifndef PSYNTH_ATEXIT_FIXED
        if (!m_destroyed)
#endif
            std::atexit(pFun);
    }

    static void on_dead_reference ()
    {
#ifndef PSYNTH_ATEXIT_FIXED
        m_destroyed = true;
#endif
    }
        
private:
#ifndef PSYNTH_ATEXIT_FIXED
    static bool m_destroyed;
#endif
};

template <class T>
struct lifetime_no_destroy
{
    static void schedule (T*, destroy_func_t)
    {}

    static void on_dead_reference ()
    {
        throw singleton_error ();
    }
};

} /* namespace base */
} /* namespace psynth */

#include <psynth/base/singleton.tpp>

#endif /* PSYNTH_SINGLETON_H */