1 #include <rblm.h>

     2 #include <rblm-private.h>

     3 

     4 VALUE lm_cMessageNode;

     5 

     6 LmMessageNode *

     7 rb_lm_message_node_from_ruby_object (VALUE obj)

     8 {

     9 	LmMessageNode *node;

    10 

    11 	if (!rb_lm__is_kind_of (obj, lm_cMessageNode)) {

    12 		rb_raise (rb_eTypeError, "not a LmMessageNode");

    13 	}

    14 

    15 	Data_Get_Struct (obj, LmMessageNode, node);

    16 

    17 	return node;

    18 }

    19 

    20 void

    21 msg_node_free (LmMessageNode *node)

    22 {

    23 	lm_message_node_unref (node);

    24 }

    25 

    26 VALUE

    27 rb_lm_message_node_to_ruby_object (LmMessageNode *node)

    28 {

    29 	if (node) {

    30 		lm_message_node_ref (node);

    31 		return Data_Wrap_Struct (lm_cMessageNode, NULL, 

    32 					 msg_node_free, node);

    33 	} else {

    34 		return Qnil;

    35 	}

    36 }

    37 

    38 VALUE

    39 msg_node_allocate (VALUE klass)

    40 {

    41 	return Data_Wrap_Struct (klass, NULL, msg_node_free, NULL);

    42 }

    43 

    44 VALUE

    45 msg_node_get_name (VALUE self)

    46 {

    47 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

    48 

    49 	return rb_str_new2 (node->name);

    50 }

    51 

    52 VALUE

    53 msg_node_get_value (VALUE self)

    54 {

    55 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

    56 

    57 	if (lm_message_node_get_value (node)) {

    58 		return rb_str_new2 (lm_message_node_get_value (node));

    59 	} 

    60 

    61 	return Qnil;

    62 }

    63 

    64 VALUE

    65 msg_node_set_value (VALUE self, VALUE value)

    66 {

    67 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);	

    68 	char          *value_str = NULL;

    69 	

    70 	if (!rb_respond_to (value, rb_intern ("to_s"))) {

    71 		rb_raise (rb_eArgError, "value should respond to to_s");

    72 	} else {

    73 		VALUE str_val = rb_funcall (value, rb_intern ("to_s"), 0);

    74 		value_str = StringValuePtr (str_val);

    75 	}

    76 

    77 	lm_message_node_set_value (node, value_str);

    78 }

    79 

    80 VALUE

    81 msg_node_add_child (int argc, VALUE *argv, VALUE self)

    82 {

    83 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

    84 	LmMessageNode *child;

    85 	VALUE          name, value;

    86 	char          *value_str = NULL;

    87 	

    88 	rb_scan_args (argc, argv, "11", &name, &value);

    89 

    90 	if (!NIL_P (value)) {

    91 		if (!rb_respond_to (value, rb_intern ("to_s"))) {

    92 			rb_raise (rb_eArgError, "value should respond to to_s");

    93 		} else {

    94 			VALUE str_val = rb_funcall (value, rb_intern ("to_s"), 0);

    95 			value_str = StringValuePtr (str_val);

    96 		}

    97 	}

    98 

    99 	child = lm_message_node_add_child (node, StringValuePtr (name),

   100 					   value_str);

   101 

   102 	return LMMESSAGENODE2RVAL (child);

   103 }

   104 

   105 VALUE

   106 msg_node_get_attribute (VALUE self, VALUE attr)

   107 {

   108 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   109 

   110 	if (lm_message_node_get_attribute (node, StringValuePtr (attr))) {

   111 	    return rb_str_new2 (lm_message_node_get_attribute (node, 

   112 							       StringValuePtr (attr)));

   113 	}

   114 

   115 	return Qnil;

   116 }

   117 

   118 VALUE

   119 msg_node_set_attribute (VALUE self, VALUE attr, VALUE value)

   120 {

   121 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   122 	char          *value_str = NULL;

   123 

   124 	if (!NIL_P (value)) {

   125 		value_str = StringValuePtr (value);

   126 	}

   127 	

   128 	lm_message_node_set_attribute (node, StringValuePtr (attr), value_str);

   129 	 

   130 	return Qnil;

   131 }

   132 

   133 VALUE 

   134 msg_node_get_child (VALUE self, VALUE name)

   135 {

   136 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   137 	LmMessageNode *child;

   138 

   139 	child = lm_message_node_get_child (node, StringValuePtr (name));

   140 	

   141 	return LMMESSAGENODE2RVAL (child);

   142 }

   143 

   144 VALUE

   145 msg_node_find_child (VALUE self, VALUE name)

   146 {

   147 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   148 	LmMessageNode *child;

   149 

   150 	child = lm_message_node_find_child (node, StringValuePtr (name));

   151 

   152 	return LMMESSAGENODE2RVAL (child);

   153 }

   154 

   155 VALUE

   156 msg_node_get_is_raw_mode (VALUE self)

   157 {

   158 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   159 

   160 	return GBOOL2RVAL (lm_message_node_get_raw_mode (node));

   161 }

   162 

   163 VALUE

   164 msg_node_set_is_raw_mode (VALUE self, VALUE raw_mode)

   165 {

   166 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   167 

   168 	lm_message_node_set_raw_mode (node, RVAL2GBOOL (raw_mode));

   169 

   170 	return Qnil;

   171 }

   172 

   173 VALUE

   174 msg_node_to_string (VALUE self)

   175 {

   176 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   177 

   178 	return rb_str_new2 (lm_message_node_to_string (node));

   179 }

   180 

   181 VALUE

   182 msg_node_get_next (VALUE self)

   183 {

   184 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   185 

   186 	return LMMESSAGENODE2RVAL (node->next);

   187 }

   188 

   189 VALUE

   190 msg_node_get_prev (VALUE self)

   191 {

   192 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   193 

   194 	return LMMESSAGENODE2RVAL (node->prev);

   195 }

   196 

   197 VALUE

   198 msg_node_get_parent (VALUE self)

   199 {

   200 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   201 

   202 	return LMMESSAGENODE2RVAL (node->parent);

   203 }

   204 

   205 VALUE 

   206 msg_node_get_children (VALUE self)

   207 {

   208 	LmMessageNode *node = rb_lm_message_node_from_ruby_object (self);

   209 

   210 	return LMMESSAGENODE2RVAL (node->children);

   211 }

   212 

   213 extern void 

   214 Init_lm_message_node (VALUE lm_mLM)

   215 {

   216 	lm_cMessageNode = rb_define_class_under (lm_mLM, "MessageNode", 

   217 						 rb_cObject);

   218 

   219 	rb_define_alloc_func (lm_cMessageNode, msg_node_allocate);

   220 

   221 	rb_define_method (lm_cMessageNode, "name", msg_node_get_name, 0);

   222 	rb_define_method (lm_cMessageNode, "value", msg_node_get_value, 0);

   223 	rb_define_method (lm_cMessageNode, "value=", msg_node_set_value, 1);

   224 

   225 	rb_define_method (lm_cMessageNode, "add_child", msg_node_add_child, -1);

   226 	rb_define_method (lm_cMessageNode, "get_attribute", msg_node_get_attribute, 1);

   227 	rb_define_method (lm_cMessageNode, "set_attribute", msg_node_set_attribute, 2);

   228 	rb_define_method (lm_cMessageNode, "get_child", msg_node_get_child, 1);

   229 	rb_define_method (lm_cMessageNode, "find_child", msg_node_find_child, 1);

   230 

   231 	rb_define_method (lm_cMessageNode, "raw_mode", msg_node_get_is_raw_mode, 0);

   232 	rb_define_method (lm_cMessageNode, "raw_mode=", msg_node_set_is_raw_mode, 1);

   233 

   234 	rb_define_method (lm_cMessageNode, "to_s", msg_node_to_string, 0);

   235 

   236 	rb_define_method (lm_cMessageNode, "next", msg_node_get_next, 0);

   237 	rb_define_method (lm_cMessageNode, "prev", msg_node_get_prev, 0);

   238 	rb_define_method (lm_cMessageNode, "parent", msg_node_get_parent, 0);

   239 	rb_define_method (lm_cMessageNode, "children", msg_node_get_children, 0);

   240 }