root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/StaticData.cpp @ 34827

#include "PrecompiledHeaders.h"
#include "Mil.h"
#include "Thread.h"
#include "ModuleCommon.h"

//#include <fecti/Utility/FBlockMemoryAllocator/FAllocatorImpl_Block.cpp>
//#include <fecti/Utility/FThread.cpp>

//#ifndef ENABLE_NLS
#ifndef _
#if defined(_UNICODE) || defined(UNICODE)
#define _(x) L##x
#else
#define _(x) x
#endif
#endif

namespace mil {
namespace thread {
Serial id_serial(MIL_MAX_THREADS);
static atomic<void*> threads[MIL_MAX_THREADS];

void* get(id_t thread_id) {
    if (!is_valid_id(thread_id)) {
        halt << "thread_id is out of range";
        return NULL;
    }
    return threads[thread_id].load();
}

void set(id_t thread_id, void* object) {
    if (!is_valid_id(thread_id)) {
        halt << "thread_id is out of range";
        return;
    }
    threads[thread_id].store(object);
}

bool is_valid_id(id_t thread_id) {
    if (thread_id < 0 || thread_id >= static_cast<id_t>(_countof(threads)) || thread_id == Serial::INVALID_VALUE) {
        return false;
    }
    return true;
}
}

ExitNotifier exitNotifier /* XXX depends on id_serial */;
int auto_joiner_index = 0;
AutoJoiner auto_joiners[MIL_MAX_THREADS];
}

#undef filter_exception_and_start
extern "C" int filter_exception_and_start(int argc, char** argv, int (*start)(int, char**)) {
    try {
        return start(argc, argv);
    }
    //catch (boost::exception& e)
    //{
    //    debug << "c++ boost::exception [" << boost::diagnostic_information(e) << "]";
    //}
    catch (std::exception& e) {
        //debug << "c++ std::exception [" << e.what() << "]";
        //_ftprintf(stderr, gettext("c++ std::exception [%s]\n"), e.what());
        //fprintf(stderr, gettext("c++ std::exception [%s]\n"), e.what()); // e.what() -> char
    }
    return 1;
}

#ifdef __OBJC__
namespace mil {
class CocoaThreadManager : boost::noncopyable {
    Mutex mutex;
    NSPort* port_matrix[MIL_MAX_THREADS][MIL_MAX_THREADS];
    NSConnection* send_connection_matrix[MIL_MAX_THREADS][MIL_MAX_THREADS];
    NSConnection* receive_connection_matrix[MIL_MAX_THREADS][MIL_MAX_THREADS];
    id proxies[MIL_MAX_THREADS][MIL_MAX_THREADS];
public:
    CocoaThreadManager() {
        synchronized (mutex) {
        }
    }

    ~CocoaThreadManager() {
        synchronized (mutex) {
        }
    }

    id getProxy(int sender, int receiver) {
        synchronized (mutex) {
            if (proxies[sender][receiver]) {
                return proxies[sender][receiver];
            }
            port_matrix[sender][receiver] = [NSPort port];
            port_matrix[receiver][sender] = [NSPort port];
            send_connection_matrix[sender][receiver] =
    [NSConnection connectionWithReceivePort:port_matrix[sender][receiver] sendPort:port_matrix[receiver][sender]];

            proxies[sender][receiver] = [send_connection_matrix[sender][receiver] rootProxy];
            return proxies[sender][receiver];
        }
    }

    void setProxy(int receiver, id object) {
        synchronized (mutex) {
            for (unsigned int sender = 0; sender < _countof(send_connection_matrix[0]); sender++) {
                if (send_connection_matrix[sender][receiver] && !receive_connection_matrix[sender][receiver]) {
                    receive_connection_matrix[sender][receiver] =
    [NSConnection connectionWithReceivePort:port_matrix[receiver][sender] sendPort:port_matrix[sender][receiver]];
[receive_connection_matrix[sender][receiver] setRootObject: object];
                }
            }
        }
    }
};

}
#endif