bindbc.mecab.binddynamic

Undocumented in source.

Public Imports

bindbc.mecab.types
public import bindbc.mecab.types;
Undocumented in source.

Members

Enums

MeCabSupport
enum MeCabSupport
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.

Functions

loadMeCab
MeCabSupport loadMeCab()
Undocumented in source. Be warned that the author may not have intended to support it.
unloadMeCab
void unloadMeCab()
Undocumented in source. Be warned that the author may not have intended to support it.

Static variables

mecab_cost_train
int function(int argc, char** argv) mecab_cost_train;
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
mecab_destroy
void function(mecab_t* mecab) mecab_destroy;

C wrapper of MeCab::deleteTagger(tagger)

mecab_dict_gen
int function(int argc, char** argv) mecab_dict_gen;
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
mecab_dict_index
int function(int argc, char** argv) mecab_dict_index;
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
mecab_dictionary_info
const(mecab_dictionary_info_t)* function(mecab_t* mecab) mecab_dictionary_info;

C wrapper of MeCab::Tagger::dictionary_info()

mecab_do
int function(int argc, char** argv) mecab_do;
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
mecab_format_node
const(char)* function(mecab_t* mecab, const(mecab_node_t)* node) mecab_format_node;

C wrapper of MeCab::Tagger::formatNode(const Node *node)

mecab_get_all_morphs
int function(mecab_t* mecab) mecab_get_all_morphs;

C wrapper of MeCab::Tagger::all_morphs()

mecab_get_lattice_level
int function(mecab_t* mecab) mecab_get_lattice_level;

C wrapper of MeCab::Tagger::lattice_level()

mecab_get_partial
int function(mecab_t* mecab) mecab_get_partial;

C wrapper of MeCab::Tagger:set_partial()

mecab_get_theta
float function(mecab_t* mecab) mecab_get_theta;

C wrapper of MeCab::Tagger::theta()

mecab_lattice_add_request_type
void function(mecab_lattice_t* lattice, int request_type) mecab_lattice_add_request_type;

C wrapper of MeCab::Lattice::add_request_type()

mecab_lattice_clear
void function(mecab_lattice_t* lattice) mecab_lattice_clear;

C wrapper of MeCab::Lattice::clear()

mecab_lattice_destroy
void function(mecab_lattice_t* lattice) mecab_lattice_destroy;

C wrapper of MeCab::deleteLattice(lattice)

mecab_lattice_get_all_begin_nodes
mecab_node_t** function(mecab_lattice_t* lattice) mecab_lattice_get_all_begin_nodes;

C wrapper of MeCab::Lattice::begin_nodes()

mecab_lattice_get_all_end_nodes
mecab_node_t** function(mecab_lattice_t* lattice) mecab_lattice_get_all_end_nodes;

C wrapper of MeCab::Lattice::end_nodes()

mecab_lattice_get_begin_nodes
mecab_node_t* function(mecab_lattice_t* lattice, size_t pos) mecab_lattice_get_begin_nodes;

C wrapper of MeCab::Lattice::begin_nodes(pos)

mecab_lattice_get_bos_node
mecab_node_t* function(mecab_lattice_t* lattice) mecab_lattice_get_bos_node;

C wrapper of MeCab::Lattice::bos_node()

mecab_lattice_get_boundary_constraint
int function(mecab_lattice_t* lattice, size_t pos) mecab_lattice_get_boundary_constraint;

C wrapper of MeCab::Lattice::boundary_constraint(pos)

mecab_lattice_get_end_nodes
mecab_node_t* function(mecab_lattice_t* lattice, size_t pos) mecab_lattice_get_end_nodes;

C wrapper of MeCab::Lattice::end_nodes(pos)

mecab_lattice_get_eos_node
mecab_node_t* function(mecab_lattice_t* lattice) mecab_lattice_get_eos_node;

C wrapper of MeCab::Lattice::eos_node()

mecab_lattice_get_feature_constraint
const(char)* function(mecab_lattice_t* lattice, size_t pos) mecab_lattice_get_feature_constraint;

C wrapper of MeCab::Lattice::feature_constraint(pos)

mecab_lattice_get_request_type
int function(mecab_lattice_t* lattice) mecab_lattice_get_request_type;

C wrapper of MeCab::Lattice::request_type()

mecab_lattice_get_sentence
char* function(mecab_lattice_t* lattice) mecab_lattice_get_sentence;

C wrapper of MeCab::Lattice::sentence()

mecab_lattice_get_size
size_t function(mecab_lattice_t* lattice) mecab_lattice_get_size;

C wrapper of MeCab::Lattice::size()

mecab_lattice_get_theta
double function(mecab_lattice_t* lattice) mecab_lattice_get_theta;

C wrapper of MeCab::Lattice::theta()

mecab_lattice_get_z
double function(mecab_lattice_t* lattice) mecab_lattice_get_z;

