| #include <cstring> |
| #include <new> |
| |
| #include "marisa-swig.h" |
| |
| namespace marisa_swig { |
| |
| void Key::str(const char **ptr_out, size_t *length_out) const { |
| *ptr_out = key_.ptr(); |
| *length_out = key_.length(); |
| } |
| |
| size_t Key::id() const { |
| return key_.id(); |
| } |
| |
| float Key::weight() const { |
| return key_.weight(); |
| } |
| |
| void Query::str(const char **ptr_out, size_t *length_out) const { |
| *ptr_out = query_.ptr(); |
| *length_out = query_.length(); |
| } |
| |
| size_t Query::id() const { |
| return query_.id(); |
| } |
| |
| Keyset::Keyset() : keyset_(new (std::nothrow) marisa::Keyset) { |
| MARISA_THROW_IF(keyset_ == NULL, ::MARISA_MEMORY_ERROR); |
| } |
| |
| Keyset::~Keyset() { |
| delete keyset_; |
| } |
| |
| void Keyset::push_back(const marisa::Key &key) { |
| keyset_->push_back(key); |
| } |
| |
| void Keyset::push_back(const char *ptr, size_t length, float weight) { |
| keyset_->push_back(ptr, length, weight); |
| } |
| |
| const Key &Keyset::key(size_t i) const { |
| return reinterpret_cast<const Key &>((*keyset_)[i]); |
| } |
| |
| void Keyset::key_str(size_t i, |
| const char **ptr_out, size_t *length_out) const { |
| *ptr_out = (*keyset_)[i].ptr(); |
| *length_out = (*keyset_)[i].length(); |
| } |
| |
| size_t Keyset::key_id(size_t i) const { |
| return (*keyset_)[i].id(); |
| } |
| |
| size_t Keyset::num_keys() const { |
| return keyset_->num_keys(); |
| } |
| |
| bool Keyset::empty() const { |
| return keyset_->empty(); |
| } |
| |
| size_t Keyset::size() const { |
| return keyset_->size(); |
| } |
| |
| size_t Keyset::total_length() const { |
| return keyset_->total_length(); |
| } |
| |
| void Keyset::reset() { |
| keyset_->reset(); |
| } |
| |
| void Keyset::clear() { |
| keyset_->clear(); |
| } |
| |
| Agent::Agent() |
| : agent_(new (std::nothrow) marisa::Agent), buf_(NULL), buf_size_(0) { |
| MARISA_THROW_IF(agent_ == NULL, ::MARISA_MEMORY_ERROR); |
| } |
| |
| Agent::~Agent() { |
| delete agent_; |
| delete [] buf_; |
| } |
| |
| void Agent::set_query(const char *ptr, size_t length) { |
| if (length > buf_size_) { |
| size_t new_buf_size = (buf_size_ != 0) ? buf_size_ : 1; |
| if (length >= (MARISA_SIZE_MAX / 2)) { |
| new_buf_size = MARISA_SIZE_MAX; |
| } else { |
| while (new_buf_size < length) { |
| new_buf_size *= 2; |
| } |
| } |
| char *new_buf = new (std::nothrow) char[new_buf_size]; |
| MARISA_THROW_IF(new_buf == NULL, MARISA_MEMORY_ERROR); |
| delete [] buf_; |
| buf_ = new_buf; |
| buf_size_ = new_buf_size; |
| } |
| std::memcpy(buf_, ptr, length); |
| agent_->set_query(buf_, length); |
| } |
| |
| void Agent::set_query(size_t id) { |
| agent_->set_query(id); |
| } |
| |
| const Key &Agent::key() const { |
| return reinterpret_cast<const Key &>(agent_->key()); |
| } |
| |
| const Query &Agent::query() const { |
| return reinterpret_cast<const Query &>(agent_->query()); |
| } |
| |
| void Agent::key_str(const char **ptr_out, size_t *length_out) const { |
| *ptr_out = agent_->key().ptr(); |
| *length_out = agent_->key().length(); |
| } |
| |
| size_t Agent::key_id() const { |
| return agent_->key().id(); |
| } |
| |
| void Agent::query_str(const char **ptr_out, size_t *length_out) const { |
| *ptr_out = agent_->query().ptr(); |
| *length_out = agent_->query().length(); |
| } |
| |
| size_t Agent::query_id() const { |
| return agent_->query().id(); |
| } |
| |
| Trie::Trie() : trie_(new (std::nothrow) marisa::Trie) { |
| MARISA_THROW_IF(trie_ == NULL, ::MARISA_MEMORY_ERROR); |
| } |
| |
| Trie::~Trie() { |
| delete trie_; |
| } |
| |
| void Trie::build(Keyset &keyset, int config_flags) { |
| trie_->build(*keyset.keyset_, config_flags); |
| } |
| |
| void Trie::mmap(const char *filename) { |
| trie_->mmap(filename); |
| } |
| |
| void Trie::load(const char *filename) { |
| trie_->load(filename); |
| } |
| |
| void Trie::save(const char *filename) const { |
| trie_->save(filename); |
| } |
| |
| bool Trie::lookup(Agent &agent) const { |
| return trie_->lookup(*agent.agent_); |
| } |
| |
| void Trie::reverse_lookup(Agent &agent) const { |
| trie_->reverse_lookup(*agent.agent_); |
| } |
| |
| bool Trie::common_prefix_search(Agent &agent) const { |
| return trie_->common_prefix_search(*agent.agent_); |
| } |
| |
| bool Trie::predictive_search(Agent &agent) const { |
| return trie_->predictive_search(*agent.agent_); |
| } |
| |
| size_t Trie::lookup(const char *ptr, size_t length) const { |
| marisa::Agent agent; |
| agent.set_query(ptr, length); |
| if (!trie_->lookup(agent)) { |
| return MARISA_INVALID_KEY_ID; |
| } |
| return agent.key().id(); |
| } |
| |
| void Trie::reverse_lookup(size_t id, |
| const char **ptr_out_to_be_deleted, size_t *length_out) const { |
| marisa::Agent agent; |
| agent.set_query(id); |
| trie_->reverse_lookup(agent); |
| char * const buf = new (std::nothrow) char[agent.key().length()]; |
| MARISA_THROW_IF(buf == NULL, MARISA_MEMORY_ERROR); |
| std::memcpy(buf, agent.key().ptr(), agent.key().length()); |
| *ptr_out_to_be_deleted = buf; |
| *length_out = agent.key().length(); |
| } |
| |
| size_t Trie::num_tries() const { |
| return trie_->num_tries(); |
| } |
| |
| size_t Trie::num_keys() const { |
| return trie_->num_keys(); |
| } |
| |
| size_t Trie::num_nodes() const { |
| return trie_->num_nodes(); |
| } |
| |
| TailMode Trie::tail_mode() const { |
| if (trie_->tail_mode() == ::MARISA_TEXT_TAIL) { |
| return TEXT_TAIL; |
| } else { |
| return BINARY_TAIL; |
| } |
| } |
| |
| NodeOrder Trie::node_order() const { |
| if (trie_->node_order() == ::MARISA_LABEL_ORDER) { |
| return LABEL_ORDER; |
| } else { |
| return WEIGHT_ORDER; |
| } |
| } |
| |
| bool Trie::empty() const { |
| return trie_->empty(); |
| } |
| |
| size_t Trie::size() const { |
| return trie_->size(); |
| } |
| |
| size_t Trie::total_size() const { |
| return trie_->total_size(); |
| } |
| |
| size_t Trie::io_size() const { |
| return trie_->io_size(); |
| } |
| |
| void Trie::clear() { |
| trie_->clear(); |
| } |
| |
| } // namespace marisa_swig |