/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex-cpp/src/jni/JNIGateway.cpp

Go to the documentation of this file.

#include "JNIGateway.hpp"
#include "ValueTypes.hpp"
#include "IndexBuilder.hpp"
#include "IndexSearcher.hpp"

// Do NOT include these methods in namespaces (changes the function signatures)
using namespace aitools::invertedindex;

JNIGateway::BuilderMap
JNIGateway::builders;

JNIGateway::SearcherMap
JNIGateway::searchers;

JNIGateway::IteratorMap
JNIGateway::iterators;

boost::mutex
JNIGateway::mutex;

const char*
JNIGateway::java_exception("java/lang/RuntimeException");

void
JNIGateway::copy_string(JNIEnv* env, jstring jstr, std::string& cstr)
{
        const char* chars(env->GetStringUTFChars(jstr, 0));
        cstr.assign(chars);
        env->ReleaseStringUTFChars(jstr, chars);
}
// I know that looks ugly,
// but relax, this mapping happens only once.
Builder::shared_pointer
JNIGateway::create_builder(JNIEnv* env, jstring jclazz)
throw (std::invalid_argument)
{
        std::string value_class;
        copy_string(env, jclazz, value_class);
        Builder::shared_pointer builder;

        // 1-tuple
        if (value_class == "SingleByte")
                builder.reset(new IndexBuilder<SingleByte>);
        else if (value_class == "SingleFloat")
                builder.reset(new IndexBuilder<SingleFloat>);
        else if (value_class == "SingleInt")
                builder.reset(new IndexBuilder<SingleInt>);
        else if (value_class == "SingleLong")
                builder.reset(new IndexBuilder<SingleLong>);
        else if (value_class == "SingleShort")
                builder.reset(new IndexBuilder<SingleShort>);
        else if (value_class == "SingleString")
                builder.reset(new IndexBuilder<SingleString>);
        // 2-tuple
        else if (value_class == "FloatFloat")
                builder.reset(new IndexBuilder<FloatFloat>);
        else if (value_class == "FloatInt")
                builder.reset(new IndexBuilder<FloatInt>);
        else if (value_class == "FloatLong")
                builder.reset(new IndexBuilder<FloatLong>);
        else if (value_class == "IntFloat")
                builder.reset(new IndexBuilder<IntFloat>);
        else if (value_class == "IntInt")
                builder.reset(new IndexBuilder<IntInt>);
        else if (value_class == "IntLong")
                builder.reset(new IndexBuilder<IntLong>);
        else if (value_class == "LongFloat")
                builder.reset(new IndexBuilder<LongFloat>);
        else if (value_class == "LongInt")
                builder.reset(new IndexBuilder<LongInt>);
        else if (value_class == "LongLong")
                builder.reset(new IndexBuilder<LongLong>);
        else if (value_class == "ShortFloat")
                builder.reset(new IndexBuilder<ShortFloat>);
        else if (value_class == "ShortInt")
                builder.reset(new IndexBuilder<ShortInt>);
        else if (value_class == "ShortLong")
                builder.reset(new IndexBuilder<ShortLong>);
        // 2-tuple with string
        else if (value_class == "ByteString")
                builder.reset(new IndexBuilder<ByteString>);
        else if (value_class == "FloatString")
                builder.reset(new IndexBuilder<FloatString>);
        else if (value_class == "IntString")
                builder.reset(new IndexBuilder<IntString>);
        else if (value_class == "LongString")
                builder.reset(new IndexBuilder<LongString>);
        else if (value_class == "ShortString")
                builder.reset(new IndexBuilder<ShortString>);
        else if (value_class == "StringString")
                builder.reset(new IndexBuilder<StringString>);
        // 3-tuple
        else if (value_class == "FloatFloatFloat")
                builder.reset(new IndexBuilder<FloatFloatFloat>);
        else if (value_class == "FloatIntFloat")
                builder.reset(new IndexBuilder<FloatIntFloat>);
        else if (value_class == "FloatIntInt")
                builder.reset(new IndexBuilder<FloatIntInt>);
        else if (value_class == "IntFloatFloat")
                builder.reset(new IndexBuilder<IntFloatFloat>);
        else if (value_class == "IntIntFloat")
                builder.reset(new IndexBuilder<IntIntFloat>);
        else if (value_class == "IntIntInt")
                builder.reset(new IndexBuilder<IntIntInt>);
        else if (value_class == "LongFloatFloat")
                builder.reset(new IndexBuilder<LongFloatFloat>);
        else if (value_class == "LongIntFloat")
                builder.reset(new IndexBuilder<LongIntFloat>);
        else if (value_class == "LongIntInt")
                builder.reset(new IndexBuilder<LongIntInt>);
        else if (value_class == "ShortFloatFloat")
                builder.reset(new IndexBuilder<ShortFloatFloat>);
        else if (value_class == "ShortIntFloat")
                builder.reset(new IndexBuilder<ShortIntFloat>);
        else if (value_class == "ShortIntInt")
                builder.reset(new IndexBuilder<ShortIntInt>);
        // 4-tuple
        else if (value_class == "IntIntIntInt")
                builder.reset(new IndexBuilder<IntIntIntInt>);
        else if (value_class == "LongLongLongLong")
                builder.reset(new IndexBuilder<LongLongLongLong>);
        else if (value_class == "LongLongIntInt")
                builder.reset(new IndexBuilder<LongLongIntInt>);
        else if (value_class == "LongLongFloatFloat")
                builder.reset(new IndexBuilder<LongLongFloatFloat>);
        else if (value_class == "LongFloatLongInt")
                builder.reset(new IndexBuilder<LongFloatLongInt>);

        else Exception::throw_invalid_argument("JNI: Unknown type " + value_class);
        return builder;
}

