rb-wartslib 0.9.10

data/ext/scfile.h

@@ -0,0 +1,29 @@
+/*
+** Ruby bindings to scamper file operations in scamper_file.c.
+**
+** --------------------------------------------------------------------------
+** Copyright (C) 2007 The Regents of the University of California.
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+** 
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+** 
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+**
+** $Id: scfile.h,v 1.2 2007/11/29 01:32:24 youngh Exp $
+**/
+
+#ifndef __SCFILE_H
+#define __SCFILE_H
+
+void Init_scfile(void);
+
+#endif  # __SCFILE_H

data/ext/sclist.c

@@ -0,0 +1,632 @@
+/*
+** Ruby bindings to scamper_list_t and scamper_cycle_t.
+**
+** --------------------------------------------------------------------------
+** Copyright (C) 2007 The Regents of the University of California.
+**
+** This program is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2 of the License, or
+** (at your option) any later version.
+** 
+** This program is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+** GNU General Public License for more details.
+** 
+** You should have received a copy of the GNU General Public License
+** along with this program; if not, write to the Free Software
+** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+**
+** $Id: sclist.c,v 1.10 2007/11/29 01:42:07 youngh Exp $
+**/
+
+#include <stdlib.h>
+#include <string.h>
+#include "ruby.h"
+
+#if defined(__HAVE_STDINT_H__)
+#include <stdint.h>
+#endif
+
+#include "scamper_file.h"
+
+#include "sclist.h"
+
+extern VALUE mWarts;
+
+static VALUE cList;
+VALUE cCycle; /* Don't make this static, since it's referenced from scfile.c.*/
+
+static ID iv_element_type, iv_list;
+static ID meth_write_cycle_start, meth_write_cycle_stop;
+static VALUE sym_type, sym_id, sym_start_time, sym_stop_time, sym_hostname;
+static VALUE sym_list, sym_name, sym_descr, sym_monitor;
+
+/*-------------------------------------------------------------------------*/
+
+#define EXTRACT_STR_OPTION(object, opt)	     \
+  option = rb_hash_aref(options, sym_##opt); \
+  if (NIL_P(option)) { \
+    opt = object->opt; \
+  } \
+  else { \
+    StringValue(option); \
+    opt = RSTRING(option)->ptr; \
+  }
+
+
+/*-------------------------------------------------------------------------*/
+
+#define LIST_DEF_ATTR(name) \
+  rb_define_method(cList, #name, sclist_attr_##name, 0);
+
+#define LIST_NUM_ATTR_FIELD_FUN(name,field)		  \
+  static VALUE sclist_attr_##name(VALUE self) \
+  { \
+    scamper_list_t *list; \
+    Data_Get_Struct(self, scamper_list_t, list); \
+    return UINT2NUM(list->field); \
+  }
+
+#define LIST_NUM_ATTR_FUN(name) LIST_NUM_ATTR_FIELD_FUN(name,name)
+
+
+#define LIST_STR_ATTR_FIELD_FUN(name,field)		  \
+  static VALUE sclist_attr_##name(VALUE self) \
+  { \
+    scamper_list_t *list; \
+    char *ptr; \
+    Data_Get_Struct(self, scamper_list_t, list); \
+    ptr = list->field; \
+    ptr = (ptr ? ptr : ""); \
+    return rb_str_new2(ptr); \
+  }
+
+#define LIST_STR_ATTR_FUN(name) LIST_STR_ATTR_FIELD_FUN(name,name)
+
+
+LIST_NUM_ATTR_FUN(id);
+LIST_STR_ATTR_FUN(name);
+LIST_STR_ATTR_FUN(descr);
+LIST_STR_ATTR_FUN(monitor);
+
+
+/***************************************************************************/
+
+static void sclist_free(void *data)
+{
+  if (data) {
+    scamper_list_free((scamper_list_t *)data);
+  }
+}
+
+static VALUE sclist_alloc(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, 0, sclist_free, 0);
+}
+
+
+static VALUE sclist_init(VALUE self)
+{
+  rb_ivar_set(self, iv_element_type, INT2FIX(SCAMPER_FILE_OBJ_LIST));
+  return self;
+}
+
+
+static VALUE sclist_cmp(VALUE self, VALUE other)
+{
+  scamper_list_t *self_list;
+  scamper_list_t *other_list;
+
+  if (other == self) {
+    return INT2FIX(0);
+  }
+
+  /* See Pragmatic Programmer's book. */
+  if (TYPE(other) != T_DATA || RDATA(other)->dfree != sclist_free) {
+    rb_raise(rb_eTypeError, "wrong argument type");
+  }
+
+  Data_Get_Struct(self, scamper_list_t, self_list);
+  Data_Get_Struct(other, scamper_list_t, other_list);
+
+  return INT2FIX(self_list->id < other_list->id ? -1
+		 : (self_list->id > other_list->id ? 1 : 0));
+}
+
+
+static VALUE sclist_write_to(VALUE self, VALUE file)
+{
+  return self;  /* nothing to do: users shouldn't write lists themselves */
+}
+
+
+static VALUE sclist_derive(int argc, VALUE *argv, VALUE self)
+{
+  scamper_list_t *self_list;
+  scamper_list_t *list;
+  VALUE options, option;
+  unsigned int id;
+  char* name;
+  char* descr;
+  char* monitor;
+  VALUE retval;
+
+  if (rb_scan_args(argc, argv, "01", &options) == 0) {
+    options = rb_hash_new();
+  }
+
+  Data_Get_Struct(self, scamper_list_t, self_list);
+
+  if (TYPE(options) != T_HASH) {
+    rb_raise(rb_eTypeError, "wrong argument type -- expected hash");
+  }
+
+  option = rb_hash_aref(options, sym_id);
+  id = (NIL_P(option) ? self_list->id : NUM2UINT(option));
+
+  EXTRACT_STR_OPTION(self_list, name);
+  EXTRACT_STR_OPTION(self_list, descr);
+  EXTRACT_STR_OPTION(self_list, monitor);
+
+  list = scamper_list_alloc(id, name, descr, monitor);
+  if (!list) {
+    return Qnil;
+  }
+
+  retval = Data_Wrap_Struct(cList, 0, sclist_free, list);
+  if (NIL_P(sclist_init(retval))) {
+    scamper_list_free(list);
+    return Qnil;
+  }
+
+  return retval;
+}
+
+
+static VALUE sclist_s_create(VALUE klass, VALUE options)
+{
+  scamper_list_t *list;
+  VALUE option;
+  unsigned int id;
+  char* name;
+  char* descr;
+  char* monitor;
+  VALUE retval;
+
+  if (TYPE(options) != T_HASH) {
+    rb_raise(rb_eTypeError, "wrong argument type -- expected hash");
+  }
+
+  option = rb_hash_aref(options, sym_id);
+  id = (NIL_P(option) ? 0 : NUM2UINT(option));
+
+  EXTRACT_STR_OPTION(list, name);
+  EXTRACT_STR_OPTION(list, descr);
+  EXTRACT_STR_OPTION(list, monitor);
+
+  list = scamper_list_alloc(id, name, descr, monitor);
+  if (!list) {
+    return Qnil;
+  }
+
+  retval = Data_Wrap_Struct(cList, 0, sclist_free, list);
+  if (NIL_P(sclist_init(retval))) {
+    scamper_list_free(list);
+    return Qnil;
+  }
+
+  return retval;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+VALUE sclist_create(scamper_list_t *list)
+{
+  VALUE obj = Data_Wrap_Struct(cList, 0, sclist_free, list);
+
+  if (NIL_P(sclist_init(obj))) {
+   return Qnil;
+  }
+
+  return obj;
+}
+
+
+/***************************************************************************/
+/***************************************************************************/
+
+void Init_sclist(void)
+{
+  ID private_class_method_ID, private_ID;
+  ID new_ID, dup_ID, clone_ID;
+
+  iv_element_type = rb_intern("@element_type");
+
+  sym_id = ID2SYM(rb_intern("id"));
+  sym_name = ID2SYM(rb_intern("name"));
+  sym_descr = ID2SYM(rb_intern("descr"));
+  sym_monitor = ID2SYM(rb_intern("monitor"));
+
+  cList = rb_define_class_under(mWarts, "List", rb_cObject);
+
+  rb_include_module(cList, rb_mComparable);
+
+  rb_define_singleton_method(cList, "create", sclist_s_create, 1);
+
+  rb_define_alloc_func(cList, sclist_alloc);
+
+  LIST_DEF_ATTR(id);
+  LIST_DEF_ATTR(name);
+  LIST_DEF_ATTR(descr);
+  LIST_DEF_ATTR(monitor);
+
+  rb_define_attr(cList, "element_type", 1, 0);
+
+  rb_define_method(cList, "initialize", sclist_init, 0);
+  rb_define_method(cList, "derive", sclist_derive, -1);
+  rb_define_method(cList, "<=>", sclist_cmp, 1);
+  rb_define_method(cList, "write_to", sclist_write_to, 1);
+
+  private_class_method_ID = rb_intern("private_class_method");
+  private_ID = rb_intern("private");
+  new_ID = rb_intern("new");
+  dup_ID = rb_intern("dup");
+  clone_ID = rb_intern("clone");
+
+  rb_funcall(cList, private_class_method_ID, 1, ID2SYM(new_ID));
+  rb_funcall(cList, private_ID, 1, ID2SYM(dup_ID));
+  rb_funcall(cList, private_ID, 1, ID2SYM(clone_ID));
+}
+
+
+/*=========================================================================*/
+/*=========================================================================*/
+
+#define CYCLE_DEF_ATTR(name) \
+  rb_define_method(cCycle, #name, sccycle_attr_##name, 0);
+
+#define CYCLE_NUM_ATTR_FIELD_FUN(name,field)		  \
+  static VALUE sccycle_attr_##name(VALUE self) \
+  { \
+    scamper_cycle_t *cycle; \
+    Data_Get_Struct(self, scamper_cycle_t, cycle); \
+    return UINT2NUM(cycle->field); \
+  }
+
+#define CYCLE_NUM_ATTR_FUN(name) CYCLE_NUM_ATTR_FIELD_FUN(name,name)
+
+
+#define CYCLE_STR_ATTR_FIELD_FUN(name,field)		  \
+  static VALUE sccycle_attr_##name(VALUE self) \
+  { \
+    scamper_cycle_t *cycle; \
+    char *ptr; \
+    Data_Get_Struct(self, scamper_cycle_t, cycle); \
+    ptr = cycle->field; \
+    ptr = (ptr ? ptr : ""); \
+    return rb_str_new2(ptr); \
+  }
+
+#define CYCLE_STR_ATTR_FUN(name) CYCLE_STR_ATTR_FIELD_FUN(name,name)
+
+
+CYCLE_NUM_ATTR_FUN(id);
+CYCLE_NUM_ATTR_FUN(start_time);
+CYCLE_NUM_ATTR_FUN(stop_time);
+CYCLE_STR_ATTR_FUN(hostname);
+
+
+/*-------------------------------------------------------------------------*/
+
+#define CYCLE_DEF_QUERY(name) \
+  rb_define_method(cCycle, #name "?", sccycle_query_##name, 0);
+
+#define CYCLE_QUERY_FUN(name,macro)		  \
+  static VALUE sccycle_query_##name(VALUE self) \
+  { \
+    VALUE type = rb_ivar_get(self, iv_element_type); \
+    return (type == INT2FIX(SCAMPER_FILE_OBJ_CYCLE_##macro) ? Qtrue: Qfalse); \
+  }
+
+CYCLE_QUERY_FUN(start, START);
+CYCLE_QUERY_FUN(def, DEF);
+CYCLE_QUERY_FUN(stop, STOP);
+
+
+/***************************************************************************/
+
+/*
+** NOTE: Don't make this function static, since we use it for type checking
+**       in sctrace.c.  It's a bit ugly to expose this, but thus is life...
+*/
+void sccycle_free(void *data)
+{
+  if (data) {
+    scamper_cycle_free((scamper_cycle_t *)data);
+  }
+}
+
+static VALUE sccycle_alloc(VALUE klass)
+{
+  return Data_Wrap_Struct(klass, 0, sccycle_free, 0);
+}
+
+
+/* {type} should be one of SCAMPER_FILE_OBJ_CYCLE_{START,DEF,STOP}. */
+static VALUE sccycle_init(VALUE self, VALUE type)
+{
+  rb_ivar_set(self, iv_element_type, type);
+  return self;
+}
+
+
+static VALUE sccycle_cmp(VALUE self, VALUE other)
+{
+  scamper_cycle_t *self_cycle;
+  scamper_cycle_t *other_cycle;
+
+  if (other == self) {
+    return INT2FIX(0);
+  }
+
+  /* See Pragmatic Programmer's book. */
+  if (TYPE(other) != T_DATA || RDATA(other)->dfree != sccycle_free) {
+    rb_raise(rb_eTypeError, "wrong argument type");
+  }
+
+  Data_Get_Struct(self, scamper_cycle_t, self_cycle);
+  Data_Get_Struct(other, scamper_cycle_t, other_cycle);
+
+  return INT2FIX(self_cycle->id < other_cycle->id ? -1
+		 : (self_cycle->id > other_cycle->id ? 1 : 0));
+}
+
+
+static VALUE sccycle_write_to(VALUE self, VALUE file)
+{
+  scamper_cycle_t *cycle;
+  int type;
+
+  Data_Get_Struct(self, scamper_cycle_t, cycle);
+
+  type = FIX2INT(rb_ivar_get(self, iv_element_type));
+  if (type == SCAMPER_FILE_OBJ_CYCLE_START) {
+    rb_funcall(file, meth_write_cycle_start, 1, self);
+  }
+  else if (type == SCAMPER_FILE_OBJ_CYCLE_STOP) {
+    rb_funcall(file, meth_write_cycle_stop, 1, self);
+  }
+  /* else type == SCAMPER_FILE_OBJ_CYCLE_DEF; ignore */
+
+  return self;
+}
+
+
+static VALUE sccycle_list(VALUE self)
+{
+  scamper_cycle_t *cycle;
+  VALUE retval;
+
+  retval = rb_ivar_get(self, iv_list);
+  if (NIL_P(retval)) {
+    Data_Get_Struct(self, scamper_cycle_t, cycle);
+
+    retval = sclist_create(scamper_list_use(cycle->list));
+    rb_ivar_set(self, iv_list, retval);
+  }
+  return retval;
+}
+
+
+static VALUE sccycle_derive(int argc, VALUE *argv, VALUE self)
+{
+  scamper_cycle_t *self_cycle;
+  scamper_list_t *list;
+  scamper_cycle_t *cycle;
+  VALUE options, option;
+  int type;
+  unsigned int id;
+  unsigned int start_time, stop_time;
+  char* hostname;
+  VALUE retval;
+
+  if (rb_scan_args(argc, argv, "01", &options) == 0) {
+    options = rb_hash_new();
+  }
+
+  Data_Get_Struct(self, scamper_cycle_t, self_cycle);
+
+  if (TYPE(options) != T_HASH) {
+    rb_raise(rb_eTypeError, "wrong argument type -- expected hash");
+  }
+
+  option = rb_hash_aref(options, sym_list);
+  if (NIL_P(option)) {
+    list = self_cycle->list;
+  }
+  else {
+    /* See Pragmatic Programmer's book. */
+    if (TYPE(option) != T_DATA || RDATA(option)->dfree != sclist_free) {
+      rb_raise(rb_eTypeError, "wrong list argument type");
+    }
+
+    Data_Get_Struct(option, scamper_list_t, list);
+  }
+
+  option = rb_hash_aref(options, sym_type);
+  if (NIL_P(option)) {
+    type = FIX2INT(rb_ivar_get(self, iv_element_type));
+  }
+  else {
+    type = NUM2INT(option);
+    if (type < SCAMPER_FILE_OBJ_CYCLE_START
+	|| type > SCAMPER_FILE_OBJ_CYCLE_STOP) {
+      rb_raise(rb_eArgError, "invalid cycle type");
+    }
+  }
+
+  option = rb_hash_aref(options, sym_id);
+  id = (NIL_P(option) ? self_cycle->id : NUM2UINT(option));
+
+  option = rb_hash_aref(options, sym_start_time);
+  start_time = (NIL_P(option) ? self_cycle->start_time : NUM2UINT(option));
+
+  option = rb_hash_aref(options, sym_stop_time);
+  stop_time = (NIL_P(option) ? self_cycle->stop_time : NUM2UINT(option));
+
+  EXTRACT_STR_OPTION(self_cycle, hostname);
+
+  cycle = scamper_cycle_alloc(list);
+  if (!cycle) {
+    return Qnil;
+  }
+
+  cycle->id = id;
+  cycle->start_time = start_time;
+  cycle->stop_time = stop_time;
+  cycle->hostname = strdup(hostname);
+
+  retval = Data_Wrap_Struct(cCycle, 0, sccycle_free, cycle);
+  if (NIL_P(sccycle_init(retval, INT2FIX(type)))) {
+    scamper_cycle_free(cycle);
+    return Qnil;
+  }
+
+  return retval;
+}
+
+
+static VALUE sccycle_s_create(VALUE klass, VALUE list_value, VALUE options)
+{
+  scamper_list_t *list;
+  scamper_cycle_t *cycle;
+  VALUE option;
+  int type;
+  unsigned int id;
+  unsigned int start_time, stop_time;
+  char* hostname;
+  VALUE retval;
+
+  /* See Pragmatic Programmer's book. */
+  if (TYPE(list_value) != T_DATA || RDATA(list_value)->dfree != sclist_free) {
+    rb_raise(rb_eTypeError, "wrong list argument type");
+  }
+
+  Data_Get_Struct(list_value, scamper_list_t, list);
+
+  if (TYPE(options) != T_HASH) {
+    rb_raise(rb_eTypeError, "wrong options argument type -- expected hash");
+  }
+
+  option = rb_hash_aref(options, sym_type);
+  type = (NIL_P(option) ? SCAMPER_FILE_OBJ_CYCLE_START : NUM2INT(option));
+  if (type < SCAMPER_FILE_OBJ_CYCLE_START
+      || type > SCAMPER_FILE_OBJ_CYCLE_STOP) {
+    rb_raise(rb_eArgError, "invalid cycle type");
+  }
+
+  option = rb_hash_aref(options, sym_id);
+  id = (NIL_P(option) ? 0 : NUM2UINT(option));
+
+  option = rb_hash_aref(options, sym_start_time);
+  start_time = (NIL_P(option) ? 0 : NUM2UINT(option));
+
+  option = rb_hash_aref(options, sym_stop_time);
+  stop_time = (NIL_P(option) ? 0 : NUM2UINT(option));
+
+  EXTRACT_STR_OPTION(cycle, hostname);
+
+  cycle = scamper_cycle_alloc(list);
+  if (!cycle) {
+    return Qnil;
+  }
+
+  cycle->id = id;
+  cycle->start_time = start_time;
+  cycle->stop_time = stop_time;
+  cycle->hostname = strdup(hostname);
+
+  retval = Data_Wrap_Struct(cCycle, 0, sccycle_free, cycle);
+  if (NIL_P(sccycle_init(retval, INT2FIX(type)))) {
+    scamper_cycle_free(cycle);
+    return Qnil;
+  }
+
+  return retval;
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+/* {type} should be one of SCAMPER_FILE_OBJ_CYCLE_{START,DEF,STOP}. */
+VALUE sccycle_create(scamper_cycle_t *cycle, int type)
+{
+  VALUE obj = Data_Wrap_Struct(cCycle, 0, sccycle_free, cycle);
+
+  if (NIL_P(sccycle_init(obj, INT2FIX(type)))) {
+   return Qnil;
+  }
+
+  return obj;
+}
+
+
+/***************************************************************************/
+/***************************************************************************/
+
+void Init_sccycle(void)
+{
+  ID private_class_method_ID, private_ID;
+  ID new_ID, dup_ID, clone_ID;
+
+  iv_element_type = rb_intern("@element_type");
+  iv_list = rb_intern("@list");
+
+  meth_write_cycle_start = rb_intern("write_cycle_start");
+  meth_write_cycle_stop = rb_intern("write_cycle_stop");
+
+  sym_type = ID2SYM(rb_intern("type"));
+  sym_id = ID2SYM(rb_intern("id"));
+  sym_start_time = ID2SYM(rb_intern("start_time"));
+  sym_stop_time = ID2SYM(rb_intern("stop_time"));
+  sym_hostname = ID2SYM(rb_intern("hostname"));
+  sym_list = ID2SYM(rb_intern("list"));
+
+  cCycle = rb_define_class_under(mWarts, "Cycle", rb_cObject);
+
+  rb_include_module(cCycle, rb_mComparable);
+
+  rb_define_singleton_method(cCycle, "create", sccycle_s_create, 2);
+
+  rb_define_alloc_func(cCycle, sccycle_alloc);
+
+  CYCLE_DEF_ATTR(id);
+  CYCLE_DEF_ATTR(start_time);
+  CYCLE_DEF_ATTR(stop_time);
+  CYCLE_DEF_ATTR(hostname);
+
+  CYCLE_DEF_QUERY(start);
+  CYCLE_DEF_QUERY(def);
+  CYCLE_DEF_QUERY(stop);
+
+  rb_define_attr(cCycle, "element_type", 1, 0);
+
+  rb_define_method(cCycle, "initialize", sccycle_init, 1);
+  rb_define_method(cCycle, "list", sccycle_list, 0);
+  rb_define_method(cCycle, "derive", sccycle_derive, -1);
+  rb_define_method(cCycle, "<=>", sccycle_cmp, 1);
+  rb_define_method(cCycle, "write_to", sccycle_write_to, 1);
+
+  private_class_method_ID = rb_intern("private_class_method");
+  private_ID = rb_intern("private");
+  new_ID = rb_intern("new");
+  dup_ID = rb_intern("dup");
+  clone_ID = rb_intern("clone");
+
+  rb_funcall(cCycle, private_class_method_ID, 1, ID2SYM(new_ID));
+  rb_funcall(cCycle, private_ID, 1, ID2SYM(dup_ID));
+  rb_funcall(cCycle, private_ID, 1, ID2SYM(clone_ID));
+}