root/lang/cplusplus/i3/trunk/src/mol/include/mol/Mol.h @ 30250

#pragma once

/**
 * MO Library
 */
#include "Environment.h"


#ifdef MOL_OS_WINDOWS
#include "os-windows/PrecompiledHeaders.h"
#include "os-windows/Os.h"
#else
#include "os-unix/Os.h"
#endif

#ifdef MOL_GUI_WINDOWS
#include "gui-windows/Gui.h"
#elif defined(MOL_GUI_FLTK)
#include "gui-fltk/Gui.h"
#else
#include "gui-qt/Gui.h"
#endif

#include <memory>
#include <cstdlib>
#include <cmath>
#include <cerrno>
#include <cstring>
#include <climits>

#include <iostream>
#include <string>
#include <stack>
#include <queue>
#include <map>

#include <boost/static_assert.hpp>
#include <boost/utility.hpp>
#include <boost/cstdint.hpp>
#include <boost/integer.hpp>
#include <boost/cast.hpp>
#include <boost/array.hpp>
#include <boost/preprocessor.hpp>
#include <boost/concept_check.hpp>
#include <boost/pool/singleton_pool.hpp>
#include <boost/intrusive/list.hpp>
#include <boost/intrusive/list_hook.hpp>
#include <boost/intrusive/slist.hpp>
#include <boost/intrusive/slist_hook.hpp>
#include <boost/ptr_container/ptr_map.hpp>

#include <boost/lexical_cast.hpp>
#include <boost/format.hpp>
#include <boost/typeof/typeof.hpp>


#ifndef decltype
#  define decltype(expression) BOOST_TYPEOF(expression)
#endif

namespace mol
{
inline static void yield();
inline static bool execute_in_single_processor();
}

#include "MscCrt.h"
#include "Debug.h"


#ifdef HAVE_CSTDATOMIC
#include <cstdatomic>
#else
#ifdef MOL_INTERLOCKED
namespace std
{
template <typename T>
class atomic : boost::noncopyable
{
    void* t;
public:
    atomic(T t)
    {
        store(t);
    }

    //T load() const volatile
    T load() volatile
    {
        BOOST_STATIC_ASSERT(sizeof(T) <= sizeof(void*));
        void* got = InterlockedCompareExchangePointer(
            reinterpret_cast<void* volatile *>(&t), 0, 0);
        T cooked;
        memcpy(&cooked, &got, sizeof(cooked));
        return cooked;
    }

    T exchange(T new_val) volatile
    {
        void* tmp = NULL;
        memcpy(&tmp, &new_val, sizeof(new_val));
        void* got = InterlockedExchangePointer(
            reinterpret_cast<void* volatile *>(&t), tmp);
        T cooked;
        memcpy(&cooked, &got, sizeof(cooked));
        return cooked;
    }

    void store(T new_val) volatile
    {
        exchange(new_val);
    }

private:
    operator T() const volatile
    {
        return load();
    }

    T operator=(T new_val) volatile
    {
        store(new_val);
    }
};
}
#else
#include <pthread.h>
namespace std
{
template <typename T>
class atomic : boost::noncopyable
{
    T t;
    pthread_mutex_t mutex;
public:
    atomic(T t) : t(t)
    {
        pthread_mutex_init(&mutex, NULL);
    }

    ~atomic()
    {
        pthread_mutex_destroy(&mutex);
    }

    //T load() const volatile
    T load()
    {
        pthread_mutex_lock(&mutex);
        T retval = t;
        pthread_mutex_unlock(&mutex);
        return retval;
    }

    //T exchange(T new_val) volatile
    T exchange(T new_val)
    {
        pthread_mutex_lock(&mutex);
        T old = t;
        t = new_val;
        pthread_mutex_unlock(&mutex);
        return old;
    }

    //void store(T new_val) volatile
    void store(T new_val)
    {
        exchange(new_val);
    }

private:
    //operator T() const volatile
    operator T() const
    {
        return load();
    }

    //T operator=(T new_val) volatile
    T operator=(T new_val)
    {
        store(new_val);
    }
};
}
#endif
#endif



namespace mol
{

template <class T, int V = 0
+ (sizeof(T) <= 16   ? 0:1)
+ (sizeof(T) <= 32   ? 0:1)
+ (sizeof(T) <= 64   ? 0:1)
+ (sizeof(T) <= 192  ? 0:1)
+ (sizeof(T) <= 1024 ? 0:1)
> struct PoolSizeSelector {};

template <class T> struct PoolSizeSelector<T, 0>
{
    enum { SIZE = 16 };
};
template <class T> struct PoolSizeSelector<T, 1>
{
    enum { SIZE = 32 };
};
template <class T> struct PoolSizeSelector<T, 2>
{
    enum { SIZE = 64 };
};
template <class T> struct PoolSizeSelector<T, 3>
{
    enum { SIZE = 192 };
};
template <class T> struct PoolSizeSelector<T, 4>
{
    enum { SIZE = 1024 };
};

}