JniProxy.h

Go to the documentation of this file.

/*
// $Id: //open/dev/fennel/farrago/JniProxy.h#15 $
// 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_JniProxy_Included
#define Fennel_JniProxy_Included

#include "fennel/farrago/JniUtil.h"

#include <map>

FENNEL_BEGIN_NAMESPACE

// This file contains the generic support for proxies generated by
// net.sf.farrago.fennel.ProxyGen.

class FENNEL_FARRAGO_EXPORT JniProxy
{
protected:
    // helper for methods which return strings
    std::string constructString(jobject jStringObj)
    {
        jstring jString = reinterpret_cast<jstring>(jStringObj);
        return JniUtil::toStdString(pEnv,jString);
    }

    // helper for setters which take strings (returns local JNI reference)
    jstring constructJavaString(const std::string &stringObj)
    {
        return pEnv->NewStringUTF(stringObj.c_str());
    }

    int32_t int32Value(jobject jIntegerObj)
    {
        return pEnv->CallIntMethod(jIntegerObj, JniUtil::methIntValue);
    }

    jobject constructJavaInteger(const int32_t &value)
    {
        return pEnv->CallStaticObjectMethod(
            JniUtil::classInteger,
            JniUtil::methIntegerValueOf,
            static_cast<jint>(value));
    }

    int64_t int64Value(jobject jLongObj)
    {
        return pEnv->CallLongMethod(jLongObj, JniUtil::methLongValue);
    }

    jobject constructJavaLong(const int64_t &value)
    {
        return pEnv->CallStaticObjectMethod(
            JniUtil::classLong,
            JniUtil::methLongValueOf,
            static_cast<jlong>(value));
    }

    int16_t int16Value(jobject jShortObj)
    {
        return pEnv->CallShortMethod(jShortObj, JniUtil::methShortValue);
    }

    jobject constructJavaShort(const int16_t &value)
    {
        return pEnv->CallStaticObjectMethod(
            JniUtil::classShort,
            JniUtil::methShortValueOf,
            static_cast<jshort>(value));
    }

    double doubleValue(jobject jDoubleObj)
    {
        return pEnv->CallDoubleMethod(jDoubleObj, JniUtil::methDoubleValue);
    }

    jobject constructJavaDouble(const double &value)
    {
        return pEnv->CallStaticObjectMethod(
            JniUtil::classDouble,
            JniUtil::methDoubleValueOf,
            static_cast<jdouble>(value));
    }

    float floatValue(jobject jFloatObj)
    {
        return pEnv->CallFloatMethod(jFloatObj, JniUtil::methFloatValue);
    }

    jobject constructJavaFloat(const float &value)
    {
        return pEnv->CallStaticObjectMethod(
            JniUtil::classFloat,
            JniUtil::methFloatValueOf,
            static_cast<jfloat>(value));
    }

    bool boolValue(jobject jBooleanObj)
    {
        return pEnv->CallBooleanMethod(jBooleanObj, JniUtil::methBooleanValue);
    }

    jobject constructJavaBoolean(const bool &value)
    {
        return pEnv->CallStaticObjectMethod(
            JniUtil::classBoolean,
            JniUtil::methBooleanValueOf,
            static_cast<jboolean>(value));
    }

public:
    JniEnvRef pEnv;

    jobject jObject;

    explicit JniProxy();

    virtual ~JniProxy();

    void init(JniEnvRef pEnv,jobject jObject);

    std::string getInterfaceName()
    {
        jclass jClass = pEnv->GetObjectClass(jObject);
        return JniUtil::getFirstPublicInterfaceName(jClass);
    }
};

template <class T>
class JniProxyIter : public boost::shared_ptr<T>
{
public:
    jobject jIter;

    explicit JniProxyIter()
        : boost::shared_ptr<T>(new T)
    {
        // by default, no iteration support
        jIter = NULL;
    }

    void operator ++ ()
    {
        assert(jIter);
        boost::shared_ptr<T>::get()->jObject =
            JniUtil::getNextFromIter(boost::shared_ptr<T>::get()->pEnv,jIter);
        if (!(boost::shared_ptr<T>::get()->jObject)) {
            // iteration exhausted, so become singular
            boost::shared_ptr<T>::reset();
        }
    }
};

class FENNEL_FARRAGO_EXPORT JniProxyVisitor
{
public:
    virtual ~JniProxyVisitor();

    virtual void unhandledVisit();
};

class FENNEL_FARRAGO_EXPORT JniProxyVisitTableBase
{
public:
    struct VisitorMethod
    {
        virtual ~VisitorMethod()
        {
        }

        virtual void execute(JniProxyVisitor &visitor,JniProxy &) = 0;
    };

    typedef boost::shared_ptr<VisitorMethod> SharedVisitorMethod;

    typedef std::map<std::string,SharedVisitorMethod> MethodMap;

    MethodMap methodMap;

    void addMethod(jclass jClass,SharedVisitorMethod pMethod)
    {
        assert(pMethod);
        methodMap[JniUtil::getClassName(jClass)] = pMethod;
    }


    void accept(JniProxyVisitor &visitor,JniProxy &proxy)
    {
        // NOTE:  it's OK to use operator [] here since it's an error to call
        // with the wrong proxy type, so in the non-error case we should always
        // find something
        std::string className = proxy.getInterfaceName();
        SharedVisitorMethod pMethod = methodMap[className];
        if (!pMethod) {
            throw std::logic_error(
                std::string("error: unknown method for proxy class '") +
                className + "'");
        }
        pMethod->execute(visitor,proxy);
    }
};

template <class Visitor>
class JniProxyVisitTable : public JniProxyVisitTableBase
{
public:
    template<class ProxyImpl>
    struct VisitorMethodImpl : public VisitorMethod
    {
        virtual void execute(JniProxyVisitor &visitor,JniProxy &proxy)
        {
            // This accomplishes an effective downcast by reinstantiating proxy
            // as the correct type.  The abstract proxy and the specific proxy
            // alias the same underlying Java object, but it's important to
            // realize that the proxies themselves don't share the same
            // identity.
            ProxyImpl proxyImpl;
            proxyImpl.init(proxy.pEnv,proxy.jObject);
            // This binds to the correct visit overload.
            Visitor &visitorImpl = dynamic_cast<Visitor &>(visitor);
            visitorImpl.visit(proxyImpl);
        }
    };
};

FENNEL_END_NAMESPACE

#endif

// End JniProxy.h

---