path: root/examples/src/main/ruby/Poi4R.i

/* ====================================================================
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You 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.
==================================================================== */

%module poi4r


%{

#include <gcj/cni.h>
#include <java/lang/Object.h>
#include <java/lang/Thread.h>
#include <java/lang/ThreadGroup.h>
#include <java/lang/Runnable.h>
#include <java/lang/String.h>
#include <java/lang/Throwable.h>
#include <java/lang/Comparable.h>
#include <java/lang/Integer.h>
#include <java/lang/Long.h>
#include <java/lang/Float.h>
#include <java/lang/Double.h>
#include <java/io/StringWriter.h>
#include <java/io/PrintWriter.h>
#include <java/util/HashMap.h>
#include <java/util/Date.h>
#include <java/util/Calendar.h>
#include <java/lang/System.h>

#include "org/apache/poi/hssf/usermodel/HSSFWorkbook.h"
#include "org/apache/poi/hssf/usermodel/HSSFSheet.h"
#include "org/apache/poi/hssf/usermodel/HSSFRow.h"
#include "org/apache/poi/hssf/usermodel/HSSFCell.h"
#include "org/apache/poi/hssf/usermodel/HSSFFont.h"
#include "org/apache/poi/hssf/usermodel/HSSFCellStyle.h"
#include "org/apache/poi/hssf/usermodel/HSSFDataFormat.h"
#include "org/apache/poi/hssf/usermodel/HSSFHeader.h"
#include "org/apache/poi/hssf/usermodel/HSSFFooter.h"
#include "org/apache/poi/RubyOutputStream.h"


typedef ::org::apache::poi::hssf::usermodel::HSSFWorkbook *jhworkbook;
typedef ::org::apache::poi::hssf::usermodel::HSSFSheet *jhsheet;
typedef ::org::apache::poi::hssf::usermodel::HSSFRow *jhrow;
typedef ::org::apache::poi::hssf::usermodel::HSSFCell *jhcell;
typedef ::org::apache::poi::hssf::usermodel::HSSFCellStyle *jhcellstyle;
typedef ::org::apache::poi::hssf::usermodel::HSSFFont *jhfont;
typedef ::org::apache::poi::hssf::usermodel::HSSFFooter *jhfooter;
typedef ::org::apache::poi::hssf::usermodel::HSSFHeader *jhheader;
typedef ::org::apache::poi::hssf::usermodel::HSSFDataFormat *jhdataformat;

typedef ::java::util::Date *jdate;
typedef ::java::util::Calendar *jcalendar;
typedef ::java::io::OutputStream *joutputstream;
typedef ::java::io::InputStream *jinputstream;
typedef ::java::util::Collection *jstringCollection;
typedef ::java::util::Collection *jtermCollection;
typedef ::java::util::Locale *jlocale;
typedef ::java::lang::Comparable *jcomparable;
typedef JArray<jobject> *jobjectArray;
typedef JArray<jstring> *jstringArray;


static java::lang::Thread *nextThread;
static java::util::HashMap *objects;


static void store_reference(jobject object) {
	java::lang::Integer *ji =new java::lang::Integer(java::lang::System::identityHashCode(object));
	jobject jo = objects->get(ji);
	if (!jo) {
	//	printf("put object in hash\n");
		objects->put(ji,object);
	}
}
static VALUE jo2rv(jobject object, swig_type_info *descriptor)
{
    if (object == NULL)
    {
        return Qnil;
    }
    else
    {
        return SWIG_NewPointerObj((void *) object, descriptor, 0);
    }
}
static int cvtptr(VALUE value, void **jo, swig_type_info *info)
{
    if (SWIG_ConvertPtr(value, jo, info, 0) == 0)
        return 0;
    else
    {
        return -1;
    }
}

static int rv2jo(VALUE rv, jobject *jo, swig_type_info *descriptor)
{
    if (NIL_P(rv))
        *jo = NULL;
    else
    {
        java::lang::Object *javaObj;

        if (cvtptr(rv, (void **) &javaObj, descriptor) == -1)
            return 0;

        *jo = javaObj;
    }

    return 1;
}


static jstring r2j(VALUE object)
{
    if (NIL_P(object)){
        return NULL;
    }
    else {
    	char *ps =  STR2CSTR(object);
        jstring js = JvNewStringLatin1(ps);

        if (!js)
        {
    		rb_raise(rb_eRuntimeError, "ruby str cannot be converted to java: %s",ps);
        }

        return js;
    }
}

VALUE j2r(jstring js)
{
    if (!js)
    {
        return Qnil;
    }
    else
    {
        jint len = JvGetStringUTFLength(js);
        char buf[len + 1];

        JvGetStringUTFRegion(js, 0, len, buf);
        buf[len] = '\0';
       
        return rb_str_new2(buf);
    }
}

static void free_java_obj(void* arg1) {
	jobject object =(jobject) arg1;
	java::lang::Integer *ji =new java::lang::Integer(java::lang::System::identityHashCode(object));
        jobject jo = objects->get(ji);
        if (jo) {
        //        printf("removed object from hash\n");
                objects->remove(ji);
        }
}

static void raise_ruby_error(java::lang::Throwable *e) {
	java::io::StringWriter *buffer = new java::io::StringWriter();
    java::io::PrintWriter *writer = new java::io::PrintWriter(buffer);
    e->printStackTrace(writer);
    writer->close();
    jstring message = buffer->toString();
    jint len = JvGetStringUTFLength(message);
    char buf[len + 1];
    JvGetStringUTFRegion(message, 0, len, buf);
    buf[len] = '\0';
	rb_raise(rb_eRuntimeError, "error calling poi \n %s", buf);
}

%}

