root/lang/ruby/RubyESRIShape/RubyESRIShape.c @ 2165

#include "ruby.h"
#include "Shape.h"

static VALUE rb_cShape       = 0;
static VALUE rb_cPolygon     = 0;
static VALUE rb_cPolyline    = 0;
static VALUE rb_cPoint       = 0;
static VALUE rb_cBoundingBox = 0;

VALUE getRubyESRIShapePolygonClass()
{
        return rb_cPolygon;
}

VALUE getRubyESRIShapePolylineClass()
{
        return rb_cPolyline;
}

VALUE getRubyESRIShapePointClass()
{
        return rb_cPoint;
}

VALUE getRubyESRIShapeBoundingBoxClass()
{
        return rb_cBoundingBox;
}

#ifndef RUBYESRISHAPE_TEST

static VALUE rb_shape_allocate(VALUE klass);
static void  rb_shape_free(void *ptr);
static void  rb_shape_mark(void *ptr);

static VALUE rb_polygon_allocate(VALUE klass);
static void  rb_polygon_free(void *ptr);
static void  rb_polygon_mark(void *ptr);

static VALUE rb_polyline_allocate(VALUE klass);
static void  rb_polyline_free(void *ptr);

static void  rb_point_free(void *ptr);

// Shape

static VALUE rb_shape_allocate(VALUE klass)
{
        RShapeData* indata = ALLOC(RShapeData);
        indata->pThis = c_Shape_new();

        return Data_Wrap_Struct(klass, rb_shape_mark, rb_shape_free, indata);
}

static void rb_shape_free(void *ptr)
{
        if (ptr)
        {
                if (((RShapeData*)ptr)->pThis)
                        c_Shape_delete(((RShapeData*)ptr)->pThis);

                free(ptr);
        }
}

static void rb_shape_mark(void *ptr)
{
        if (ptr)
        {
                if (((RShapeData*)ptr)->pThis)
                        c_Shape_markRubyGC(((RShapeData*)ptr)->pThis);
        }
}

static VALUE rb_shape_initialize(VALUE self, VALUE shape_name)
{
        RShapeData* indata;
        es_error_t rv;
    Data_Get_Struct(self, RShapeData, indata);

        rv = c_Shape_readFromFile(indata->pThis, STR2CSTR(shape_name));
        if (rv == ESHP_CANNOTOPEN)
                rb_raise(rb_eIOError, "cannot open the shape file.");
        else if (rv == ESHP_UNMATCHED_SHAPETYPE)
                rb_raise(rb_eIOError, "shape types unmatched between files.");

        /* ESHP_NOINDEXFILE doesn't raise any errors */

        return Qnil;
}

static VALUE rb_shape_aref(VALUE self, VALUE index)
{
        RShapeData* indata;
    Data_Get_Struct(self, RShapeData, indata);

        return c_Shape_getRecordAt(indata->pThis, NUM2LONG(index));
}

static VALUE rb_shape_length(VALUE self)
{
        RShapeData* indata;
    Data_Get_Struct(self, RShapeData, indata);

        return INT2NUM( c_Shape_getLength(indata->pThis) );
}

static VALUE rb_shape_each(VALUE self)
{
        RShapeData* indata;
        int len, i;
    Data_Get_Struct(self, RShapeData, indata);

        len = c_Shape_getLength(indata->pThis);
        for (i = 0;i < len;i++)
        {
                volatile VALUE arr = rb_ary_new2(2);
                rb_ary_push(arr, INT2NUM(i+1) );
                rb_ary_push(arr, c_Shape_getRecordAt(indata->pThis, i+1) );

                rb_yield(arr);
        }

        return self;
}

static VALUE rb_shape_type(VALUE self)
{
        RShapeData* indata;
    Data_Get_Struct(self, RShapeData, indata);

        return INT2NUM( c_Shape_getType(indata->pThis) );
}

// Polygon

static VALUE rb_polygon_allocate(VALUE klass)
{
        RPolygonData* indata = ALLOC(RPolygonData);
        indata->pThis = NULL;

        return Data_Wrap_Struct(klass, rb_polygon_mark, rb_polygon_free, indata);
}

static void rb_polygon_free(void *ptr)
{
        if (ptr)
        {
                if (((RPolygonData*)ptr)->pThis)
                        c_Polygon_delete(((RPolygonData*)ptr)->pThis);
                free(ptr);

        }
}