C wrapper of MeCab::Lattice::Z()

mecab_lattice_has_constraint
int function(mecab_lattice_t* lattice) mecab_lattice_has_constraint;

C wrapper of MeCab::Lattice::has_constraint()

mecab_lattice_has_request_type
int function(mecab_lattice_t* lattice, int request_type) mecab_lattice_has_request_type;

C wrapper of MeCab::Lattice::has_request_type()

mecab_lattice_is_available
int function(mecab_lattice_t* lattice) mecab_lattice_is_available;

C wrapper of MeCab::Lattice::is_available()

mecab_lattice_nbest_tostr
const(char)* function(mecab_lattice_t* lattice, size_t N) mecab_lattice_nbest_tostr;

C wrapper of MeCab::Lattice::enumNBestAsString(N)

mecab_lattice_nbest_tostr2
const(char)* function(mecab_lattice_t* lattice, size_t N, char* buf, size_t size) mecab_lattice_nbest_tostr2;

C wrapper of MeCab::Lattice::enumNBestAsString(N, buf, size)

mecab_lattice_new
mecab_lattice_t* function() mecab_lattice_new;

C wrapper of MeCab::createLattice()

mecab_lattice_new_node
mecab_node_t* function(mecab_lattice_t* lattice) mecab_lattice_new_node;

C wrapper of MeCab::Lattice::newNode();

mecab_lattice_next
int function(mecab_lattice_t* lattice) mecab_lattice_next;

C wrapper of MeCab::Lattice::next()

mecab_lattice_remove_request_type
void function(mecab_lattice_t* lattice, int request_type) mecab_lattice_remove_request_type;

C wrapper of MeCab::Lattice::remove_request_type()

mecab_lattice_set_boundary_constraint
void function(mecab_lattice_t* lattice, size_t pos, int boundary_type) mecab_lattice_set_boundary_constraint;

C wrapper of MeCab::Lattice::boundary_constraint(pos, type)

mecab_lattice_set_feature_constraint
void function(mecab_lattice_t* lattice, size_t begin_pos, size_t end_pos, const(char)* feature) mecab_lattice_set_feature_constraint;

C wrapper of MeCab::Lattice::set_feature_constraint(begin_pos, end_pos, feature)

mecab_lattice_set_request_type
void function(mecab_lattice_t* lattice, int request_type) mecab_lattice_set_request_type;

C wrapper of MeCab::Lattice::set_request_type()

mecab_lattice_set_sentence
void function(mecab_lattice_t* lattice, const(char)* sentence) mecab_lattice_set_sentence;

C wrapper of MeCab::Lattice::set_sentence(sentence)

mecab_lattice_set_sentence2
void function(mecab_lattice_t* lattice, const(char)* sentence, size_t len) mecab_lattice_set_sentence2;

C wrapper of MeCab::Lattice::set_sentence(sentence, len)

mecab_lattice_set_theta
void function(mecab_lattice_t* lattice, double theta) mecab_lattice_set_theta;

C wrapper of MeCab::Lattice::set_theta()

mecab_lattice_set_z
void function(mecab_lattice_t* lattice, double Z) mecab_lattice_set_z;

C wrapper of MeCab::Lattice::set_Z()

mecab_lattice_strerror
const(char)* function(mecab_lattice_t* lattice) mecab_lattice_strerror;

C wrapper of MeCab::Lattice::what()

mecab_lattice_tostr
const(char)* function(mecab_lattice_t* lattice) mecab_lattice_tostr;

C wrapper of MeCab::Lattice::toString()

mecab_lattice_tostr2
const(char)* function(mecab_lattice_t* lattice, char* buf, size_t size) mecab_lattice_tostr2;

C wrapper of MeCab::Lattice::toString(buf, size)

mecab_model_destroy
void function(mecab_model_t* model) mecab_model_destroy;

C wapper of MeCab::deleteModel(model)

mecab_model_dictionary_info
const(mecab_dictionary_info_t)* function(mecab_model_t* model) mecab_model_dictionary_info;

C wapper of MeCab::Model::dictionary_info()

mecab_model_lookup
mecab_node_t* function(mecab_model_t* model, const(char)* begin, const(char)* end, mecab_lattice_t* lattice) mecab_model_lookup;

C wrapper of MeCab::Model::lookup()

mecab_model_new
mecab_model_t* function(int argc, char** argv) mecab_model_new;

C wapper of MeCab::Model::create(argc, argv)

mecab_model_new2
mecab_model_t* function(const(char)* arg) mecab_model_new2;

C wapper of MeCab::Model::create(arg)

mecab_model_new_lattice
mecab_lattice_t* function(mecab_model_t* model) mecab_model_new_lattice;

C wapper of MeCab::Model::createLattice()

