root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/Mil.h @ 37881

#pragma once

/**
 * MI Library
 */
#include "PrecompiledHeaders.h"
#include "Environment.h"

#include "FilterException.h"

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

#ifdef MIL_UI_WINDOWS
#include "ui-windows/UI.h"
#elif defined(MIL_UI_COCOA)
#include "ui-cocoa/UI.h"
#else
#include "ui-cocoa/UI.h"
#endif

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

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

#ifndef likely
#ifdef HAVE_BUILTIN_EXPECT
#define likely(expression) __builtin_expect((!!(expression)), (true))
#define unlikely(expression) __builtin_expect((!!(expression)), (false))
#else
#define likely(expression) (expression)
#define unlikely(expression) (expression)
#endif
#endif

namespace mil {
//inline static void yield();
//inline static bool execute_in_single_processor();
/*

template <
int T,
int V = ((T <= sizeof(void*) *  3) ? sizeof(void*) *  3 :
        ((T <= sizeof(void*) *  6) ? sizeof(void*) *  6 :
        ((T <= sizeof(void*) * 16) ? sizeof(void*) * 16 :
        ((T <= sizeof(void*) * 48) ? sizeof(void*) * 48 :
//        ((T <= 1024) ? 1024 :
        0))))
        //)
>
struct SizeFixer {
    static const int SIZE = V;
};

template <int T>
struct MyPool {
    enum { SIZE = SizeFixer<sizeof(T)>::SIZE };
    static void* malloc() {
        if (SIZE == 0) {
            return std::malloc(sizeof(T));
        }
        return boost::singleton_pool<int, SIZE>::malloc();
    }
    static void free(void* memory) {
        if (SIZE == 0) {
            return std::free(memory);
        }
        boost::singleton_pool<int, SIZE>::free(memory);
    }
};
*/
}

namespace mil {
/*
template <class T>
struct PoolSizeSelector {
    enum {
        SIZE = (sizeof(T) >= 1024 ? 0 :
                (sizeof(T) >= 192 ? 192 :
                 (sizeof(T) >= 64 ? 64 :
                  (sizeof(T) >= 16 ? 16 : 4))))
    };
};
*/
typedef int SFINAE_CONDITION;
const int SFINAE_DUMMY_VALUE = (0);

template <class from>
struct auto_cast_temp {
    from& f;
    auto_cast_temp(from f_) : f(f_) {}
    template <class to> operator to() {
        return (to)f;
    }
};

template <class from>
auto_cast_temp<from> auto_cast(from f) {
    return auto_cast_temp<from>(f);
}

template <class To, class From>
To memcpy_cast(From f) {
    To t;
    memset(&t, 0, sizeof(t));
    size_t size = 0;
    if (sizeof(From) > sizeof(To)) {
        size = sizeof(To);
    } else {
        size = sizeof(From);
    }
    memcpy(&t, &f, size);
    return t;
}

struct AutoFree {
    void* ptr;
    AutoFree(void* ptr) : ptr(ptr) {
    }
    ~AutoFree() {
        free(ptr);
    }
};

#ifdef MIL_OS_WINDOWS
#if defined(UNICODE) || defined(_UNICODE)
const size_t STACKABLE_MAX_PATH = 2000;
#else
const size_t STACKABLE_MAX_PATH = MAX_PATH;
#endif
#else
#ifdef MAX_PATH
const size_t STACKABLE_MAX_PATH = MAX_PATH;
#else
const size_t STACKABLE_MAX_PATH = 2000;
#endif
#endif

}

#define MIL_MODULE_GET_SUPER_CHILD(o)          ((o).getChild().getChild().getChild().getChild().getChild().getChild().getChild().getChild().getChild().getChild().getChild())
#define MIL_MODULE_SUPER_CHILD_TYPE(t)  typename t::ChildType::ChildType::ChildType::ChildType::ChildType::ChildType::ChildType::ChildType::ChildType::ChildType::ChildType

#define MIL_CRTP_CLASS_MEMBERS Child& getChild(){return *static_cast<Child*>(this);} typedef Child ChildType;

//#ifdef __OBJC__
//#include "ObjCExceptionFix.h"
//#endif