/*

 *   Licensed under the Apache License, Version 2.0 (the "License");

 *   you may not use this file except in compliance with the License.

 *   You may obtain a copy of the License at

 *

 *       http://www.apache.org/licenses/LICENSE-2.0

 *

 *   Unless required by applicable law or agreed to in writing, software

 *   distributed under the License is distributed on an "AS IS" BASIS,

 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *   See the License for the specific language governing permissions and

 *   limitations under the License.

 */

#ifndef _functions_h

#define _functions_h

#include "java/util/Iterator.h"

#include "java/util/Enumeration.h"

#include "java/lang/String.h"

#include "java/lang/Object.h"

#include "macros.h"

#if PY_VERSION_HEX < 0x02050000

typedef int Py_ssize_t;

typedef inquiry lenfunc;

typedef intargfunc ssizeargfunc;

typedef intintargfunc ssizessizeargfunc;

typedef intobjargproc ssizeobjargproc;

typedef intintobjargproc ssizessizeobjargproc;

#endif

typedef jclass (*getclassfn)(void);

typedef PyTypeObject **(*getparametersfn)(void *);

PyObject *PyErr_SetArgsError(char *name, PyObject *args);

PyObject *PyErr_SetArgsError(PyObject *self, char *name, PyObject *args);

PyObject *PyErr_SetArgsError(PyTypeObject *type, char *name, PyObject *args);

PyObject *PyErr_SetJavaError(jthrowable throwable);

extern PyObject *PyExc_JavaError;

extern PyObject *PyExc_InvalidArgsError;

void throwPythonError(void);

void throwTypeError(const char *name, PyObject *object);

#if defined(_MSC_VER) || defined(__SUNPRO_CC)

#define parseArgs __parseArgs

#define parseArg __parseArg

int __parseArgs(PyObject *args, char *types, ...);

int __parseArg(PyObject *arg, char *types, ...);

int _parseArgs(PyObject **args, unsigned int count, char *types,

	       va_list list, va_list check);

#else