mecab_model_new_tagger
mecab_t* function(mecab_model_t* model) mecab_model_new_tagger;

C wapper of MeCab::Model::createTagger()

mecab_model_swap
int function(mecab_model_t* model, mecab_model_t* new_model) mecab_model_swap;

C wrapper of MeCab::Model::swap()

mecab_model_transition_cost
int function(mecab_model_t* model, ushort rcAttr, ushort lcAttr) mecab_model_transition_cost;

C wrapper of MeCab::Model::transition_cost()

mecab_nbest_init
int function(mecab_t* mecab, const(char)* str) mecab_nbest_init;

C wrapper of MeCab::Tagger::parseNBestInit(char *str)

mecab_nbest_init2
int function(mecab_t* mecab, const(char)* str, size_t len) mecab_nbest_init2;

C wrapper of MeCab::Tagger::parseNBestInit(char *str, size_t len)

mecab_nbest_next_tonode
const(mecab_node_t)* function(mecab_t* mecab) mecab_nbest_next_tonode;

C wrapper of MeCab::Tagger::nextNode()

mecab_nbest_next_tostr
const(char)* function(mecab_t* mecab) mecab_nbest_next_tostr;

C wrapper of MeCab::Tagger::next()

mecab_nbest_next_tostr2
char* function(mecab_t* mecab, char* ostr, size_t olen) mecab_nbest_next_tostr2;

C wrapper of MeCab::Tagger::next(char *ostr, size_t olen)

mecab_nbest_sparse_tostr
const(char)* function(mecab_t* mecab, size_t N, const(char)* str) mecab_nbest_sparse_tostr;

C wrapper of MeCab::Tagger::parseNBest(size_t N, char *str)

mecab_nbest_sparse_tostr2
const(char)* function(mecab_t* mecab, size_t N, const(char)* str, size_t len) mecab_nbest_sparse_tostr2;

C wrapper of MeCab::Tagger::parseNBest(size_t N, char *str, size_t len)

mecab_nbest_sparse_tostr3
char* function(mecab_t* mecab, size_t N, const(char)* str, size_t len, char* ostr, size_t olen) mecab_nbest_sparse_tostr3;

C wrapper of MeCab::Tagger::parseNBest(size_t N, char *str, char *ostr, size_t olen)

mecab_new
mecab_t* function(int argc, char** argv) mecab_new;

C wrapper of MeCab::Tagger::create(argc, argv)

mecab_new2
mecab_t* function(const(char)* arg) mecab_new2;

C wrapper of MeCab::Tagger::create(arg)

mecab_parse_lattice
int function(mecab_t* mecab, mecab_lattice_t* lattice) mecab_parse_lattice;

C wrapper of MeCab::Tagger::parse(MeCab::Lattice *lattice)

mecab_set_all_morphs
void function(mecab_t* mecab, int all_morphs) mecab_set_all_morphs;

C wrapper of MeCab::Tagger::set_all_moprhs()

mecab_set_lattice_level
void function(mecab_t* mecab, int level) mecab_set_lattice_level;

C wrapper of MeCab::Tagger::set_lattice_level()

mecab_set_partial
void function(mecab_t* mecab, int partial) mecab_set_partial;

C wrapper of MeCab::Tagger::partial()

mecab_set_theta
void function(mecab_t* mecab, float theta) mecab_set_theta;

C wrapper of MeCab::Tagger::set_theta()

mecab_sparse_tonode
const(mecab_node_t)* function(mecab_t* mecab, const(char)*) mecab_sparse_tonode;

C wrapper of MeCab::Tagger::parseToNode(char *str)

mecab_sparse_tonode2
const(mecab_node_t)* function(mecab_t* mecab, const(char)*, size_t) mecab_sparse_tonode2;

C wrapper of MeCab::Tagger::parseToNode(char *str, size_t len)

mecab_sparse_tostr
const(char)* function(mecab_t* mecab, char* str) mecab_sparse_tostr;

C wrapper of MeCab::Tagger::parse(char *str)

mecab_sparse_tostr2
const(char)* function(mecab_t* mecab, char* str, size_t len) mecab_sparse_tostr2;

C wrapper of MeCab::Tagger::parse(char *str, size_t len)

mecab_sparse_tostr3
char* function(mecab_t* mecab, const(char)* str, size_t len, char* ostr, size_t olen) mecab_sparse_tostr3;

C wrapper of MeCab::Tagger::parse(char *str, char *ostr, size_t olen)

mecab_strerror
const(char)* function(mecab_t* mecab) mecab_strerror;

C wrapper of MeCab::getLastError()

mecab_system_eval
int function(int argc, char** argv) mecab_system_eval;
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
mecab_test_gen
int function(int argc, char** argv) mecab_test_gen;
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
mecab_version
const(char)* function() mecab_version;

C wrapper of MeCab::Tagger::version()

Meta