static void rb_polygon_mark(void *ptr)
{
        if (ptr)
        {
                if (((RPolygonData*)ptr)->pThis)
                        c_Polygon_markRubyGC(((RPolygonData*)ptr)->pThis);
        }
}

static VALUE rb_polygon_aref(VALUE self, VALUE index)
{
        RPolygonData* indata;
    Data_Get_Struct(self, RPolygonData, indata);

        return c_Polygon_getPartAt(indata->pThis, NUM2LONG(index));
}

static VALUE rb_polygon_length(VALUE self)
{
        RPolygonData* indata;
    Data_Get_Struct(self, RPolygonData, indata);

        return INT2NUM( c_Polygon_getPartsLength(indata->pThis) );
}

static VALUE rb_polygon_each(VALUE self)
{
        RPolygonData* indata;
        int len, i;
    Data_Get_Struct(self, RPolygonData, indata);

        len = c_Polygon_getPartsLength(indata->pThis);
        for (i = 0;i < len;i++)
        {
                VALUE arr = rb_ary_new2(2);
                rb_ary_push(arr, INT2NUM(i) );
                rb_ary_push(arr, c_Polygon_getPartAt(indata->pThis, i) );

                rb_yield(arr);
        }

        return self;
}

static VALUE rb_polygon_bounding_box(VALUE self)
{
        RPolygonData* indata;
    Data_Get_Struct(self, RPolygonData, indata);

        return c_Polygon_getBoundingBox(indata->pThis);
}

// Polyline

static VALUE rb_polyline_allocate(VALUE klass)
{
        RPolylineData* indata = ALLOC(RPolylineData);
        indata->pThis = NULL;

        return Data_Wrap_Struct(klass, 0, rb_polyline_free, indata);
}

static void rb_polyline_free(void *ptr)
{
        if (ptr)
        {
                if (((RPolylineData*)ptr)->pThis)
                        c_Polyline_delete(((RPolylineData*)ptr)->pThis);
                free(ptr);
        }
}

static VALUE rb_polyline_aref(VALUE self, VALUE index)
{
        RPolylineData* indata;
    Data_Get_Struct(self, RPolylineData, indata);

        return c_Polyline_getPartAt(indata->pThis, NUM2LONG(index));
}

static VALUE rb_polyline_length(VALUE self)
{
        RPolylineData* indata;
    Data_Get_Struct(self, RPolylineData, indata);

        return INT2NUM( c_Polyline_getPartsLength(indata->pThis) );
}

static VALUE rb_polyline_each(VALUE self)
{
        RPolylineData* indata;
        int len, i;
    Data_Get_Struct(self, RPolylineData, indata);

        len = c_Polyline_getPartsLength(indata->pThis);
        for (i = 0;i < len;i++)
        {
                VALUE arr = rb_ary_new2(2);
                rb_ary_push(arr, INT2NUM(i) );
                rb_ary_push(arr, c_Polyline_getPartAt(indata->pThis, i) );

                rb_yield(arr);
        }

        return self;
}

// Point

static VALUE rb_point_allocate(VALUE klass)
{
        RPointData* indata = ALLOC(RPointData);
        indata->pThis = NULL;

        return Data_Wrap_Struct(klass, 0, rb_point_free, indata);
}

static void rb_point_free(void *ptr)
{
        if (ptr)
        {
                if (((RPointData*)ptr)->pThis)
                        c_Point_delete(((RPointData*)ptr)->pThis);
                free(ptr);
        }
}

static VALUE rb_point_x(VALUE self)
{
        RPointData* indata;
    Data_Get_Struct(self, RPointData, indata);

        return rb_float_new( c_Point_getX(indata->pThis) );
}

static VALUE rb_point_y(VALUE self)
{
        RPointData* indata;
    Data_Get_Struct(self, RPointData, indata);

        return rb_float_new( c_Point_getY(indata->pThis) );
}

static VALUE rb_point_z(VALUE self)
{
        RPointData* indata;
    Data_Get_Struct(self, RPointData, indata);

        return rb_float_new( c_Point_getZ(indata->pThis) );
}

static VALUE rb_point_m(VALUE self)
{
        RPointData* indata;
    Data_Get_Struct(self, RPointData, indata);

        return rb_float_new( c_Point_getM(indata->pThis) );
}

// BoundingBox
static VALUE rb_bbox_allocate(VALUE klass)
{
        RubyBoundingBox* indata = ALLOC(RubyBoundingBox);
        return Data_Wrap_Struct(klass, 0, 0, indata);
}

