fx.h

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef FX_H
#define FX_H

#include "fastlib/fx/datanode.h"
#include "fastlib/fx/stopwatch.h"
//#include "datanode.h"
//#include "stopwatch.h"

#include "fastlib/base/common.h"

EXTERN_C_BEGIN

typedef struct datanode fx_module;
typedef struct stopwatch fx_timer;

extern fx_module *fx_root;

extern int fx_docs_nagging;

/*
 * TODO: Consider adding support for printing params, timers, and
 * results to stdout upon accessing/stopping/writing them.
 */

typedef enum {
  FX_UNKNOWN = 0,
  FX_MODULE,
  FX_PARAM,
  FX_REQUIRED,
  FX_RESERVED,
  FX_PROVIDED,
  FX_DEFAULT,
  FX_RESULT,
  FX_TIMER
} fx_mod_t;

extern char fx_mod_marker[];
extern const char *fx_mod_name[];

typedef enum {
  FX_STR = 0,
  FX_DOUBLE,
  FX_INT,
  FX_BOOL,
  FX_STR_LIST,
  FX_DOUBLE_LIST,
  FX_INT_LIST,
  FX_BOOL_LIST,
  FX_CUSTOM = -1
} fx_val_t;

extern const char *fx_val_name[];

struct fx_module_doc;

typedef struct fx_entry_doc {
  const char *key;
  fx_mod_t mod_type;
  fx_val_t val_type;
  const char *meta;
  const char *text;
} fx_entry_doc;

typedef struct fx_submodule_doc {
  const char *key;
  const struct fx_module_doc *doc;
  const char *text;
} fx_submodule_doc;

typedef struct fx_module_doc {
  const struct fx_entry_doc *entries;
  const struct fx_submodule_doc *submodules;
  const char *text;
} fx_module_doc;

#define FX_ENTRY_DOC_DONE {NULL, (fx_mod_t)0, (fx_val_t)0, NULL}

#define FX_SUBMODULE_DOC_DONE {NULL, NULL, NULL}

int fx_module_is_type(fx_module *entry, fx_mod_t type);

const char *fx_param_str_req(fx_module *mod, const char *key);
double fx_param_double_req(fx_module *mod, const char *key);
long long fx_param_int_req(fx_module *mod, const char *key);
int fx_param_bool_req(fx_module *mod, const char *key);

const char **fx_param_str_list_req(fx_module *mod, const char *key,
                                   size_t *size_ptr);
double *fx_param_double_list_req(fx_module *mod, const char *key,
                                 size_t *size_ptr);
long long *fx_param_list_int_req(fx_module *mod, const char *key,
                                 size_t *size_ptr);
int *fx_param_bool_list_req(fx_module *mod, const char *key,
                            size_t *size_ptr);

const char *fx_param_str(fx_module *mod, const char *key, const char *def);
double fx_param_double(fx_module *mod, const char *key, double def);
long long fx_param_int(fx_module *mod, const char *key, long long def);
int fx_param_bool(fx_module *mod, const char *key, int def);

const char **fx_param_str_list(fx_module *mod, const char *key,
                               size_t *size_ptr, size_t def_size, ...);
double *fx_param_double_list(fx_module *mod, const char *key,
                             size_t *size_ptr, size_t def_size, ...);
long long *fx_param_int_list(fx_module *mod, const char *key,
                             size_t *size_ptr, size_t def_size, ...);
int *fx_param_bool_list(fx_module *mod, const char *key,
                        size_t *size_ptr, size_t def_size, ...);

const char **fx_param_str_array(fx_module *mod, const char *key,
                                size_t *size_ptr, size_t def_size,
                                const char *const *def_array);
double *fx_param_double_array(fx_module *mod, const char *key,
                              size_t *size_ptr, size_t def_size,
                              const double *def_array);
long long *fx_param_int_array(fx_module *mod, const char *key,
                              size_t *size_ptr, size_t def_size,
                              const long long *def_array);
int *fx_param_bool_array(fx_module *mod, const char *key,
                         size_t *size_ptr, size_t def_size,
                         const int *def_array);