typedef long jint;
typedef long long jlong;
typedef char jbyte;
typedef float jfloat;
typedef float jdouble;
typedef int jshort;
typedef bool jboolean;

%typemap(in) SWIGTYPE * {

    if (!rv2jo($input, (jobject *) &$1, $1_descriptor))
        rb_raise(rb_eRuntimeError, "Unrecoverable error in SWIG typemapping");
}
%typemap(out) SWIGTYPE * {

    $result = jo2rv($1, $1_descriptor);
}

%typemap(in) org::apache::poi::hssf::usermodel::HSSFWorkbook{

    if (!rv2jo($input, (jobject *) &$1,
               $descriptor(org::apache::poi::hssf::usermodel::HSSFWorkbook *)))
        SWIG_fail;
}
%typemap(out) org::apache::poi::hssf::usermodel::HSSFWorkbook {
    $result = jo2rv($1, $descriptor(org::apache::poi::hssf::usermodel::HSSFWorkbook *));
}

%typemap(in) jhsheet{

    if (!rv2jo($input, (jobject *) &$1,
               $descriptor(org::apache::poi::hssf::usermodel::HSSFSheet *)))
        SWIG_fail;
}
%typemap(out) jhsheet {

    $result = jo2rv($1, $descriptor(org::apache::poi::hssf::usermodel::HSSFSheet *));
}
%typemap(in) jhrow{

    if (!rv2jo($input, (jobject *) &$1,
               $descriptor(org::apache::poi::hssf::usermodel::HSSFRow *)))
        SWIG_fail;
}
%typemap(out) jhrow {

    $result = jo2rv($1, $descriptor(org::apache::poi::hssf::usermodel::HSSFRow *));
}
%typemap(in) jhcell{

    if (!rv2jo($input, (jobject *) &$1,
               $descriptor(org::apache::poi::hssf::usermodel::HSSFCell *)))
        SWIG_fail;
}
%typemap(out) jhcell {

    $result = jo2rv($1, $descriptor(org::apache::poi::hssf::usermodel::HSSFCell *));
}
%typemap(in) jhfont{

    if (!rv2jo($input, (jobject *) &$1,
                $descriptor(org::apache::poi::hssf::usermodel::HSSFFont *)))
         rb_raise(rb_eRuntimeError, "Unrecoverable error in SWIG typemapping of HSSFFont");
}

%typemap(out) jhfont {

    $result = jo2rv($1, $descriptor(org::apache::poi::hssf::usermodel::HSSFFont *));
}