Searcher::SharedPointer
JNIGateway::create_searcher(JNIEnv* env, jstring jclazz)
throw (std::invalid_argument)
{
        std::string value_class;
        copy_string(env, jclazz, value_class);
        Searcher::SharedPointer searcher;

        // 1-tuple
        if (value_class == "SingleByte")
                searcher.reset(new IndexSearcher<SingleByte>);
        else if (value_class == "SingleFloat")
                searcher.reset(new IndexSearcher<SingleFloat>);
        else if (value_class == "SingleInt")
                searcher.reset(new IndexSearcher<SingleInt>);
        else if (value_class == "SingleLong")
                searcher.reset(new IndexSearcher<SingleLong>);
        else if (value_class == "SingleShort")
                searcher.reset(new IndexSearcher<SingleShort>);
        else if (value_class == "SingleString")
                searcher.reset(new IndexSearcher<SingleString>);
        // 2-tuple
        else if (value_class == "FloatFloat")
                searcher.reset(new IndexSearcher<FloatFloat>);
        else if (value_class == "FloatInt")
                searcher.reset(new IndexSearcher<FloatInt>);
        else if (value_class == "FloatLong")
                searcher.reset(new IndexSearcher<FloatLong>);
        else if (value_class == "IntFloat")
                searcher.reset(new IndexSearcher<IntFloat>);
        else if (value_class == "IntInt")
                searcher.reset(new IndexSearcher<IntInt>);
        else if (value_class == "IntLong")
                searcher.reset(new IndexSearcher<IntLong>);
        else if (value_class == "LongFloat")
                searcher.reset(new IndexSearcher<LongFloat>);
        else if (value_class == "LongInt")
                searcher.reset(new IndexSearcher<LongInt>);
        else if (value_class == "LongLong")
                searcher.reset(new IndexSearcher<LongLong>);
        else if (value_class == "ShortFloat")
                searcher.reset(new IndexSearcher<ShortFloat>);
        else if (value_class == "ShortInt")
                searcher.reset(new IndexSearcher<ShortInt>);
        else if (value_class == "ShortLong")
                searcher.reset(new IndexSearcher<ShortLong>);
        // 2-tuple with string
        else if (value_class == "ByteString")
                searcher.reset(new IndexSearcher<ByteString>);
        else if (value_class == "FloatString")
                searcher.reset(new IndexSearcher<FloatString>);
        else if (value_class == "IntString")
                searcher.reset(new IndexSearcher<IntString>);
        else if (value_class == "LongString")
                searcher.reset(new IndexSearcher<LongString>);
        else if (value_class == "ShortString")
                searcher.reset(new IndexSearcher<ShortString>);
        else if (value_class == "StringString")
                searcher.reset(new IndexSearcher<StringString>);
        // 3-tuple
        else if (value_class == "FloatFloatFloat")
                searcher.reset(new IndexSearcher<FloatFloatFloat>);
        else if (value_class == "FloatIntFloat")
                searcher.reset(new IndexSearcher<FloatIntFloat>);
        else if (value_class == "FloatIntInt")
                searcher.reset(new IndexSearcher<FloatIntInt>);
        else if (value_class == "IntFloatFloat")
                searcher.reset(new IndexSearcher<IntFloatFloat>);
        else if (value_class == "IntIntFloat")
                searcher.reset(new IndexSearcher<IntIntFloat>);
        else if (value_class == "IntIntInt")
                searcher.reset(new IndexSearcher<IntIntInt>);
        else if (value_class == "LongFloatFloat")
                searcher.reset(new IndexSearcher<LongFloatFloat>);
        else if (value_class == "LongIntFloat")
                searcher.reset(new IndexSearcher<LongIntFloat>);
        else if (value_class == "LongIntInt")
                searcher.reset(new IndexSearcher<LongIntInt>);
        else if (value_class == "ShortFloatFloat")
                searcher.reset(new IndexSearcher<ShortFloatFloat>);
        else if (value_class == "ShortIntFloat")
                searcher.reset(new IndexSearcher<ShortIntFloat>);
        else if (value_class == "ShortIntInt")
                searcher.reset(new IndexSearcher<ShortIntInt>);
        // 4-tuple
        else if (value_class == "IntIntIntInt")
                searcher.reset(new IndexSearcher<IntIntIntInt>);
        else if (value_class == "LongLongLongLong")
                searcher.reset(new IndexSearcher<LongLongLongLong>);
        else if (value_class == "LongLongIntInt")
                searcher.reset(new IndexSearcher<LongLongIntInt>);
        else if (value_class == "LongLongFloatFloat")
                searcher.reset(new IndexSearcher<LongLongFloatFloat>);
        else if (value_class == "LongFloatLongInt")
                searcher.reset(new IndexSearcher<LongFloatLongInt>);

        else Exception::throw_invalid_argument("JNI: Unknown type " + value_class);
        return searcher;
}