void fx_set_param_str(fx_module *mod, const char *key, const char *val);
void fx_set_param_double(fx_module *mod, const char *key, double val);
void fx_set_param_int(fx_module *mod, const char *key, long long val);
void fx_set_param_bool(fx_module *mod, const char *key, int val);

void fx_set_param_str_list(fx_module *mod, const char *key,
                           size_t size, ...);
void fx_set_param_double_list(fx_module *mod, const char *key,
                              size_t size, ...);
void fx_set_param_int_list(fx_module *mod, const char *key,
                           size_t size, ...);
void fx_set_param_bool_list(fx_module *mod, const char *key,
                            size_t size, ...);

void fx_set_param_str_array(fx_module *mod, const char *key,
                            size_t size, const char *const *array);
void fx_set_param_double_array(fx_module *mod, const char *key,
                               size_t size, const double *array);
void fx_set_param_int_array(fx_module *mod, const char *key,
                            size_t size, const long long *array);
void fx_set_param_bool_array(fx_module *mod, const char *key,
                             size_t size, const int *array);

COMPILER_PRINTF(3, 4)
void fx_default_param(fx_module *mod, const char *key,
                      const char *def_format, ...);
void fx_default_param_list(fx_module *mod, const char *key,
                           size_t *size_ptr, size_t def_size, ...);
COMPILER_PRINTF(3, 4)
void fx_format_param(fx_module *mod, const char *key,
                     const char *format, ...);
void fx_format_param_list(fx_module *mod, const char *key,
                          size_t size, ...);

void fx_clear_param(fx_module *mod, const char *key);
int fx_param_exists(fx_module *mod, const char *key);

const char *fx_get_result_str(fx_module *mod, const char *key);
double fx_get_result_double(fx_module *mod, const char *key);
long long fx_get_result_int(fx_module *mod, const char *key);
int fx_get_result_bool(fx_module *mod, const char *key);

const char **fx_get_result_str_list(fx_module *mod, const char *key,
                                    size_t *size_ptr);
double *fx_get_result_double_list(fx_module *mod, const char *key,
                                  size_t *size_ptr);
long long *fx_get_result_list_int(fx_module *mod, const char *key,
                                  size_t *size_ptr);
int *fx_get_result_bool_list(fx_module *mod, const char *key,
                             size_t *size_ptr);

void fx_result_str(fx_module *mod, const char *key, const char *val);
void fx_result_double(fx_module *mod, const char *key, double val);
void fx_result_int(fx_module *mod, const char *key, long long val);
void fx_result_bool(fx_module *mod, const char *key, int val);

void fx_result_str_list(fx_module *mod, const char *key,
                        size_t size, ...);
void fx_result_double_list(fx_module *mod, const char *key,
                           size_t size, ...);
void fx_result_int_list(fx_module *mod, const char *key,
                        size_t size, ...);
void fx_result_bool_list(fx_module *mod, const char *key,
                         size_t size, ...);

void fx_result_str_array(fx_module *mod, const char *key,
                         size_t size, const char *const *array);
void fx_result_double_array(fx_module *mod, const char *key,
                            size_t size, const double *array);
void fx_result_int_array(fx_module *mod, const char *key,
                         size_t size, const long long *array);
void fx_result_bool_array(fx_module *mod, const char *key,
                          size_t size, const int *array);

COMPILER_PRINTF(3, 4)
void fx_format_result(fx_module *mod, const char *key,
                      const char *format, ...);
void fx_format_result_list(fx_module *mod, const char *key,
                           size_t size, ...);

void fx_clear_result(fx_module *mod, const char *key);
int fx_result_exists(fx_module *mod, const char *key);

fx_timer *fx_get_timer(fx_module *mod, const char *key);
void fx_timer_start(fx_module *mod, const char *key);
void fx_timer_stop(fx_module *mod, const char *key);
void fx_reset_timer(fx_module *mod, const char *key);

fx_module *fx_submodule(fx_module *mod, const char *key);
COMPILER_PRINTF(3, 4)
fx_module *fx_copy_module(fx_module *mod, const char *src_key,
                          const char *dest_format, ...);

success_t fx_help(const fx_module_doc *doc, const char *key);

fx_module *fx_init(int argc, char **argv, const fx_module_doc *doc);
void fx_done(fx_module *root);

EXTERN_C_END

#endif