%typemap(in) jhcellstyle{

    if (!rv2jo($input, (jobject *) &$1,
               $descriptor(org::apache::poi::hssf::usermodel::HSSFCellStyle *)))
		rb_raise(rb_eRuntimeError, "Unrecoverable error in SWIG typemapping of HSSFCellStyle");
}
%typemap(out) jhcellstyle {

    $result = jo2rv($1, $descriptor(org::apache::poi::hssf::usermodel::HSSFCellStyle *));
}
%typemap(in) jhdataformat{

    if (!rv2jo($input, (jobject *) &$1,
               $descriptor(org::apache::poi::hssf::usermodel::HSSFDataFormat *)))
	rb_raise(rb_eRuntimeError, "Unrecoverable error in SWIG typemapping of HSSFDataFormat");
}
%typemap(out) jhdataformat {

    $result = jo2rv($1, $descriptor(org::apache::poi::hssf::usermodel::HSSFDataFormat *));
}


%typemap(in) jstring {
    $1 = r2j($input);
}
%typemap(out) jstring {
    $result = j2r($1);
}
%typecheck(SWIG_TYPECHECK_STRING) jstring {
    $1 = ( NIL_P($input) || TYPE($input)==T_STRING );
}

%typemap(in) joutputstream {

        jlong ptr;
		if (!rb_respond_to($input, rb_intern("putc"))) rb_raise(rb_eTypeError,"Expected IO");
        *(VALUE *) &ptr = (VALUE) $input;
        $1 = new org::apache::poi::RubyOutputStream(ptr);
}
%typemap(in) jcalendar {
	$1 = java::util::Calendar::getInstance();
	//$1->setTimeInMillis((long long) NUM2DBL(rb_funcall($input,rb_intern("to_i"),0,NULL))*1000.0);
	$1->set(FIX2INT(rb_funcall($input,rb_intern("year"),0,NULL)),
		FIX2INT(rb_funcall($input,rb_intern("mon"),0,NULL))-1,
		FIX2INT(rb_funcall($input,rb_intern("day"),0,NULL)),
		FIX2INT(rb_funcall($input,rb_intern("hour"),0,NULL)),
		FIX2INT(rb_funcall($input,rb_intern("min"),0,NULL)),
		FIX2INT(rb_funcall($input,rb_intern("sec"),0,NULL))
		);	
}

%typecheck(SWIG_TYPECHECK_POINTER) jcalendar {
    $1 = rb_respond_to($input, rb_intern("asctime"));
}

%typemap(out) jdate {
	jlong t = ((jdate) $1)->getTime();
	//TODO: separate seconds and microsecs
	int ts=t/1000;
	$result=rb_time_new((time_t) ts, 0 );
}


%freefunc org::apache::poi::hssf::usermodel::HSSFWorkbook "free_java_obj";

%exception {
    try {
        $action
    } catch (java::lang::Throwable *e) {
    	raise_ruby_error(e);
    }
}
%exception org::apache::poi::hssf::usermodel::HSSFWorkbook::HSSFWorkbook {
    try {
        $action
		store_reference(result);
    } catch (java::lang::Throwable *e) {
        raise_ruby_error(e);
    }
}




namespace java {
    namespace lang {
        class Object {
            jstring toString();
        };
%nodefault;
	class System : public Object {
        public:
            static jstring getProperty(jstring);
            static jstring getProperty(jstring, jstring);
            static void load(jstring);
            static void loadLibrary(jstring);
            static void mapLibraryName(jstring);
            static void runFinalization();
            static void setProperty(jstring, jstring);
        };
%makedefault;
    }
    namespace io {
%nodefault;
        class InputStream : public ::java::lang::Object {
        };
        class OutputStream : public ::java::lang::Object {
        };
        
%makedefault;
    }
    namespace util {
        class Date : public ::java::lang::Object {
        public:
            Date();
            Date(jlong);
            void setTime(jlong);
            jstring toString();
        };
    }
}