void
JNIGateway::delete_builder(jint oid)
{
        boost::mutex::scoped_lock lock(mutex);
        builders.erase(oid);
}

void
JNIGateway::delete_searcher(jint oid)
{
        boost::mutex::scoped_lock lock(mutex);
        searchers.erase(oid);
}

void
JNIGateway::delete_iterator(jint oid)
{
        boost::mutex::scoped_lock lock(mutex);
        iterators.erase(oid);
}

Builder::shared_pointer&
JNIGateway::get_builder(jint oid) throw (std::invalid_argument)
{
        boost::mutex::scoped_lock lock(mutex);
        BuilderMap::iterator it(builders.find(oid));
        if (it == builders.end())
        {
                Exception::throw_invalid_argument("JNI: Invalid object id");
        }
        return it->second;
}

Searcher::SharedPointer&
JNIGateway::get_searcher(jint oid) throw (std::invalid_argument)
{
        boost::mutex::scoped_lock lock(mutex);
        SearcherMap::iterator it(searchers.find(oid));
        if (it == searchers.end())
        {
                Exception::throw_invalid_argument("JNI: Invalid object id");
        }
        return it->second;
}

Iterator::SharedPointer&
JNIGateway::get_iterator(jint oid) throw (std::invalid_argument)
{
        boost::mutex::scoped_lock lock(mutex);
        IteratorMap::iterator it(iterators.find(oid));
        if (it == iterators.end())
        {
                Exception::throw_invalid_argument("JNI: Invalid object id");
        }
        return it->second;
}

jint
JNIGateway::put_builder(const Builder::shared_pointer& builder)
{
        jint oid(-1);
        if (builder)
        {
                oid = std::rand();
                boost::mutex::scoped_lock lock(mutex);
                while (builders.find(oid) != builders.end())
                {
                        oid = std::rand();
                }
                builders.insert(std::make_pair(oid, builder));
        }
        return oid;
}

jint
JNIGateway::put_searcher(const Searcher::SharedPointer& searcher)
{
        jint oid(-1);
        if (searcher)
        {
                oid = std::rand();
                boost::mutex::scoped_lock lock(mutex);
                while (searchers.find(oid) != searchers.end())
                {
                        oid = std::rand();
                }
                searchers.insert(std::make_pair(oid, searcher));
        }
        return oid;
}

jint
JNIGateway::put_iterator(const Iterator::SharedPointer& iterator)
{
        jint oid(-1);
        if (iterator && iterator->header().value_count != 0)
        {
                oid = std::rand();
                boost::mutex::scoped_lock lock(mutex);
                while (iterators.find(oid) != iterators.end())
                {
                        oid = std::rand();
                }
                iterators.insert(std::make_pair(oid, iterator));
        }
        return oid;
}

---