JniUtil.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/farrago/JniUtil.h#33 $
// Fennel is a library of data storage and processing components.
// Copyright (C) 2005-2009 The Eigenbase Project
// Copyright (C) 2005-2009 SQLstream, Inc.
// Copyright (C) 2005-2009 LucidEra, Inc.
// Portions Copyright (C) 1999-2009 John V. Sichi
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 of the License, or (at your option)
// any later version approved by The Eigenbase Project.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef Fennel_JniUtil_Included
#define Fennel_JniUtil_Included

#include "fennel/common/AtomicCounter.h"
#include "fennel/common/PseudoUuid.h"
#include "fennel/tuple/TupleDescriptor.h"
#include "fennel/farrago/JavaThreadTracker.h"

#include <jni.h>
#include <locale>
#include <fstream>

FENNEL_BEGIN_NAMESPACE

class FENNEL_FARRAGO_EXPORT JniExceptionChecker
{
    JNIEnv *pEnv;

    void checkExceptions();

public:
    explicit JniExceptionChecker(JNIEnv *pEnvInit)
    {
        pEnv = pEnvInit;
    }

    ~JniExceptionChecker();

    JNIEnv *operator->() const
    {
        return pEnv;
    }
};

class FENNEL_FARRAGO_EXPORT JniEnvRef
{
    JNIEnv *pEnv;

public:
    explicit JniEnvRef(JNIEnv *pEnvInit)
    {
        pEnv = pEnvInit;
    }

    void operator = (JniEnvRef const &other)
    {
        pEnv = other.pEnv;
    }

    JniExceptionChecker operator->() const
    {
        return JniExceptionChecker(pEnv);
    }

    JNIEnv *get()
    {
        return pEnv;
    }

    void handleExcn(std::exception &ex);
};

class FENNEL_FARRAGO_EXPORT JniEnvAutoRef
    : public JniEnvRef
{
    bool needDetach;

public:
    explicit JniEnvAutoRef();

    void suppressDetach();

    ~JniEnvAutoRef();
};

// TODO jvs 21-Aug-2007:  templatize and clean this up as part of
// memory allocation cleanup (FNL-55)

class FENNEL_FARRAGO_EXPORT JniLocalRefReaper
{
    JNIEnv *pEnv;
    jobject obj;

public:
    JniLocalRefReaper(JniEnvRef &pEnvInit, jobject objInit)
    {
        pEnv = pEnvInit.get();
        obj = objInit;
    }

    ~JniLocalRefReaper()
    {
        if (obj) {
            pEnv->DeleteLocalRef(obj);
            obj = NULL;
        }
    }
};

class ConfigMap;

class FENNEL_FARRAGO_EXPORT JniUtilParams
{
public:
    static ParamName paramJniHandleTraceFile;

    std::string jniHandleTraceFile;

    explicit JniUtilParams();

    void readConfig(ConfigMap const &configMap);
};


class FENNEL_FARRAGO_EXPORT JniUtil
{
    friend class JniEnvAutoRef;

    static JavaVM *pVm;

    static jmethodID methGetClassName;

    static jmethodID methGetInterfaces;

    static jmethodID methGetModifiers;

    static jclass classModifier;

    static jmethodID methIsPublic;

    static jmethodID methIterator;

    static jmethodID methHasNext;

    static jmethodID methNext;

    static jmethodID methToString;

    static JNIEnv *getAttachedJavaEnv(bool &needDetach);

    static AtomicCounter handleCount;

    static bool traceHandleCountEnabled;

    static bool closeHandleCountTraceOnZero;

    static std::ofstream handleCountTraceStream;

    static JavaThreadTracker threadTracker;

    static void traceHandleCount(
        const char *pAction, const char *pType, const void *pHandle);

public:
    static const jint jniVersion = JNI_VERSION_1_2;

    static jmethodID methGetJavaStreamHandle;

    static jmethodID methGetIndexRoot;

    static jmethodID methBase64Decode;
    static jclass classRhBase64;