namespace org {
    namespace apache {
        namespace poi {
            namespace hssf {
            	namespace usermodel {
%nodefault; 
	                class HSSFWorkbook : public ::java::lang::Object {
	                public:
                		HSSFWorkbook();
	                    jstring getSheetName(jint);
	                    jint getNumberOfSheets();
	                    void setSheetOrder(jstring,jint);
	                    void setSheetName(jint,jstring);
	                    void setSheetName(jint,jstring,jshort);
	                    jint getSheetIndex(jstring);
	                    jhsheet createSheet();
	                    jhsheet cloneSheet(jint);
	                    jhsheet createSheet(jstring);
	                    jhsheet getSheetAt(jint);
	                    jhsheet getSheet(jstring);
	                    void removeSheetAt(jint);
	                    jhcellstyle createCellStyle();
			    jhfont createFont();
			    jhdataformat createDataFormat(); 
	                    void write(joutputstream);
	                    
	                };

	                class HSSFSheet : public ::java::lang::Object {
	                public:
	                	jhrow createRow(jint);
	                	jhrow getRow(jint);
	                	jhfooter getFooter();
	                	jhheader getHeader();
	                };
	                class HSSFRow : public ::java::lang::Object {
	                public:
	                	jhcell createCell(jshort);
	                	jhcell getCell(jshort);
	                	//jboolean getProtect(); //only in 2.5
	                	
	                };
	                class HSSFCell : public ::java::lang::Object {
	                public:
	                	void setCellValue(jdouble);
	                	void setCellValue(jstring);
	                	void setCellValue(jboolean);
	                	void setCellValue(jcalendar);
	                	void setCellFormula(jstring);
	                	jstring getStringCellValue();
	                	jdouble getNumericCellValue();
	                	jdate getDateCellValue();
	                	jstring getCellFormula();
	                	jboolean getBooleanCellValue();
	                	jint getCellType();
	                	jshort getEncoding();
	                	void setAsActiveCell();
	                	
	                	void setCellStyle(jhcellstyle);
	                	void setEncoding(jshort encoding);
	                	
	                	static const jint CELL_TYPE_BLANK;
	                	static const jint CELL_TYPE_BOOLEAN;
	                	static const jint CELL_TYPE_ERROR;
	                	static const jint CELL_TYPE_FORMULA;
	                	static const jint CELL_TYPE_NUMERIC;
	                	static const jint CELL_TYPE_STRING;
	                	
	                	static const jshort ENCODING_COMPRESSED_UNICODE;
	                	static const jshort ENCODING_UTF_16;
	                };
					class HSSFCellStyle : public ::java::lang::Object {
					public:
						static const jshort ALIGN_CENTER;
						static const jshort ALIGN_CENTER_SELECTION;
						static const jshort ALIGN_FILL;
						static const jshort ALIGN_GENERAL;
						static const jshort ALIGN_JUSTIFY;
						static const jshort ALIGN_LEFT;
						static const jshort ALIGN_RIGHT;
						static const jshort ALT_BARS;
						static const jshort BIG_SPOTS;
						static const jshort BORDER_DASH_DOT;
						static const jshort BORDER_DASH_DOT_DOT;
						static const jshort BORDER_DASHED;
						static const jshort BORDER_DOTTED;
						static const jshort BORDER_DOUBLE;
						static const jshort BORDER_HAIR;
						static const jshort BORDER_MEDIUM;
						static const jshort BORDER_MEDIUM_DASH_DOT;
						static const jshort BORDER_MEDIUM_DASH_DOT_DOT;
						static const jshort BORDER_MEDIUM_DASHED;
						static const jshort BORDER_NONE;
						static const jshort BORDER_SLANTED_DASH_DOT;
						static const jshort BORDER_THICK;
						static const jshort BORDER_THIN;
						static const jshort BRICKS;
						static const jshort DIAMONDS;
						static const jshort FINE_DOTS;
						static const jshort NO_FILL;
						static const jshort SOLID_FOREGROUND;
						static const jshort SPARSE_DOTS;
						static const jshort SQUARES;
						static const jshort THICK_BACKWARD_DIAG;
						static const jshort THICK_FORWARD_DIAG;
						static const jshort THICK_HORZ_BANDS;
						static const jshort THICK_VERT_BANDS;
						static const jshort THIN_BACKWARD_DIAG;
						static const jshort THIN_FORWARD_DIAG;
						static const jshort THIN_HORZ_BANDS;
						static const jshort THIN_VERT_BANDS;
						static const jshort VERTICAL_BOTTOM;
						static const jshort VERTICAL_CENTER;
						static const jshort VERTICAL_JUSTIFY;
						static const jshort VERTICAL_TOP;
						
