melisa 0.1.0 → 0.2.0

data/ext/marisa-0.2.4/pkg/include/marisa/exception.h

@@ -0,0 +1,82 @@
+#ifndef MARISA_EXCEPTION_H_
+#define MARISA_EXCEPTION_H_
+
+#include <exception>
+
+#include "base.h"
+
+namespace marisa {
+
+// An exception object keeps a filename, a line number, an error code and an
+// error message. The message format is as follows:
+//  "__FILE__:__LINE__: error_code: error_message"
+class Exception : public std::exception {
+ public:
+  Exception(const char *filename, int line,
+      ErrorCode error_code, const char *error_message)
+      : std::exception(), filename_(filename), line_(line),
+        error_code_(error_code), error_message_(error_message) {}
+  Exception(const Exception &ex)
+      : std::exception(), filename_(ex.filename_), line_(ex.line_),
+        error_code_(ex.error_code_), error_message_(ex.error_message_) {}
+  virtual ~Exception() throw() {}
+
+  Exception &operator=(const Exception &rhs) {
+    filename_ = rhs.filename_;
+    line_ = rhs.line_;
+    error_code_ = rhs.error_code_;
+    error_message_ = rhs.error_message_;
+    return *this;
+  }
+
+  const char *filename() const {
+    return filename_;
+  }
+  int line() const {
+    return line_;
+  }
+  ErrorCode error_code() const {
+    return error_code_;
+  }
+  const char *error_message() const {
+    return error_message_;
+  }
+
+  virtual const char *what() const throw() {
+    return error_message_;
+  }
+
+ private:
+  const char *filename_;
+  int line_;
+  ErrorCode error_code_;
+  const char *error_message_;
+};
+
+// These macros are used to convert a line number to a string constant.
+#define MARISA_INT_TO_STR(value) #value
+#define MARISA_LINE_TO_STR(line) MARISA_INT_TO_STR(line)
+#define MARISA_LINE_STR MARISA_LINE_TO_STR(__LINE__)
+
+// MARISA_THROW throws an exception with a filename, a line number, an error
+// code and an error message. The message format is as follows:
+//  "__FILE__:__LINE__: error_code: error_message"
+#define MARISA_THROW(error_code, error_message) \
+  (throw marisa::Exception(__FILE__, __LINE__, error_code, \
+       __FILE__ ":" MARISA_LINE_STR ": " #error_code ": " error_message))
+
+// MARISA_THROW_IF throws an exception if `condition' is true.
+#define MARISA_THROW_IF(condition, error_code) \
+  (void)((!(condition)) || (MARISA_THROW(error_code, #condition), 0))
+
+// MARISA_DEBUG_IF is ignored if _DEBUG is undefined. So, it is useful for
+// debugging time-critical codes.
+#ifdef _DEBUG
+ #define MARISA_DEBUG_IF(cond, error_code) MARISA_THROW_IF(cond, error_code)
+#else
+ #define MARISA_DEBUG_IF(cond, error_code)
+#endif
+
+}  // namespace marisa
+
+#endif  // MARISA_EXCEPTION_H_

data/ext/marisa-0.2.4/pkg/include/marisa/iostream.h

@@ -0,0 +1,18 @@
+#ifndef MARISA_IOSTREAM_H_
+#define MARISA_IOSTREAM_H_
+
+#include <iosfwd>
+
+namespace marisa {
+
+class Trie;
+
+std::istream &read(std::istream &stream, Trie *trie);
+std::ostream &write(std::ostream &stream, const Trie &trie);
+
+std::istream &operator>>(std::istream &stream, Trie &trie);
+std::ostream &operator<<(std::ostream &stream, const Trie &trie);
+
+}  // namespace marisa
+
+#endif  // MARISA_IOSTREAM_H_

data/ext/marisa-0.2.4/pkg/include/marisa/key.h

@@ -0,0 +1,85 @@
+#ifndef MARISA_KEY_H_
+#define MARISA_KEY_H_
+
+#include "base.h"
+
+namespace marisa {
+
+class Key {
+ public:
+  Key() : ptr_(NULL), length_(0), union_() {
+    union_.id = 0;
+  }
+  Key(const Key &key)
+      : ptr_(key.ptr_), length_(key.length_), union_(key.union_) {}
+
+  Key &operator=(const Key &key) {
+    ptr_ = key.ptr_;
+    length_ = key.length_;
+    union_ = key.union_;
+    return *this;
+  }
+
+  char operator[](std::size_t i) const {
+    MARISA_DEBUG_IF(i >= length_, MARISA_BOUND_ERROR);
+    return ptr_[i];
+  }
+
+  void set_str(const char *str) {
+    MARISA_DEBUG_IF(str == NULL, MARISA_NULL_ERROR);
+    std::size_t length = 0;
+    while (str[length] != '\0') {
+      ++length;
+    }
+    MARISA_DEBUG_IF(length > MARISA_UINT32_MAX, MARISA_SIZE_ERROR);
+    ptr_ = str;
+    length_ = (UInt32)length;
+  }
+  void set_str(const char *ptr, std::size_t length) {
+    MARISA_DEBUG_IF((ptr == NULL) && (length != 0), MARISA_NULL_ERROR);
+    MARISA_DEBUG_IF(length > MARISA_UINT32_MAX, MARISA_SIZE_ERROR);
+    ptr_ = ptr;
+    length_ = (UInt32)length;
+  }
+  void set_id(std::size_t id) {
+    MARISA_DEBUG_IF(id > MARISA_UINT32_MAX, MARISA_SIZE_ERROR);
+    union_.id = (UInt32)id;
+  }
+  void set_weight(float weight) {
+    union_.weight = weight;
+  }
+
+  const char *ptr() const {
+    return ptr_;
+  }
+  std::size_t length() const {
+    return length_;
+  }
+  std::size_t id() const {
+    return union_.id;
+  }
+  float weight() const {
+    return union_.weight;
+  }
+
+  void clear() {
+    Key().swap(*this);
+  }
+  void swap(Key &rhs) {
+    marisa::swap(ptr_, rhs.ptr_);
+    marisa::swap(length_, rhs.length_);
+    marisa::swap(union_.id, rhs.union_.id);
+  }
+
+ private:
+  const char *ptr_;
+  UInt32 length_;
+  union Union {
+    UInt32 id;
+    float weight;
+  } union_;
+};
+
+}  // namespace marisa
+
+#endif  // MARISA_KEY_H_

data/ext/marisa-0.2.4/pkg/include/marisa/keyset.h

@@ -0,0 +1,80 @@
+#ifndef MARISA_KEYSET_H_
+#define MARISA_KEYSET_H_
+
+#include "key.h"
+
+namespace marisa {
+
+class Keyset {
+ public:
+  enum {
+    BASE_BLOCK_SIZE  = 4096,
+    EXTRA_BLOCK_SIZE = 1024,
+    KEY_BLOCK_SIZE   = 256
+  };
+
+  Keyset();
+
+  void push_back(const Key &key);
+  void push_back(const Key &key, char end_marker);
+
+  void push_back(const char *str);
+  void push_back(const char *ptr, std::size_t length, float weight = 1.0);
+
+  const Key &operator[](std::size_t i) const {
+    MARISA_DEBUG_IF(i >= size_, MARISA_BOUND_ERROR);
+    return key_blocks_[i / KEY_BLOCK_SIZE][i % KEY_BLOCK_SIZE];
+  }
+  Key &operator[](std::size_t i) {
+    MARISA_DEBUG_IF(i >= size_, MARISA_BOUND_ERROR);
+    return key_blocks_[i / KEY_BLOCK_SIZE][i % KEY_BLOCK_SIZE];
+  }
+
+  std::size_t num_keys() const {
+    return size_;
+  }
+
+  bool empty() const {
+    return size_ == 0;
+  }
+  std::size_t size() const {
+    return size_;
+  }
+  std::size_t total_length() const {
+    return total_length_;
+  }
+
+  void reset();
+
+  void clear();
+  void swap(Keyset &rhs);
+
+ private:
+  scoped_array<scoped_array<char> > base_blocks_;
+  std::size_t base_blocks_size_;
+  std::size_t base_blocks_capacity_;
+  scoped_array<scoped_array<char> > extra_blocks_;
+  std::size_t extra_blocks_size_;
+  std::size_t extra_blocks_capacity_;
+  scoped_array<scoped_array<Key> > key_blocks_;
+  std::size_t key_blocks_size_;
+  std::size_t key_blocks_capacity_;
+  char *ptr_;
+  std::size_t avail_;
+  std::size_t size_;
+  std::size_t total_length_;
+
+  char *reserve(std::size_t size);
+
+  void append_base_block();
+  void append_extra_block(std::size_t size);
+  void append_key_block();
+
+  // Disallows copy and assignment.
+  Keyset(const Keyset &);
+  Keyset &operator=(const Keyset &);
+};
+
+}  // namespace marisa
+
+#endif  // MARISA_KEYSET_H_

data/ext/marisa-0.2.4/pkg/include/marisa/query.h

@@ -0,0 +1,71 @@
+#ifndef MARISA_QUERY_H_
+#define MARISA_QUERY_H_
+
+#include "base.h"
+
+namespace marisa {
+
+class Query {
+ public:
+  Query() : ptr_(NULL), length_(0), id_(0) {}
+  Query(const Query &query)
+      : ptr_(query.ptr_), length_(query.length_), id_(query.id_) {}
+
+  Query &operator=(const Query &query) {
+    ptr_ = query.ptr_;
+    length_ = query.length_;
+    id_ = query.id_;
+    return *this;
+  }
+
+  char operator[](std::size_t i) const {
+    MARISA_DEBUG_IF(i >= length_, MARISA_BOUND_ERROR);
+    return ptr_[i];
+  }
+
+  void set_str(const char *str) {
+    MARISA_DEBUG_IF(str == NULL, MARISA_NULL_ERROR);
+    std::size_t length = 0;
+    while (str[length] != '\0') {
+      ++length;
+    }
+    ptr_ = str;
+    length_ = length;
+  }
+  void set_str(const char *ptr, std::size_t length) {
+    MARISA_DEBUG_IF((ptr == NULL) && (length != 0), MARISA_NULL_ERROR);
+    ptr_ = ptr;
+    length_ = length;
+  }
+  void set_id(std::size_t id) {
+    id_ = id;
+  }
+
+  const char *ptr() const {
+    return ptr_;
+  }
+  std::size_t length() const {
+    return length_;
+  }
+  std::size_t id() const {
+    return id_;
+  }
+
+  void clear() {
+    Query().swap(*this);
+  }
+  void swap(Query &rhs) {
+    marisa::swap(ptr_, rhs.ptr_);
+    marisa::swap(length_, rhs.length_);
+    marisa::swap(id_, rhs.id_);
+  }
+
+ private:
+  const char *ptr_;
+  std::size_t length_;
+  std::size_t id_;
+};
+
+}  // namespace marisa
+
+#endif  // MARISA_QUERY_H_

data/ext/marisa-0.2.4/pkg/include/marisa/scoped-array.h

@@ -0,0 +1,48 @@
+#ifndef MARISA_SCOPED_ARRAY_H_
+#define MARISA_SCOPED_ARRAY_H_
+
+#include "base.h"
+
+namespace marisa {
+
+template <typename T>
+class scoped_array {
+ public:
+  scoped_array() : array_(NULL) {}
+  explicit scoped_array(T *array) : array_(array) {}
+
+  ~scoped_array() {
+    delete [] array_;
+  }
+
+  void reset(T *array = NULL) {
+    MARISA_THROW_IF((array != NULL) && (array == array_), MARISA_RESET_ERROR);
+    scoped_array(array).swap(*this);
+  }
+
+  T &operator[](std::size_t i) const {
+    MARISA_DEBUG_IF(array_ == NULL, MARISA_STATE_ERROR);
+    return array_[i];
+  }
+  T *get() const {
+    return array_;
+  }
+
+  void clear() {
+    scoped_array().swap(*this);
+  }
+  void swap(scoped_array &rhs) {
+    marisa::swap(array_, rhs.array_);
+  }
+
+ private:
+  T *array_;
+
+  // Disallows copy and assignment.
+  scoped_array(const scoped_array &);
+  scoped_array &operator=(const scoped_array &);
+};
+
+}  // namespace marisa
+
+#endif  // MARISA_SCOPED_ARRAY_H_

data/ext/marisa-0.2.4/pkg/include/marisa/scoped-ptr.h

@@ -0,0 +1,52 @@
+#ifndef MARISA_SCOPED_PTR_H_
+#define MARISA_SCOPED_PTR_H_
+
+#include "base.h"
+
+namespace marisa {
+
+template <typename T>
+class scoped_ptr {
+ public:
+  scoped_ptr() : ptr_(NULL) {}
+  explicit scoped_ptr(T *ptr) : ptr_(ptr) {}
+
+  ~scoped_ptr() {
+    delete ptr_;
+  }
+
+  void reset(T *ptr = NULL) {
+    MARISA_THROW_IF((ptr != NULL) && (ptr == ptr_), MARISA_RESET_ERROR);
+    scoped_ptr(ptr).swap(*this);
+  }
+
+  T &operator*() const {
+    MARISA_DEBUG_IF(ptr_ == NULL, MARISA_STATE_ERROR);
+    return *ptr_;
+  }
+  T *operator->() const {
+    MARISA_DEBUG_IF(ptr_ == NULL, MARISA_STATE_ERROR);
+    return ptr_;
+  }
+  T *get() const {
+    return ptr_;
+  }
+
+  void clear() {
+    scoped_ptr().swap(*this);
+  }
+  void swap(scoped_ptr &rhs) {
+    marisa::swap(ptr_, rhs.ptr_);
+  }
+
+ private:
+  T *ptr_;
+
+  // Disallows copy and assignment.
+  scoped_ptr(const scoped_ptr &);
+  scoped_ptr &operator=(const scoped_ptr &);
+};
+
+}  // namespace marisa
+
+#endif  // MARISA_SCOPED_PTR_H_

data/ext/marisa-0.2.4/pkg/include/marisa/stdio.h

@@ -0,0 +1,15 @@
+#ifndef MARISA_STDIO_H_
+#define MARISA_STDIO_H_
+
+#include <cstdio>
+
+namespace marisa {
+
+class Trie;
+
+void fread(std::FILE *file, Trie *trie);
+void fwrite(std::FILE *file, const Trie &trie);
+
+}  // namespace marisa
+
+#endif  // MARISA_STDIO_H_