1 #include "rblm.h"

     2 

     3 VALUE lm_cProxy;

     4 

     5 LmProxy *

     6 rb_lm_proxy_from_ruby_object (VALUE obj)

     7 {

     8 	LmProxy *proxy;

     9 

    10 	if (!rb_lm__is_kind_of (obj, lm_cProxy)) {

    11 		rb_raise (rb_eTypeError, "not a LmProxy");

    12 	}

    13 

    14 	Data_Get_Struct (obj, LmProxy, proxy);

    15 

    16 	return proxy;

    17 }

    18 

    19 void

    20 proxy_free (LmProxy *proxy)

    21 {

    22 	lm_proxy_unref (proxy);

    23 }

    24 

    25 VALUE

    26 rb_lm_proxy_to_ruby_object (LmProxy *proxy)

    27 {

    28 	if (proxy) {

    29 		lm_proxy_ref (proxy);

    30 		return Data_Wrap_Struct (lm_cProxy, NULL, 

    31 					 proxy_free, proxy);

    32 	} else {

    33 		return Qnil;

    34 	}

    35 }

    36 VALUE

    37 proxy_allocate (VALUE klass)

    38 {

    39 	return Data_Wrap_Struct (klass, NULL, proxy_free, NULL);

    40 }

    41 

    42 VALUE

    43 proxy_initialize (int argc, VALUE *argv, VALUE self)

    44 {

    45 	LmProxy *proxy;

    46 	VALUE    type, server, port;

    47 	char    *server_str = NULL;

    48 

    49 	rb_scan_args (argc, argv, "12", &type, &server, &port);

    50 

    51 	proxy = lm_proxy_new (FIX2INT (type));

    52 

    53 	if (!NIL_P (server)) {

    54 		if (!rb_respond_to (server, rb_intern ("to_s"))) {

    55 			rb_raise (rb_eArgError, "server should respond to to_s");

    56 		} else {

    57 			VALUE str_val = rb_funcall (server, rb_intern ("to_s"), 0);

    58 			lm_proxy_set_server (proxy, StringValuePtr (str_val));

    59 		}

    60 	}

    61 

    62 	if (!NIL_P (port)) {

    63 		lm_proxy_set_port (proxy, NUM2UINT (port));

    64 	}

    65 

    66 	DATA_PTR (self) = proxy;

    67 

    68 	return self;

    69 }

    70 

    71 VALUE

    72 proxy_get_type (VALUE self)

    73 {

    74 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

    75 

    76 	return INT2FIX (lm_proxy_get_type (proxy));

    77 }

    78 

    79 VALUE

    80 proxy_set_type (VALUE self, VALUE type)

    81 {

    82 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

    83 

    84 	lm_proxy_set_type (proxy, FIX2INT (type));

    85 

    86 	return Qnil;

    87 }

    88 

    89 VALUE

    90 proxy_get_server (VALUE self)

    91 {

    92 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

    93 

    94 	if (lm_proxy_get_server (proxy)) {

    95 		return rb_str_new2 (lm_proxy_get_server (proxy));

    96 	}

    97 

    98 	return Qnil;

    99 }

   100 

   101 VALUE

   102 proxy_set_server (VALUE self, VALUE server)

   103 {

   104 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

   105 	VALUE    str_val;

   106 

   107 	if (!rb_respond_to (server, rb_intern ("to_s"))) {

   108 		rb_raise (rb_eArgError, "server should respond to to_s");

   109 	} 

   110 

   111 	str_val = rb_funcall (server, rb_intern ("to_s"), 0);

   112 	lm_proxy_set_server (proxy, StringValuePtr (str_val));

   113 

   114 	return Qnil;

   115 }

   116 

   117 VALUE 

   118 proxy_get_port (VALUE self)

   119 {

   120 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

   121 

   122 	return UINT2NUM (lm_proxy_get_port (proxy));

   123 }

   124 

   125 VALUE

   126 proxy_set_port (VALUE self, VALUE port)

   127 {

   128 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

   129 

   130 	lm_proxy_set_port (proxy, NUM2UINT (port));

   131 

   132 	return Qnil;

   133 }

   134 

   135 VALUE

   136 proxy_get_username (VALUE self)

   137 {

   138 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

   139 

   140 	if (lm_proxy_get_username (proxy)) {

   141 		return rb_str_new2 (lm_proxy_get_username (proxy));

   142 	}

   143 

   144 	return Qnil;

   145 }

   146 

   147 VALUE

   148 proxy_set_username (VALUE self, VALUE username)

   149 {

   150 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

   151 	VALUE    str_val;

   152 

   153 	if (!rb_respond_to (username, rb_intern ("to_s"))) {

   154 		rb_raise (rb_eArgError, "username should respond to to_s");

   155 	} 

   156 

   157 	str_val = rb_funcall (username, rb_intern ("to_s"), 0);

   158 	lm_proxy_set_username (proxy, StringValuePtr (str_val));

   159 

   160 	return Qnil;

   161 }

   162 

   163 VALUE

   164 proxy_get_password (VALUE self)

   165 {

   166 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

   167 

   168 	if (lm_proxy_get_password (proxy)) {

   169 		return rb_str_new2 (lm_proxy_get_password (proxy));

   170 	}

   171 

   172 	return Qnil;

   173 }

   174 

   175 VALUE

   176 proxy_set_password (VALUE self, VALUE password)

   177 {

   178 	LmProxy *proxy = rb_lm_proxy_from_ruby_object (self);

   179 	VALUE    str_val;

   180 

   181 	if (!rb_respond_to (password, rb_intern ("to_s"))) {

   182 		rb_raise (rb_eArgError, "password should respond to to_s");

   183 	} 

   184 

   185 	str_val = rb_funcall (password, rb_intern ("to_s"), 0);

   186 	lm_proxy_set_password (proxy, StringValuePtr (str_val));

   187 

   188 	return Qnil;

   189 }

   190 

   191 extern void

   192 Init_lm_proxy (VALUE lm_mLM)

   193 {

   194 	lm_cProxy = rb_define_class_under (lm_mLM, "Proxy", rb_cObject);

   195 

   196 	rb_define_alloc_func (lm_cProxy, proxy_allocate);

   197 

   198 	rb_define_method (lm_cProxy, "initialize", proxy_initialize, -1);

   199 	rb_define_method (lm_cProxy, "type", proxy_get_type, 0);

   200 	rb_define_method (lm_cProxy, "type=", proxy_set_type, 1);

   201 	rb_define_method (lm_cProxy, "server", proxy_get_server, 0);

   202 	rb_define_method (lm_cProxy, "server=", proxy_set_server, 1);

   203 	rb_define_method (lm_cProxy, "port", proxy_get_port, 0);

   204 	rb_define_method (lm_cProxy, "port=", proxy_set_port, 1);

   205 	rb_define_method (lm_cProxy, "username", proxy_get_username, 0);

   206 	rb_define_method (lm_cProxy, "username=", proxy_set_username, 1);

   207 	rb_define_method (lm_cProxy, "password", proxy_get_password, 0);

   208 	rb_define_method (lm_cProxy, "password=", proxy_set_password, 1);

   209 }

   210