    static jmethodID methRandomUUID;
    static jclass classUUID;

    static jmethodID methFarragoTransformInit;

    static jmethodID methFarragoTransformExecute;

    static jmethodID methFarragoTransformSetInputFetchTimeout;

    static jmethodID methFarragoTransformRestart;

    static jclass classFarragoTransformInputBinding;

    static jmethodID methFarragoTransformInputBindingCons;

    static jmethodID methFarragoRuntimeContextStatementClassForName;

    static jmethodID methFarragoRuntimeContextFindFarragoTransform;

    static jclass classUtil;

    static jmethodID methUtilGetStackTrace;

    static jclass classLong;

    static jclass classInteger;

    static jclass classShort;

    static jclass classDouble;

    static jclass classFloat;

    static jclass classBoolean;

    static jmethodID methLongValueOf;

    static jmethodID methIntegerValueOf;

    static jmethodID methShortValueOf;

    static jmethodID methDoubleValueOf;

    static jmethodID methFloatValueOf;

    static jmethodID methBooleanValueOf;

    static jmethodID methLongValue;

    static jmethodID methIntValue;

    static jmethodID methShortValue;

    static jmethodID methDoubleValue;

    static jmethodID methFloatValue;

    static jmethodID methBooleanValue;

    static void initDebug(char const *envVarName);

    static jint init(JavaVM *pVm);

    static void configure(const JniUtilParams &params);

    static void shutdown();

    static std::string getClassName(jclass jClass);

    static std::string getFirstPublicInterfaceName(jclass jClass);

    static std::string toStdString(JniEnvRef pEnv,jstring jString);

    static jstring toString(JniEnvRef pEnv,jobject jObject);

    static jobject getIter(JniEnvRef pEnv,jobject jCollection);

    static jobject getNextFromIter(JniEnvRef pEnv,jobject jIter);

    static uint lookUpEnum(std::string *pSymbols,std::string const &symbol);

    // TODO jvs 13-Oct-2006:  reprivate this
    static void detachJavaEnv();

    static void incrementHandleCount(const char *pType, const void *pHandle);

    static void decrementHandleCount(const char *pType, const void *pHandle);

    static inline int getHandleCount()
    {
        return handleCount;
    }

    static std::string getXmi(const TupleDescriptor &tupleDesc);

    static ThreadTracker &getThreadTracker();
};

class FENNEL_FARRAGO_EXPORT JniPseudoUuidGenerator
    : public PseudoUuidGenerator
{
public:
    virtual void generateUuid(PseudoUuid &pseudoUuid);
};

// NOTE jvs 16-Oct-2004:  This crazy kludge is for problems arising on Linux
// when using multiple JNI libs.  This has to be included in each
// JNI_OnLoad as a workaround (and it must be a macro, not a function).
// Code was taken from _Stl_loc_assign_ids() in stlport/src/locale_impl.cpp.
#define FENNEL_JNI_ONLOAD_COMMON() \
{ \
  _STL::num_get< \
    char, \
    _STL::istreambuf_iterator<char, _STL::char_traits<char> > >::id._M_index = \
      12; \
  _STL::num_get<char, const char*>::id._M_index          = 13; \
  _STL::num_put< \
    char, \
    _STL::ostreambuf_iterator<char, _STL::char_traits<char> > >::id._M_index = \
      14; \
  _STL::num_put<char, char*>::id._M_index                = 15; \
  _STL::time_get< \
    char, \
    _STL::istreambuf_iterator<char, _STL::char_traits<char> > >::id._M_index = \
      16; \
  _STL::time_get<char, const char*>::id._M_index         = 17; \
  _STL::time_put< \
    char, \
    _STL::ostreambuf_iterator<char, _STL::char_traits<char> > >::id._M_index = \
      18; \
  _STL::time_put<char, char*>::id._M_index               = 19; \
}

FENNEL_END_NAMESPACE

#endif

// End JniUtil.h

---