#define parseArgs(args, types, rest...) \

    _parseArgs(((PyTupleObject *)(args))->ob_item, \

               ((PyTupleObject *)(args))->ob_size, types, ##rest)

#define parseArg(arg, types, rest...) \

    _parseArgs(&(arg), 1, types, ##rest)

int _parseArgs(PyObject **args, unsigned int count, char *types, ...);

#endif

int abstract_init(PyObject *self, PyObject *args, PyObject *kwds);

PyObject *wrapType(PyTypeObject *type, const jobject& obj);

PyObject *j2p(const java::lang::String& js);

java::lang::String p2j(PyObject *object);

PyObject *make_descriptor(PyTypeObject *value);

PyObject *make_descriptor(getclassfn initializeClass);

PyObject *make_descriptor(getclassfn initializeClass, int generics);

PyObject *make_descriptor(PyObject *value);

PyObject *make_descriptor(PyObject *(*wrapfn)(const jobject &));

PyObject *make_descriptor(jboolean value);

PyObject *make_descriptor(jbyte value);

PyObject *make_descriptor(jchar value);

PyObject *make_descriptor(jdouble value);

PyObject *make_descriptor(jfloat value);

PyObject *make_descriptor(jint value);

PyObject *make_descriptor(jlong value);

PyObject *make_descriptor(jshort value);

jobjectArray make_array(jclass cls, PyObject *sequence);

PyObject *callSuper(PyTypeObject *type,

                    const char *name, PyObject *args, int cardinality);

PyObject *callSuper(PyTypeObject *type, PyObject *self,

                    const char *name, PyObject *args, int cardinality);

template<class T> PyObject *get_iterator(T *self)

{

    java::util::Iterator iterator((jobject) NULL);

    OBJ_CALL(iterator = self->object.iterator());

    return java::util::t_Iterator::wrap_Object(iterator);

}

#ifdef _java_generics

template<class T> PyObject *get_generic_iterator(T *self)

{

    java::util::Iterator iterator((jobject) NULL);

    PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;

    OBJ_CALL(iterator = self->object.iterator());

    return java::util::t_Iterator::wrap_Object(iterator, param);

}

#endif

template<class T, class U> PyObject *get_iterator_next(T *self)

{

    jboolean hasNext;

    OBJ_CALL(hasNext = self->object.hasNext());

    if (!hasNext)

    {

        PyErr_SetNone(PyExc_StopIteration);

        return NULL;

    }

    jobject next;

    OBJ_CALL(next = env->iteratorNext(self->object.this$));

    jclass cls = java::lang::String::initializeClass();

    if (env->get_vm_env()->IsInstanceOf(next, cls))

        return env->fromJString((jstring) next, 1);

    return U::wrap_jobject(next);

}

#ifdef _java_generics

template<class T, class U> PyObject *get_generic_iterator_next(T *self)

{

    jboolean hasNext;

    OBJ_CALL(hasNext = self->object.hasNext());

    if (!hasNext)

    {

        PyErr_SetNone(PyExc_StopIteration);

        return NULL;

    }

    jobject next;

    OBJ_CALL(next = env->iteratorNext(self->object.this$));

    jclass cls = java::lang::String::initializeClass();

    if (env->get_vm_env()->IsInstanceOf(next, cls))

        return env->fromJString((jstring) next, 1);

    PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;

    if (param != NULL)

        return wrapType(param, next);

    return U::wrap_jobject(next);

}

#endif

template<class T, class U> PyObject *get_enumeration_next(T *self)

{

    jboolean hasMoreElements;

    OBJ_CALL(hasMoreElements = self->object.hasMoreElements());

    if (!hasMoreElements)

    {

        PyErr_SetNone(PyExc_StopIteration);

        return NULL;

    }

    jobject next;

    OBJ_CALL(next = env->enumerationNext(self->object.this$));

    jclass cls = java::lang::String::initializeClass();

    if (env->get_vm_env()->IsInstanceOf(next, cls))

        return env->fromJString((jstring) next, 1);

    return U::wrap_jobject(next);

}

#ifdef _java_generics

template<class T, class U> PyObject *get_generic_enumeration_next(T *self)

{

    jboolean hasMoreElements;

    OBJ_CALL(hasMoreElements = self->object.hasMoreElements());

    if (!hasMoreElements)

    {

        PyErr_SetNone(PyExc_StopIteration);

        return NULL;

    }

    jobject next;

    OBJ_CALL(next = env->enumerationNext(self->object.this$));

    jclass cls = java::lang::String::initializeClass();

    if (env->get_vm_env()->IsInstanceOf(next, cls))

        return env->fromJString((jstring) next, 1);

    PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;

    if (param != NULL)

        return wrapType(param, next);

    return U::wrap_jobject(next);

}

#endif

template<class T, class U, class V> PyObject *get_next(T *self)

{

    V next((jobject) NULL);

    OBJ_CALL(next = self->object.next());

    if (!next)

    {

        PyErr_SetNone(PyExc_StopIteration);

        return NULL;

    }

    jclass cls = java::lang::String::initializeClass();

    if (env->get_vm_env()->IsInstanceOf(next.this$, cls))

        return env->fromJString((jstring) next.this$, 0);

    return U::wrap_Object(next);

}

#ifdef _java_generics

template<class T, class U, class V> PyObject *get_generic_next(T *self)

{

    V next((jobject) NULL);

    OBJ_CALL(next = self->object.next());

    if (!next)

    {

        PyErr_SetNone(PyExc_StopIteration);

        return NULL;

    }

    jclass cls = java::lang::String::initializeClass();

    if (env->get_vm_env()->IsInstanceOf(next.this$, cls))

        return env->fromJString((jstring) next.this$, 0);

    PyTypeObject *param = self->parameters ? self->parameters[0] : NULL;

    if (param != NULL)

        return wrapType(param, next.this$);

    return U::wrap_Object(next);

}

#endif

PyObject *get_extension_iterator(PyObject *self);

PyObject *get_extension_next(PyObject *self);

PyObject *get_extension_nextElement(PyObject *self);

jobjectArray fromPySequence(jclass cls, PyObject *sequence);

PyObject *castCheck(PyObject *obj, getclassfn initializeClass,

                    int reportError);

void installType(PyTypeObject *type, PyObject *module, char *name,

                 int isExtension);

#ifdef _java_generics

PyObject *typeParameters(PyTypeObject *types[], size_t size);

#endif

extern PyTypeObject FinalizerClass$$Type;

extern PyTypeObject FinalizerProxy$$Type;

typedef struct {

    PyObject_HEAD

    PyObject *object;

} t_fp;

#endif /* _functions_h */