mecab-sys 0.1.0

FFI binding and safe wrappers of MeCab
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//  MeCab -- Yet Another Part-of-Speech and Morphological Analyzer
//
//
//  Copyright(C) 2001-2011 Taku Kudo <taku@chasen.org>
//  Copyright(C) 2004-2006 Nippon Telegraph and Telephone Corporation
#ifndef MECAB_DICTIONARY_H_
#define MECAB_DICTIONARY_H_

#include "mecab.h"
#include "mmap.h"
#include "darts.h"
#include "char_property.h"

namespace MeCab {

class Param;

struct Token {
  unsigned short lcAttr;
  unsigned short rcAttr;
  unsigned short posid;
  short wcost;
  unsigned int   feature;
  unsigned int   compound;
};

class Dictionary {
 public:
  typedef Darts::DoubleArray::result_pair_type result_type;

  bool open(const char *filename, const char *mode = "r");
  void close();

  size_t commonPrefixSearch(const char* key, size_t len,
                            result_type *result,
                            size_t rlen) const {
    return da_.commonPrefixSearch(key, result, rlen, len);
  }

  result_type exactMatchSearch(const char* key) const {
    result_type n;
    da_.exactMatchSearch(key, n);
    return n;
  }

  bool isCompatible(const Dictionary &d) const {
    return(version_ == d.version_ &&
           lsize_  == d.lsize_   &&
           rsize_  == d.rsize_   &&
           decode_charset(charset_) ==
           decode_charset(d.charset_));
  }

  const char *filename() const { return filename_.c_str(); }
  const char *charset() const { return const_cast<const char*>(charset_); }
  unsigned short version() const { return version_; }
  size_t  size() const { return static_cast<size_t>(lexsize_); }
  int type() const { return static_cast<int>(type_);  }
  size_t lsize() const { return static_cast<size_t>(lsize_); }
  size_t rsize() const { return static_cast<size_t>(rsize_); }

  const Token *token(const result_type &n) const {
    return token_ +(n.value >> 8);
  }
  size_t token_size(const result_type &n) const { return 0xff & n.value; }
  const char  *feature(const Token &t) const { return feature_ + t.feature; }

  static bool compile(const Param &param,
                      const std::vector<std::string> &dics,
                      const char *output);  // outputs

  static bool assignUserDictionaryCosts(
      const Param &param,
      const std::vector<std::string> &dics,
      const char *output);  // outputs


  const char *what() { return what_.str(); }

  explicit Dictionary(): dmmap_(new Mmap<char>), token_(0),
                         feature_(0), charset_(0) {}
  virtual ~Dictionary() { this->close(); }

 private:
  scoped_ptr<Mmap<char> > dmmap_;
  const Token        *token_;
  const char         *feature_;
  const char         *charset_;
  unsigned int        version_;
  unsigned int        type_;
  unsigned int        lexsize_;
  unsigned int        lsize_;
  unsigned int        rsize_;
  std::string         filename_;
  whatlog             what_;
  Darts::DoubleArray  da_;
};
}
#endif  // MECAB_DICTIONARY_H_