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

Go to the documentation of this file.

/* Copyright (C) 2010 webis.de
 * All rights reserved.
 */
#include "IndexSearcher.java.h"
#include "JNIGateway.hpp"

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

/*
 * Class:     de_aitools_aq_invertedindex_core_IndexSearcher
 * Method:    natInstance
 * Signature: (Ljava/lang/String;)I
 */
JNIEXPORT jint JNICALL Java_de_aitools_aq_invertedindex_core_IndexSearcher_natInstance
(JNIEnv* env, jobject jsearcher, jstring jclazz)
{
        try
        {
                Searcher::SharedPointer searcher;
                searcher = JNIGateway::create_searcher(env, jclazz);
                return JNIGateway::put_searcher(searcher);
        }
        catch (const std::exception& error)
        {
                env->ThrowNew(env->FindClass(JNIGateway::java_exception), error.what());
        }
        return -1;
}

/*
 * Class:     de_aitools_aq_invertedindex_core_IndexSearcher
 * Method:    natInit
 * Signature: (I[B)[B
 */
JNIEXPORT jbyteArray JNICALL Java_de_aitools_aq_invertedindex_core_IndexSearcher_natInit
(JNIEnv* env, jobject jsearcher, jint oid, jbyteArray jconfig)
{
        try
        {
                Configuration config;
                Searcher::SharedPointer searcher(JNIGateway::get_searcher(oid));
                if (!config.ParseFromArray(env->GetByteArrayElements(jconfig, NULL),
                                                   env->GetArrayLength(jconfig)))
                {
                        Exception::throw_invalid_argument("JNI: Cannot parse config");
                }
                searcher->init(config);
                ByteBuffer cheader(searcher->header().ByteSize());
                if (!searcher->header().SerializeToArray(cheader.data(), cheader.size()))
                {
                        Exception::throw_invalid_argument("JNI: Cannot serialize header");
                }
                jbyteArray jheader(env->NewByteArray(cheader.size()));
                env->SetByteArrayRegion(jheader, 0, cheader.size(), (jbyte*)cheader.data());
                return jheader;
        }
        catch (const std::exception& error)
        {
                env->ThrowNew(env->FindClass(JNIGateway::java_exception), error.what());
        }
        return NULL;
}

/*
 * Class:     de_aitools_aq_invertedindex_core_IndexSearcher
 * Method:    natGetQuantile
 * Signature: (ILjava/lang/String;)[I
 */
JNIEXPORT jintArray JNICALL Java_de_aitools_aq_invertedindex_core_IndexSearcher_natGetQuantile
(JNIEnv* env, jobject jsearcher, jint oid, jstring jkey)
{
        try
        {
                std::string ckey;
                JNIGateway::copy_string(env, jkey, ckey);
                jsize size(Quantile::COUNT);
                jintArray jquantile(env->NewIntArray(size));
                const Quantile& cquantile(JNIGateway::get_searcher(oid)->quantile(ckey));
                env->SetIntArrayRegion(jquantile, 0, size, (jint*)cquantile.values());
                return jquantile;
        }
        catch (const std::exception& error)
        {
                env->ThrowNew(env->FindClass(JNIGateway::java_exception), error.what());
        }
        return NULL;
}

/*
 * Class:     de_aitools_aq_invertedindex_core_IndexSearcher
 * Method:    natGetFrequency
 * Signature: (ILjava/lang/String;)J
 */
JNIEXPORT jlong JNICALL Java_de_aitools_aq_invertedindex_core_IndexSearcher_natGetFrequency
(JNIEnv* env, jobject jsearcher, jint oid, jstring jkey)
{
        try
        {
                std::string ckey;
                JNIGateway::copy_string(env, jkey, ckey);
                const Vocabulary& vocab(JNIGateway::get_searcher(oid)->vocabulary());
                Vocabulary::const_iterator it(vocab.find(ckey));
                return it == vocab.end() ? 0 : it->second;
        }
        catch (const std::exception& error)
        {
                env->ThrowNew(env->FindClass(JNIGateway::java_exception), error.what());
        }
        return 0;
}

/*
 * Class:     de_aitools_aq_invertedindex_core_IndexSearcher
 * Method:    natSearchL
 * Signature: (ILjava/lang/String;I)I
 */
JNIEXPORT jint JNICALL Java_de_aitools_aq_invertedindex_core_IndexSearcher_natSearchL
(JNIEnv* env, jobject jsearcher, jint oid, jstring jkey, jint length)
{
        try
        {
                std::string ckey;
                JNIGateway::copy_string(env, jkey, ckey);
                const Searcher::SharedPointer& searcher(JNIGateway::get_searcher(oid));
                return JNIGateway::put_iterator(searcher->generic_search(ckey, length));
        }
        catch (const std::exception& error)
        {
                env->ThrowNew(env->FindClass(JNIGateway::java_exception), error.what());
        }
        return -1;
}

/*
 * Class:     de_aitools_aq_invertedindex_core_IndexSearcher
 * Method:    natSearchO
 * Signature: (ILjava/lang/String;I)I
 */
JNIEXPORT jint JNICALL Java_de_aitools_aq_invertedindex_core_IndexSearcher_natSearchO
(JNIEnv* env, jobject jsearcher, jint oid, jstring jkey, jint order)
{
        try
        {
                std::string ckey;
                JNIGateway::copy_string(env, jkey, ckey);
                Quantile::Order corder(static_cast<Quantile::Order>(order));
                const Searcher::SharedPointer& searcher(JNIGateway::get_searcher(oid));
                return JNIGateway::put_iterator(searcher->generic_search(ckey, corder));
        }
        catch (const std::exception& error)
        {
                env->ThrowNew(env->FindClass(JNIGateway::java_exception), error.what());
        }
        return -1;
}

/*
 * Class:     de_aitools_aq_invertedindex_core_IndexSearcher
 * Method:    natDelete
 * Signature: (I)V
 */
JNIEXPORT void JNICALL Java_de_aitools_aq_invertedindex_core_IndexSearcher_natDelete
(JNIEnv* env, jobject jsearcher, jint oid)
{
        JNIGateway::delete_searcher(oid);
}

---