						jshort getAlignment();
						jshort getBorderBottom();
						jshort getBorderLeft();
						jshort getBorderRight();
						jshort getBorderTop();
						jshort getBottomBorderColor();
						jshort getDataFormat();
						jshort getFillBackgroundColor();
						jshort getFillForegroundColor();
						jshort getFillPattern();
						jshort getFontIndex();
						jboolean getHidden();
						jshort getIndention();
						jshort getIndex();
						jshort getLeftBorderColor();
						jboolean getLocked();
						jshort getRightBorderColor();
						jshort getRotation();
						jshort getTopBorderColor();
						jshort getVerticalAlignment();
						jboolean getWrapText();
						void setAlignment(jshort) ;
						void setBorderBottom(jshort );
						void setBorderLeft(jshort );
						void setBorderRight(jshort );
						void setBorderTop(jshort );
						void setBottomBorderColor(jshort );
						void setDataFormat(jshort );
						void setFillBackgroundColor(jshort );
						void setFillForegroundColor(jshort );
						void setFillPattern(jshort );
						void setFont(jhfont );
						void setHidden(jboolean );
						void setIndention(jshort );
						void setLeftBorderColor(jshort );
						void setLocked(jboolean );
						void setRightBorderColor(jshort );
						void setRotation(jshort );
						void setTopBorderColor(jshort );
						void setVerticalAlignment(jshort );
						void setWrapText(jboolean );
					};
					class HSSFDataFormat : public ::java::lang::Object {
					public:
						static jstring getBuiltinFormat(jshort);
						static jshort getBuiltinFormat(jstring);
						jstring getFormat(jshort);
						jshort getFormat(jstring);
						static jint getNumberOfBuiltinBuiltinFormats();
						//TODO static jlist getBuiltinFormats(); 
		
					};
					class HSSFFont : public ::java::lang::Object {
					public:
						static const jshort 	BOLDWEIGHT_BOLD;
static const jshort 	BOLDWEIGHT_NORMAL;
static const jshort 	COLOR_NORMAL;
static const jshort 	COLOR_RED;
static const jstring 	FONT_ARIAL;
static const jshort 	SS_NONE;
static const jshort 	SS_SUB;
static const jshort 	SS_SUPER;
static const jshort 	U_DOUBLE;
static const jshort 	U_DOUBLE_ACCOUNTING;
static const jshort 	U_NONE;
static const jshort 	U_SINGLE;
static const jshort 	U_SINGLE_ACCOUNTING;
 
 jshort 	getBoldweight();
 jshort 	getColor();
 jshort 	getFontHeight();
 jshort 	getFontHeightInPoints();
 jstring 	getFontName();
 jshort 	getIndex();
 jboolean 	getItalic();
 jboolean 	getStrikeout();
 jshort 	getTypeOffset();
 jshort 	getUnderline();
 void 	setBoldweight(jshort );
 void 	setColor(jshort );
 void 	setFontHeight(jshort );
 void 	setFontHeightInPoints(jshort );
 void 	setFontName(jstring );
 void 	setItalic(jboolean );
 void 	setStrikeout(jboolean );
 void 	setTypeOffset(jshort );
 void 	setUnderline(jshort );
};
%makedefault;
	            }
            }
        }
    }
}





%init %{

    JvCreateJavaVM(NULL);
    JvAttachCurrentThread(NULL, NULL);

    nextThread = new java::lang::Thread();
    objects = new java::util::HashMap();

    java::util::HashMap *props = (java::util::HashMap *)
        java::lang::System::getProperties();
    props->put(JvNewStringUTF("inRuby"), objects);

    JvInitClass(&org::apache::poi::hssf::usermodel::HSSFFont::class$);
    JvInitClass(&org::apache::poi::hssf::usermodel::HSSFCell::class$);
    JvInitClass(&org::apache::poi::hssf::usermodel::HSSFSheet::class$);
    JvInitClass(&org::apache::poi::hssf::usermodel::HSSFCellStyle::class$);

%}