示例#1
0
variant_type variant_converter<gl_sarray, void>::set(gl_sarray val) {
  if (USE_GL_DATATYPE) {
    return variant_type(std::dynamic_pointer_cast<model_base>(std::make_shared<gl_sarray>(val)));
  } else {
    return variant_type(std::shared_ptr<unity_sarray_base>(val));
  }
}
示例#2
0
static void _check_types_disc(char *fname, int lmin, int lmax) {
  FILE *f = fopen(fname, "r");
  if (!f) return;
  char *suffix = strrchr(fname, '.');
  char qname[MAX_QNAME_SIZE];
  int lchr, rchr, lstart, lend, rstart, rend;
  char lori, rori;
  int tmp;

  while (-1 < (tmp = fscanf(f, "%s\t%d\t%d\t%d\t%c\t%d\t%d\t%d\t%c\n", qname, &lchr, &lstart, &lend, &lori, &rchr, &rstart, &rend, &rori))) {
    switch (variant_type(lchr, rchr, ori2num(lori), ori2num(rori), lstart, rend, lmin, lmax)) {
    case INS:
      assert(!strcmp(".insertion", suffix));
      break;
    case DEL:
      assert(!strcmp(".deletion", suffix));
      break;
    case TRANS:
      assert(!strcmp(".translocation", suffix));
      break;
    case INV:
      assert(!strcmp(".inversion", suffix));
      break;
      case DIV:
      assert(!strcmp(".divergent", suffix));
      break;
    case NUM_VTYPES:
    case CONC:
      assert(0);
    }
  }
  fclose(f);
}
示例#3
0
variant_type toolkit_class_base::get_value(std::string key, variant_map_type& arg) {
  perform_registration();
  if (key == "list_functions") {
    return to_variant(list_functions());
  } else if (key == "list_get_properties") {
    return to_variant(list_get_properties());
  } else if (key == "list_set_properties") {
    return to_variant(list_set_properties());
  } else if (key == "call_function") {
    // dispatches to a user defined function
    if (!arg.count("__function_name__")) {
      throw("Invalid function call format");
    }
    std::string function_name = variant_get_value<std::string>(arg["__function_name__"]);
    return to_variant(call_function(function_name, arg));
  } else if (key == "set_property") {
    // dispatches to a user defined set property
    if (!arg.count("__property_name__")) {
      throw("Invalid function call format");
    }
    std::string property_name = variant_get_value<std::string>(arg["__property_name__"]);
    return to_variant(set_property(property_name, arg));
  } else if (key == "get_property") {
    // dispatches to a user defined get property
    if (!arg.count("__property_name__")) {
      throw("Invalid function call format");
    }
    std::string property_name = variant_get_value<std::string>(arg["__property_name__"]);
    return to_variant(get_property(property_name, arg));
  } else if (key == "get_docstring") {
    // dispatches to a user defined get property
    if (!arg.count("__symbol__")) {
      throw("Invalid function call format");
    }
    std::string symbol = variant_get_value<std::string>(arg["__symbol__"]);
    return to_variant(get_docstring(symbol));
  } else if (key == "__name__") {
    return name();
  } else if (key == "__uid__") {
    return uid();
  } else {
    return variant_type();
  }
}
示例#4
0
variant_type variant_converter<gl_gframe, void>::set(gl_gframe val) {
  return variant_type(std::shared_ptr<unity_sframe_base>(val));
};
示例#5
0
variant_type variant_converter<gl_sgraph, void>::set(gl_sgraph val) {
  return variant_type(std::shared_ptr<unity_sgraph_base>(val));
};
示例#6
0
variant_type variant_converter<std::shared_ptr<unity_sgraph>, void>::set(std::shared_ptr<unity_sgraph> val) {
  return variant_type(std::static_pointer_cast<unity_sgraph_base>(val));
}
示例#7
0
static void _check_types_conc(char *fname, int lmin, int lmax) {
  FILE *f = fopen(fname, "r");
  int lchr, lstart, rend;
  while (-1 < fscanf(f, "%d\t%d\t%d\n", &lchr, &lstart, &rend)) assert(CONC == variant_type(lchr, lchr, 0, 1, lstart, rend, lmin, lmax));
  fclose(f);
}