static VALUE rb_bbox_x_min(VALUE self)
{
        RubyBoundingBox* indata;
    Data_Get_Struct(self, RubyBoundingBox, indata);
        return rb_float_new( indata->xMin );
}

static VALUE rb_bbox_x_max(VALUE self)
{
        RubyBoundingBox* indata;
    Data_Get_Struct(self, RubyBoundingBox, indata);
        return rb_float_new( indata->xMax );
}

static VALUE rb_bbox_y_min(VALUE self)
{
        RubyBoundingBox* indata;
    Data_Get_Struct(self, RubyBoundingBox, indata);
        return rb_float_new( indata->yMin );
}

static VALUE rb_bbox_y_max(VALUE self)
{
        RubyBoundingBox* indata;
    Data_Get_Struct(self, RubyBoundingBox, indata);
        return rb_float_new( indata->yMax );
}

static VALUE rb_bbox_z_min(VALUE self)
{
        RubyBoundingBox* indata;
    Data_Get_Struct(self, RubyBoundingBox, indata);
        return rb_float_new( indata->zMin );
}

static VALUE rb_bbox_z_max(VALUE self)
{
        RubyBoundingBox* indata;
    Data_Get_Struct(self, RubyBoundingBox, indata);
        return rb_float_new( indata->zMax );
}

void Init_RubyESRIShape()
{
        VALUE rb_mRubyESRIShape;

        // module
        rb_mRubyESRIShape = rb_define_module("RubyESRIShape");

        // class
        rb_cShape = rb_define_class_under (rb_mRubyESRIShape, "Shape", rb_cObject);
        rb_define_alloc_func(rb_cShape, rb_shape_allocate);

        rb_define_private_method(rb_cShape, "initialize", rb_shape_initialize, 1);
        rb_define_method(rb_cShape, "[]",     rb_shape_aref  , 1);
        rb_define_method(rb_cShape, "length", rb_shape_length, 0);
        rb_define_method(rb_cShape, "each",   rb_shape_each  , 0);
        rb_define_method(rb_cShape, "type",   rb_shape_type  , 0);

        // class
        rb_cPolygon = rb_define_class_under (rb_mRubyESRIShape, "Polygon", rb_cObject);
        rb_define_alloc_func(rb_cPolygon, rb_polygon_allocate);
        rb_define_method(rb_cPolygon, "[]"    , rb_polygon_aref  , 1);
        rb_define_method(rb_cPolygon, "length", rb_polygon_length, 0);
        rb_define_method(rb_cPolygon, "each"  , rb_polygon_each  , 0);
        rb_define_method(rb_cPolygon, "bounding_box", rb_polygon_bounding_box, 0);

        // class
        rb_cPolyline = rb_define_class_under (rb_mRubyESRIShape, "Polyline", rb_cObject);
        rb_define_alloc_func(rb_cPolyline, rb_polyline_allocate);
        rb_define_method(rb_cPolyline, "length", rb_polyline_length, 0);
        rb_define_method(rb_cPolyline, "[]"    , rb_polyline_aref  , 1);
        rb_define_method(rb_cPolyline, "each"  , rb_polyline_each  , 0);

        // class
        rb_cPoint = rb_define_class_under (rb_mRubyESRIShape, "Point", rb_cObject);
        rb_define_alloc_func(rb_cPoint, rb_point_allocate);
        rb_define_method(rb_cPoint, "x", rb_point_x, 0);
        rb_define_method(rb_cPoint, "y", rb_point_y, 0);
        rb_define_method(rb_cPoint, "z", rb_point_z, 0);
        rb_define_method(rb_cPoint, "m", rb_point_m, 0);

        // class
        rb_cBoundingBox = rb_define_class_under (rb_mRubyESRIShape, "BoundingBox", rb_cObject);
        rb_define_alloc_func(rb_cBoundingBox, rb_bbox_allocate);
        
        rb_define_method(rb_cBoundingBox, "x_min", rb_bbox_x_min, 0);
        rb_define_method(rb_cBoundingBox, "x_max", rb_bbox_x_max, 0);
        rb_define_method(rb_cBoundingBox, "y_min", rb_bbox_y_min, 0);
        rb_define_method(rb_cBoundingBox, "y_max", rb_bbox_y_max, 0);
        rb_define_method(rb_cBoundingBox, "z_min", rb_bbox_z_min, 0);
        rb_define_method(rb_cBoundingBox, "z_max", rb_bbox_z_max, 0);
}

#else

void Init_RubyESRIShape()
{
}

#endif