rroonga 5.1.1-x64-mingw32 → 6.0.0-x64-mingw32

data/vendor/local/include/groonga/groonga/token_filter.h

@@ -1,6 +1,6 @@
 /* -*- c-basic-offset: 2 -*- */
 /*
-  Copyright(C) 2014 Brazil
+  Copyright(C) 2014-2016 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -15,8 +15,8 @@
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
-#ifndef GROONGA_TOKEN_FILTER_H
-#define GROONGA_TOKEN_FILTER_H
+
+#pragma once
 
 #include <groonga/tokenizer.h>
 
@@ -65,5 +65,3 @@ GRN_PLUGIN_EXPORT grn_rc grn_token_filter_register(grn_ctx *ctx,
 #ifdef __cplusplus
 }  /* extern "C" */
 #endif  /* __cplusplus */
-
-#endif  /* GROONGA_TOKEN_FILTER_H */

data/vendor/local/include/groonga/groonga/tokenizer.h

@@ -1,6 +1,6 @@
 /* -*- c-basic-offset: 2 -*- */
 /*
-  Copyright(C) 2012 Brazil
+  Copyright(C) 2012-2016 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -15,8 +15,8 @@
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
-#ifndef GROONGA_TOKENIZER_H
-#define GROONGA_TOKENIZER_H
+
+#pragma once
 
 #include <groonga/plugin.h>
 #include <groonga/token.h>
@@ -258,5 +258,3 @@ GRN_PLUGIN_EXPORT grn_rc grn_tokenizer_register(grn_ctx *ctx, const char *plugin
 #ifdef __cplusplus
 }  /* extern "C" */
 #endif  /* __cplusplus */
-
-#endif  /* GROONGA_TOKENIZER_H */

data/vendor/local/include/groonga/groonga/type.h

@@ -0,0 +1,31 @@
+/*
+  Copyright(C) 2009-2016 Brazil
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library 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
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#pragma once
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+GRN_API grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size,
+                                 grn_obj_flags flags, unsigned int size);
+GRN_API uint32_t grn_type_size(grn_ctx *ctx, grn_obj *type);
+
+#ifdef __cplusplus
+}
+#endif

data/vendor/local/include/groonga/groonga/util.h

@@ -1,5 +1,5 @@
 /*
-  Copyright(C) 2010-2014 Brazil
+  Copyright(C) 2010-2016 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -15,8 +15,8 @@
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
-#ifndef GROONGA_UTIL_H
-#define GROONGA_UTIL_H
+
+#pragma once
 
 #ifdef  __cplusplus
 extern "C" {
@@ -36,5 +36,3 @@ GRN_API void grn_p_ii_values(grn_ctx *ctx, grn_obj *obj);
 #ifdef __cplusplus
 }
 #endif
-
-#endif /* GROONGA_UTIL_H */

data/vendor/local/include/groonga/groonga/windows.h

@@ -1,5 +1,5 @@
 /*
-  Copyright(C) 2015 Brazil
+  Copyright(C) 2015-2016 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -16,8 +16,7 @@
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#ifndef GROONGA_WINDOWS_H
-#define GROONGA_WINDOWS_H
+#pragma once
 
 #ifdef  __cplusplus
 extern "C" {
@@ -30,5 +29,3 @@ GRN_API const char *grn_windows_base_dir(void);
 #ifdef __cplusplus
 }
 #endif
-
-#endif /* GROONGA_WINDOWS_H */

data/vendor/local/include/groonga/groonga/windows_event_logger.h

@@ -1,5 +1,5 @@
 /*
-  Copyright(C) 2015 Brazil
+  Copyright(C) 2015-2016 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -16,8 +16,7 @@
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#ifndef GROONGA_WINDOWS_EVENT_LOGGER_H
-#define GROONGA_WINDOWS_EVENT_LOGGER_H
+#pragma once
 
 #ifdef  __cplusplus
 extern "C" {
@@ -29,5 +28,3 @@ GRN_API grn_rc grn_windows_event_logger_set(grn_ctx *ctx,
 #ifdef __cplusplus
 }
 #endif
-
-#endif /* GROONGA_WINDOWS_EVENT_LOGGER_H */

data/vendor/local/include/mecab.h

@@ -1,121 +1,328 @@
 /*
   MeCab -- Yet Another Part-of-Speech and Morphological Analyzer
 
-  $Id: mecab.h 173 2009-04-18 08:10:57Z taku-ku $;
-
-  Copyright(C) 2001-2006 Taku Kudo <taku@chasen.org>
+  Copyright(C) 2001-2011 Taku Kudo <taku@chasen.org>
   Copyright(C) 2004-2006 Nippon Telegraph and Telephone Corporation
 */
-#ifndef MECAB_MECAB_H
-#define MECAB_MECAB_H
+#ifndef MECAB_MECAB_H_
+#define MECAB_MECAB_H_
 
 /* C/C++ common data structures  */
+
+/**
+ * DictionaryInfo structure
+ */
 struct mecab_dictionary_info_t {
+  /**
+   * filename of dictionary
+   * On Windows, filename is stored in UTF-8 encoding
+   */
   const char                     *filename;
+
+  /**
+   * character set of the dictionary. e.g., "SHIFT-JIS", "UTF-8"
+   */
   const char                     *charset;
+
+  /**
+   * How many words are registered in this dictionary.
+   */
   unsigned int                    size;
+
+  /**
+   * dictionary type
+   * this value should be MECAB_USR_DIC, MECAB_SYS_DIC, or MECAB_UNK_DIC.
+   */
   int                             type;
+
+  /**
+   * left attributes size
+   */
   unsigned int                    lsize;
+
+  /**
+   * right attributes size
+   */
   unsigned int                    rsize;
+
+  /**
+   * version of this dictionary
+   */
   unsigned short                  version;
+
+  /**
+   * pointer to the next dictionary info.
+   */
   struct mecab_dictionary_info_t *next;
 };
 
+/**
+ * Path structure
+ */
 struct mecab_path_t {
+  /**
+   * pointer to the right node
+   */
   struct mecab_node_t* rnode;
+
+  /**
+   * pointer to the next right path
+   */
   struct mecab_path_t* rnext;
+
+  /**
+   * pointer to the left node
+   */
   struct mecab_node_t* lnode;
+
+  /**
+   * pointer to the next left path
+   */
+
   struct mecab_path_t* lnext;
-  int                  cost;
-  float                prob;
-};
 
-struct mecab_learner_path_t {
-  struct mecab_learner_node_t*  rnode;
-  struct mecab_learner_path_t*  rnext;
-  struct mecab_learner_node_t*  lnode;
-  struct mecab_learner_path_t*  lnext;
-  double                        cost;
-  const int                     *fvector;
-};
+  /**
+   * local cost
+   */
+  int                  cost;
 
-struct mecab_token_t {
-  unsigned short lcAttr;
-  unsigned short rcAttr;
-  unsigned short posid;
-  short wcost;
-  unsigned int   feature;
-  unsigned int   compound;  /* reserved for noun compound */
+  /**
+   * marginal probability
+   */
+  float                prob;
 };
 
+/**
+ * Node structure
+ */
 struct mecab_node_t {
+  /**
+   * pointer to the previous node.
+   */
   struct mecab_node_t  *prev;
+
+  /**
+   * pointer to the next node.
+   */
   struct mecab_node_t  *next;
+
+  /**
+   * pointer to the node which ends at the same position.
+   */
   struct mecab_node_t  *enext;
+
+  /**
+   * pointer to the node which starts at the same position.
+   */
   struct mecab_node_t  *bnext;
+
+  /**
+   * pointer to the right path.
+   * this value is NULL if MECAB_ONE_BEST mode.
+   */
   struct mecab_path_t  *rpath;
+
+  /**
+   * pointer to the right path.
+   * this value is NULL if MECAB_ONE_BEST mode.
+   */
   struct mecab_path_t  *lpath;
-  struct mecab_node_t **begin_node_list;
-  struct mecab_node_t **end_node_list;
+
+  /**
+   * surface string.
+   * this value is not 0 terminated.
+   * You can get the length with length/rlength members.
+   */
   const char           *surface;
+
+  /**
+   * feature string
+   */
   const char           *feature;
+
+  /**
+   * unique node id
+   */
   unsigned int          id;
-  unsigned short        length; /* length of morph */
-  unsigned short        rlength; /* real length of morph(include white space before the morph) */
+
+  /**
+   * length of the surface form.
+   */
+  unsigned short        length;
+
+  /**
+   * length of the surface form including white space before the morph.
+   */
+  unsigned short        rlength;
+
+  /**
+   * right attribute id
+   */
   unsigned short        rcAttr;
+
+  /**
+   * left attribute id
+   */
   unsigned short        lcAttr;
+
+  /**
+   * unique part of speech id. This value is defined in "pos.def" file.
+   */
   unsigned short        posid;
+
+  /**
+   * character type
+   */
   unsigned char         char_type;
+
+  /**
+   * status of this model.
+   * This value is MECAB_NOR_NODE, MECAB_UNK_NODE, MECAB_BOS_NODE, MECAB_EOS_NODE, or MECAB_EON_NODE.
+   */
   unsigned char         stat;
+
+  /**
+   * set 1 if this node is best node.
+   */
   unsigned char         isbest;
-  unsigned int          sentence_length; /* it is avaialbe only when BOS node */
+
+  /**
+   * forward accumulative log summation.
+   * This value is only available when MECAB_MARGINAL_PROB is passed.
+   */
   float                 alpha;
+
+  /**
+   * backward accumulative log summation.
+   * This value is only available when MECAB_MARGINAL_PROB is passed.
+   */
   float                 beta;
+
+  /**
+   * marginal probability.
+   * This value is only available when MECAB_MARGINAL_PROB is passed.
+   */
   float                 prob;
+
+  /**
+   * word cost.
+   */
   short                 wcost;
+
+  /**
+   * best accumulative cost from bos node to this node.
+   */
   long                  cost;
-  struct mecab_token_t  *token;
 };
 
-/* almost the same as mecab_node_t.
-   used only for cost estimation */
-struct mecab_learner_node_t {
-  struct mecab_learner_node_t *prev;
-  struct mecab_learner_node_t *next;
-  struct mecab_learner_node_t *enext;
-  struct mecab_learner_node_t *bnext;
-  struct mecab_learner_path_t *rpath;
-  struct mecab_learner_path_t *lpath;
-  struct mecab_learner_node_t *anext;
-  const char                  *surface;
-  const char                  *feature;
-  unsigned int                 id;
-  unsigned short               length;
-  unsigned short               rlength;
-  unsigned short               rcAttr;
-  unsigned short               lcAttr;
-  unsigned short               posid;
-  unsigned char                char_type;
-  unsigned char                stat;
-  unsigned char                isbest;
-  double                       alpha;
-  double                       beta;
-  short                        wcost2;
-  double                       wcost;
-  double                       cost;
-  const int                    *fvector;
-  struct mecab_token_t         *token;
+/**
+ * Parameters for MeCab::Node::stat
+ */
+enum {
+  /**
+   * Normal node defined in the dictionary.
+   */
+  MECAB_NOR_NODE = 0,
+  /**
+   * Unknown node not defined in the dictionary.
+   */
+  MECAB_UNK_NODE = 1,
+  /**
+   * Virtual node representing a beginning of the sentence.
+   */
+  MECAB_BOS_NODE = 2,
+  /**
+   * Virtual node representing a end of the sentence.
+   */
+  MECAB_EOS_NODE = 3,
+
+  /**
+   * Virtual node representing a end of the N-best enumeration.
+   */
+  MECAB_EON_NODE = 4
+};
+
+/**
+ * Parameters for MeCab::DictionaryInfo::type
+ */
+enum {
+  /**
+   * This is a system dictionary.
+   */
+  MECAB_SYS_DIC = 0,
+
+  /**
+   * This is a user dictionary.
+   */
+  MECAB_USR_DIC = 1,
+
+  /**
+   * This is a unknown word dictionary.
+   */
+  MECAB_UNK_DIC = 2
+};
+
+/**
+ * Parameters for MeCab::Lattice::request_type
+ */
+enum {
+  /**
+   * One best result is obtained (default mode)
+   */
+  MECAB_ONE_BEST          = 1,
+  /**
+   * Set this flag if you want to obtain N best results.
+   */
+  MECAB_NBEST             = 2,
+  /**
+   * Set this flag if you want to enable a partial parsing mode.
+   * When this flag is set, the input |sentence| needs to be written
+   * in partial parsing format.
+   */
+  MECAB_PARTIAL           = 4,
+  /**
+   * Set this flag if you want to obtain marginal probabilities.
+   * Marginal probability is set in MeCab::Node::prob.
+   * The parsing speed will get 3-5 times slower than the default mode.
+   */
+  MECAB_MARGINAL_PROB     = 8,
+  /**
+   * Set this flag if you want to obtain alternative results.
+   * Not implemented.
+   */
+  MECAB_ALTERNATIVE       = 16,
+  /**
+   * When this flag is set, the result linked-list (Node::next/prev)
+   * traverses all nodes in the lattice.
+   */
+  MECAB_ALL_MORPHS        = 32,
+
+  /**
+   * When this flag is set, tagger internally copies the body of passed
+   * sentence into internal buffer.
+   */
+  MECAB_ALLOCATE_SENTENCE = 64
 };
 
-#define MECAB_NOR_NODE  (0)
-#define MECAB_UNK_NODE  (1)
-#define MECAB_BOS_NODE  (2)
-#define MECAB_EOS_NODE  (3)
-#define MECAB_EON_NODE  (4)
+/**
+ * Parameters for MeCab::Lattice::boundary_constraint_type
+ */
+enum {
+  /**
+   * The token boundary is not specified.
+   */
+  MECAB_ANY_BOUNDARY = 0,
 
-#define MECAB_USR_DIC   (1)
-#define MECAB_SYS_DIC   (0)
-#define MECAB_UNK_DIC   (2)
+  /**
+   * The position is a strong token boundary.
+   */
+  MECAB_TOKEN_BOUNDARY = 1,
+
+  /**
+   * The position is not a token boundary.
+   */
+  MECAB_INSIDE_TOKEN = 2
+};
 
 /* C interface  */
 #ifdef __cplusplus
@@ -132,6 +339,7 @@ extern "C" {
 #include <windows.h>
 #  ifdef DLL_EXPORT
 #    define MECAB_DLL_EXTERN  __declspec(dllexport)
+#    define MECAB_DLL_CLASS_EXTERN  __declspec(dllexport)
 #  else
 #    define MECAB_DLL_EXTERN  __declspec(dllimport)
 #  endif
@@ -139,54 +347,414 @@ extern "C" {
 
 #ifndef MECAB_DLL_EXTERN
 #  define MECAB_DLL_EXTERN extern
+#endif
+
+#ifndef MECAB_DLL_CLASS_EXTERN
+#  define MECAB_DLL_CLASS_EXTERN
 #endif
 
   typedef struct mecab_t                 mecab_t;
+  typedef struct mecab_model_t           mecab_model_t;
+  typedef struct mecab_lattice_t         mecab_lattice_t;
   typedef struct mecab_dictionary_info_t mecab_dictionary_info_t;
   typedef struct mecab_node_t            mecab_node_t;
-  typedef struct mecab_learner_node_t    mecab_learner_node_t;
   typedef struct mecab_path_t            mecab_path_t;
-  typedef struct mecab_learner_path_t    mecab_learner_path_t;
-  typedef struct mecab_token_t           mecab_token_t;
 
 #ifndef SWIG
   /* C interface */
-  MECAB_DLL_EXTERN int           mecab_do (int argc, char **argv);
 
+  /* old mecab interface */
+  /**
+   * C wrapper of MeCab::Tagger::create(argc, argv)
+   */
   MECAB_DLL_EXTERN mecab_t*      mecab_new(int argc, char **argv);
+
+  /**
+   * C wrapper of MeCab::Tagger::create(arg)
+   */
   MECAB_DLL_EXTERN mecab_t*      mecab_new2(const char *arg);
+
+  /**
+   * C wrapper of MeCab::Tagger::version()
+   */
   MECAB_DLL_EXTERN const char*   mecab_version();
+
+  /**
+   * C wrapper of MeCab::getLastError()
+   */
   MECAB_DLL_EXTERN const char*   mecab_strerror(mecab_t *mecab);
+
+  /**
+   * C wrapper of MeCab::deleteTagger(tagger)
+   */
   MECAB_DLL_EXTERN void          mecab_destroy(mecab_t *mecab);
 
+  /**
+   * C wrapper of MeCab::Tagger:set_partial()
+   */
   MECAB_DLL_EXTERN int           mecab_get_partial(mecab_t *mecab);
+
+  /**
+   * C wrapper of MeCab::Tagger::partial()
+   */
   MECAB_DLL_EXTERN void          mecab_set_partial(mecab_t *mecab, int partial);
+
+  /**
+   * C wrapper of MeCab::Tagger::theta()
+   */
   MECAB_DLL_EXTERN float         mecab_get_theta(mecab_t *mecab);
+
+  /**
+   * C wrapper of  MeCab::Tagger::set_theta()
+   */
   MECAB_DLL_EXTERN void          mecab_set_theta(mecab_t *mecab, float theta);
+
+  /**
+   * C wrapper of MeCab::Tagger::lattice_level()
+   */
   MECAB_DLL_EXTERN int           mecab_get_lattice_level(mecab_t *mecab);
+
+  /**
+   * C wrapper of MeCab::Tagger::set_lattice_level()
+   */
   MECAB_DLL_EXTERN void          mecab_set_lattice_level(mecab_t *mecab, int level);
+
+  /**
+   * C wrapper of MeCab::Tagger::all_morphs()
+   */
   MECAB_DLL_EXTERN int           mecab_get_all_morphs(mecab_t *mecab);
+
+  /**
+   * C wrapper of MeCab::Tagger::set_all_moprhs()
+   */
   MECAB_DLL_EXTERN void          mecab_set_all_morphs(mecab_t *mecab, int all_morphs);
 
+  /**
+   * C wrapper of MeCab::Tagger::parse(MeCab::Lattice *lattice)
+   */
+  MECAB_DLL_EXTERN int           mecab_parse_lattice(mecab_t *mecab, mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Tagger::parse(const char *str)
+   */
   MECAB_DLL_EXTERN const char*   mecab_sparse_tostr(mecab_t *mecab, const char *str);
+
+  /**
+   * C wrapper of MeCab::Tagger::parse(const char *str, size_t len)
+   */
   MECAB_DLL_EXTERN const char*   mecab_sparse_tostr2(mecab_t *mecab, const char *str, size_t len);
+
+  /**
+   * C wrapper of MeCab::Tagger::parse(const char *str, char *ostr, size_t olen)
+   */
   MECAB_DLL_EXTERN char*         mecab_sparse_tostr3(mecab_t *mecab, const char *str, size_t len,
                                                      char *ostr, size_t olen);
+
+  /**
+   * C wrapper of MeCab::Tagger::parseToNode(const char *str)
+   */
   MECAB_DLL_EXTERN const mecab_node_t* mecab_sparse_tonode(mecab_t *mecab, const char*);
+
+  /**
+   * C wrapper of MeCab::Tagger::parseToNode(const char *str, size_t len)
+   */
   MECAB_DLL_EXTERN const mecab_node_t* mecab_sparse_tonode2(mecab_t *mecab, const char*, size_t);
+
+  /**
+   * C wrapper of MeCab::Tagger::parseNBest(size_t N, const char *str)
+   */
   MECAB_DLL_EXTERN const char*   mecab_nbest_sparse_tostr(mecab_t *mecab, size_t N, const char *str);
+
+  /**
+   * C wrapper of MeCab::Tagger::parseNBest(size_t N, const char *str, size_t len)
+   */
   MECAB_DLL_EXTERN const char*   mecab_nbest_sparse_tostr2(mecab_t *mecab, size_t N,
                                                            const char *str, size_t len);
+
+  /**
+   * C wrapper of MeCab::Tagger::parseNBest(size_t N, const char *str, char *ostr, size_t olen)
+   */
   MECAB_DLL_EXTERN char*         mecab_nbest_sparse_tostr3(mecab_t *mecab, size_t N,
                                                            const char *str, size_t len,
                                                            char *ostr, size_t olen);
+
+  /**
+   * C wrapper of MeCab::Tagger::parseNBestInit(const char *str)
+   */
   MECAB_DLL_EXTERN int           mecab_nbest_init(mecab_t *mecab, const char *str);
+
+  /**
+   * C wrapper of MeCab::Tagger::parseNBestInit(const char *str, size_t len)
+   */
   MECAB_DLL_EXTERN int           mecab_nbest_init2(mecab_t *mecab, const char *str, size_t len);
+
+  /**
+   * C wrapper of MeCab::Tagger::next()
+   */
   MECAB_DLL_EXTERN const char*   mecab_nbest_next_tostr(mecab_t *mecab);
+
+  /**
+   * C wrapper of MeCab::Tagger::next(char *ostr, size_t olen)
+   */
   MECAB_DLL_EXTERN char*         mecab_nbest_next_tostr2(mecab_t *mecab, char *ostr, size_t olen);
+
+  /**
+   * C wrapper of MeCab::Tagger::nextNode()
+   */
   MECAB_DLL_EXTERN const mecab_node_t* mecab_nbest_next_tonode(mecab_t *mecab);
+
+  /**
+   * C wrapper of MeCab::Tagger::formatNode(const Node *node)
+   */
   MECAB_DLL_EXTERN const char*   mecab_format_node(mecab_t *mecab, const mecab_node_t *node);
+
+  /**
+   * C wrapper of MeCab::Tagger::dictionary_info()
+   */
   MECAB_DLL_EXTERN const mecab_dictionary_info_t* mecab_dictionary_info(mecab_t *mecab);
+
+  /* lattice interface */
+  /**
+   * C wrapper of MeCab::createLattice()
+   */
+  MECAB_DLL_EXTERN mecab_lattice_t *mecab_lattice_new();
+
+  /**
+   * C wrapper of MeCab::deleteLattice(lattice)
+   */
+  MECAB_DLL_EXTERN void             mecab_lattice_destroy(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::clear()
+   */
+  MECAB_DLL_EXTERN void             mecab_lattice_clear(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::is_available()
+   */
+
+  MECAB_DLL_EXTERN int              mecab_lattice_is_available(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::bos_node()
+   */
+  MECAB_DLL_EXTERN mecab_node_t    *mecab_lattice_get_bos_node(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::eos_node()
+   */
+  MECAB_DLL_EXTERN mecab_node_t    *mecab_lattice_get_eos_node(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::begin_nodes()
+   */
+
+  MECAB_DLL_EXTERN mecab_node_t   **mecab_lattice_get_all_begin_nodes(mecab_lattice_t *lattice);
+  /**
+   * C wrapper of MeCab::Lattice::end_nodes()
+   */
+  MECAB_DLL_EXTERN mecab_node_t   **mecab_lattice_get_all_end_nodes(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::begin_nodes(pos)
+   */
+  MECAB_DLL_EXTERN mecab_node_t    *mecab_lattice_get_begin_nodes(mecab_lattice_t *lattice, size_t pos);
+
+  /**
+   * C wrapper of MeCab::Lattice::end_nodes(pos)
+   */
+  MECAB_DLL_EXTERN mecab_node_t    *mecab_lattice_get_end_nodes(mecab_lattice_t *lattice, size_t pos);
+
+  /**
+   * C wrapper of MeCab::Lattice::sentence()
+   */
+  MECAB_DLL_EXTERN const char      *mecab_lattice_get_sentence(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::set_sentence(sentence)
+   */
+  MECAB_DLL_EXTERN void             mecab_lattice_set_sentence(mecab_lattice_t *lattice, const char *sentence);
+
+  /**
+   * C wrapper of MeCab::Lattice::set_sentence(sentence, len)
+   */
+
+  MECAB_DLL_EXTERN void             mecab_lattice_set_sentence2(mecab_lattice_t *lattice, const char *sentence, size_t len);
+
+  /**
+   * C wrapper of MeCab::Lattice::size()
+   */
+  MECAB_DLL_EXTERN size_t           mecab_lattice_get_size(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::Z()
+   */
+  MECAB_DLL_EXTERN double           mecab_lattice_get_z(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::set_Z()
+   */
+  MECAB_DLL_EXTERN void             mecab_lattice_set_z(mecab_lattice_t *lattice, double Z);
+
+  /**
+   * C wrapper of MeCab::Lattice::theta()
+   */
+  MECAB_DLL_EXTERN double           mecab_lattice_get_theta(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::set_theta()
+   */
+
+  MECAB_DLL_EXTERN void             mecab_lattice_set_theta(mecab_lattice_t *lattice, double theta);
+
+  /**
+   * C wrapper of MeCab::Lattice::next()
+   */
+  MECAB_DLL_EXTERN int              mecab_lattice_next(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::request_type()
+   */
+  MECAB_DLL_EXTERN int              mecab_lattice_get_request_type(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::has_request_type()
+   */
+  MECAB_DLL_EXTERN int              mecab_lattice_has_request_type(mecab_lattice_t *lattice, int request_type);
+
+  /**
+   * C wrapper of MeCab::Lattice::set_request_type()
+   */
+  MECAB_DLL_EXTERN void             mecab_lattice_set_request_type(mecab_lattice_t *lattice, int request_type);
+
+  /**
+   * C wrapper of MeCab::Lattice::add_request_type()
+   */
+
+  MECAB_DLL_EXTERN void             mecab_lattice_add_request_type(mecab_lattice_t *lattice, int request_type);
+
+  /**
+   * C wrapper of MeCab::Lattice::remove_request_type()
+   */
+  MECAB_DLL_EXTERN void             mecab_lattice_remove_request_type(mecab_lattice_t *lattice, int request_type);
+
+  /**
+   * C wrapper of MeCab::Lattice::newNode();
+   */
+  MECAB_DLL_EXTERN mecab_node_t    *mecab_lattice_new_node(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::toString()
+   */
+  MECAB_DLL_EXTERN const char      *mecab_lattice_tostr(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::toString(buf, size)
+   */
+  MECAB_DLL_EXTERN const char      *mecab_lattice_tostr2(mecab_lattice_t *lattice, char *buf, size_t size);
+
+  /**
+   * C wrapper of MeCab::Lattice::enumNBestAsString(N)
+   */
+  MECAB_DLL_EXTERN const char      *mecab_lattice_nbest_tostr(mecab_lattice_t *lattice, size_t N);
+
+  /**
+   * C wrapper of MeCab::Lattice::enumNBestAsString(N, buf, size)
+   */
+
+  MECAB_DLL_EXTERN const char      *mecab_lattice_nbest_tostr2(mecab_lattice_t *lattice, size_t N, char *buf, size_t size);
+
+  /**
+   * C wrapper of MeCab::Lattice::has_constraint()
+   */
+  MECAB_DLL_EXTERN int             mecab_lattice_has_constraint(mecab_lattice_t *lattice);
+
+  /**
+   * C wrapper of MeCab::Lattice::boundary_constraint(pos)
+   */
+  MECAB_DLL_EXTERN int             mecab_lattice_get_boundary_constraint(mecab_lattice_t *lattice, size_t pos);
+
+
+  /**
+   * C wrapper of MeCab::Lattice::feature_constraint(pos)
+   */
+  MECAB_DLL_EXTERN const char     *mecab_lattice_get_feature_constraint(mecab_lattice_t *lattice, size_t pos);
+
+  /**
+   * C wrapper of MeCab::Lattice::boundary_constraint(pos, type)
+   */
+  MECAB_DLL_EXTERN void            mecab_lattice_set_boundary_constraint(mecab_lattice_t *lattice, size_t pos, int boundary_type);
+
+  /**
+   * C wrapper of MeCab::Lattice::set_feature_constraint(begin_pos, end_pos, feature)
+   */
+  MECAB_DLL_EXTERN void            mecab_lattice_set_feature_constraint(mecab_lattice_t *lattice, size_t begin_pos, size_t end_pos, const char *feature);
+
+  /**
+   * C wrapper of MeCab::Lattice::set_result(result);
+   */
+  MECAB_DLL_EXTERN void            mecab_lattice_set_result(mecab_lattice_t *lattice, const char *result);
+
+  /**
+   * C wrapper of MeCab::Lattice::what()
+   */
+  MECAB_DLL_EXTERN const char      *mecab_lattice_strerror(mecab_lattice_t *lattice);
+
+
+  /* model interface */
+  /**
+   * C wapper of MeCab::Model::create(argc, argv)
+   */
+  MECAB_DLL_EXTERN mecab_model_t   *mecab_model_new(int argc, char **argv);
+
+  /**
+   * C wapper of MeCab::Model::create(arg)
+   */
+  MECAB_DLL_EXTERN mecab_model_t   *mecab_model_new2(const char *arg);
+
+  /**
+   * C wapper of MeCab::deleteModel(model)
+   */
+
+  MECAB_DLL_EXTERN void             mecab_model_destroy(mecab_model_t *model);
+
+  /**
+   * C wapper of MeCab::Model::createTagger()
+   */
+  MECAB_DLL_EXTERN mecab_t         *mecab_model_new_tagger(mecab_model_t *model);
+
+  /**
+   * C wapper of MeCab::Model::createLattice()
+   */
+  MECAB_DLL_EXTERN mecab_lattice_t *mecab_model_new_lattice(mecab_model_t *model);
+
+  /**
+   * C wrapper of MeCab::Model::swap()
+   */
+  MECAB_DLL_EXTERN int mecab_model_swap(mecab_model_t *model, mecab_model_t *new_model);
+
+  /**
+   * C wapper of MeCab::Model::dictionary_info()
+   */
+  MECAB_DLL_EXTERN const mecab_dictionary_info_t* mecab_model_dictionary_info(mecab_model_t *model);
+
+  /**
+   * C wrapper of MeCab::Model::transition_cost()
+   */
+  MECAB_DLL_EXTERN int mecab_model_transition_cost(mecab_model_t *model,
+                                                   unsigned short rcAttr,
+                                                   unsigned short lcAttr);
+
+  /**
+   * C wrapper of MeCab::Model::lookup()
+   */
+  MECAB_DLL_EXTERN mecab_node_t *mecab_model_lookup(mecab_model_t *model,
+                                                    const char *begin,
+                                                    const char *end,
+                                                    mecab_lattice_t *lattice);
+
+  /* static functions */
+  MECAB_DLL_EXTERN int           mecab_do(int argc, char **argv);
   MECAB_DLL_EXTERN int           mecab_dict_index(int argc, char **argv);
   MECAB_DLL_EXTERN int           mecab_dict_gen(int argc, char **argv);
   MECAB_DLL_EXTERN int           mecab_cost_train(int argc, char **argv);
@@ -205,65 +773,737 @@ namespace MeCab {
 typedef struct mecab_dictionary_info_t DictionaryInfo;
 typedef struct mecab_path_t            Path;
 typedef struct mecab_node_t            Node;
-typedef struct mecab_learner_path_t    LearnerPath;
-typedef struct mecab_learner_node_t    LearnerNode;
-typedef struct mecab_token_t           Token;
 
-class Tagger {
- public:
+template <typename N, typename P> class Allocator;
+class Tagger;
+
+/**
+ * Lattice class
+ */
+class MECAB_DLL_CLASS_EXTERN Lattice {
+public:
+  /**
+   * Clear all internal lattice data.
+   */
+  virtual void clear()              = 0;
+
+  /**
+   * Return true if result object is available.
+   * @return boolean
+   */
+  virtual bool is_available() const = 0;
+
+  /**
+   * Return bos (begin of sentence) node.
+   * You can obtain all nodes via "for (const Node *node = lattice->bos_node(); node; node = node->next) {}"
+   * @return bos node object
+   */
+  virtual Node *bos_node() const              = 0;
+
+  /**
+   * Return eos (end of sentence) node.
+   * @return eos node object
+   */
+  virtual Node *eos_node() const              = 0;
 
 #ifndef SWIG
-  virtual const char* parse(const char *str, size_t len, char *ostr, size_t olen) = 0;
-  virtual const char* parse(const char *str, size_t len)                          = 0;
-  virtual const Node* parseToNode(const char *str, size_t len)                    = 0;
-  virtual const char* parseNBest(size_t N, const char *str, size_t len)           = 0;
-  virtual bool  parseNBestInit(const char *str, size_t len)                       = 0;
+  /**
+   * This method is used internally.
+   */
+  virtual Node **begin_nodes() const          = 0;
+
+  /**
+   * This method is used internally.
+   */
+  virtual Node **end_nodes() const            = 0;
+#endif
+
+  /**
+   * Return node linked list ending at |pos|.
+   * You can obtain all nodes via "for (const Node *node = lattice->end_nodes(pos); node; node = node->enext) {}"
+   * @param pos position of nodes. 0 <= pos < size()
+   * @return node linked list
+   */
+  virtual Node *end_nodes(size_t pos) const   = 0;
+
+  /**
+   * Return node linked list starting at |pos|.
+   * You can obtain all nodes via "for (const Node *node = lattice->begin_nodes(pos); node; node = node->bnext) {}"
+   * @param pos position of nodes. 0 <= pos < size()
+   * @return node linked list
+   */
+  virtual Node *begin_nodes(size_t pos) const = 0;
+
+  /**
+   * Return sentence.
+   * If MECAB_NBEST or MECAB_PARTIAL mode is off, the returned poiner is the same as the one set by set_sentence().
+   * @return sentence
+   */
+  virtual const char *sentence() const = 0;
+
+  /**
+   * Set sentence. This method does not take the ownership of the object.
+   * @param sentence sentence
+   */
+  virtual void set_sentence(const char *sentence)             = 0;
+
+#ifndef SWIG
+  /**
+   * Set sentence. This method does not take the ownership of the object.
+   * @param sentence sentence
+   * @param len length of the sentence
+   */
+  virtual void set_sentence(const char *sentence, size_t len) = 0;
+#endif
+
+  /**
+   * Return sentence size.
+   * @return sentence size
+   */
+  virtual size_t size() const                                 = 0;
+
+  /**
+   * Set normalization factor of CRF.
+   * @param Z new normalization factor.
+   */
+  virtual void   set_Z(double Z) = 0;
+
+  /**
+   * return normalization factor of CRF.
+   * @return normalization factor.
+   */
+  virtual double Z() const = 0;
+
+  /**
+   * Set temparature parameter theta.
+   * @param theta temparature parameter.
+   */
+  virtual void  set_theta(float theta) = 0;
+
+  /**
+   * Return temparature parameter theta.
+   * @return temparature parameter.
+   */
+  virtual float theta() const          = 0;
+
+  /**
+   * Obtain next-best result. The internal linked list structure is updated.
+   * You should set MECAB_NBEST reques_type in advance.
+   * Return false if no more results are available or request_type is invalid.
+   * @return boolean
+   */
+  virtual bool next() = 0;
+
+  /**
+   * Return the current request type.
+   * @return request type
+   */
+  virtual int request_type() const                = 0;
+
+  /**
+   * Return true if the object has a specified request type.
+   * @return boolean
+   */
+  virtual bool has_request_type(int request_type) const = 0;
+
+  /**
+   * Set request type.
+   * @param request_type new request type assigned
+   */
+  virtual void set_request_type(int request_type) = 0;
+
+  /**
+   * Add request type.
+   * @param request_type new request type added
+   */
+  virtual void add_request_type(int request_type) = 0;
+
+  /**
+   * Remove request type.
+   * @param request_type new request type removed
+   */
+  virtual void remove_request_type(int request_type) = 0;
+
+#ifndef SWIG
+  /**
+   * This method is used internally.
+   */
+  virtual Allocator<Node, Path> *allocator() const = 0;
+#endif
+
+  /**
+   * Return new node. Lattice objects has the ownership of the node.
+   * @return new node object
+   */
+  virtual Node *newNode() = 0;
+
+  /**
+   * Return string representation of the lattice.
+   * Returned object is managed by this instance. When clear/set_sentence() method
+   * is called, the returned buffer is initialized.
+   * @return string representation of the lattice
+   */
+  virtual const char *toString()                = 0;
+
+  /**
+   * Return string representation of the node.
+   * Returned object is managed by this instance. When clear/set_sentence() method
+   * is called, the returned buffer is initialized.
+   * @return string representation of the node
+   * @param node node object
+   */
+  virtual const char *toString(const Node *node) = 0;
+
+  /**
+   * Return string representation of the N-best results.
+   * Returned object is managed by this instance. When clear/set_sentence() method
+   * is called, the returned buffer is initialized.
+   * @return string representation of the node
+   * @param N how many results you want to obtain
+   */
+  virtual const char *enumNBestAsString(size_t N) = 0;
+
+#ifndef SWIG
+  /**
+   * Return string representation of the lattice.
+   * Result is saved in the specified buffer.
+   * @param buf output buffer
+   * @param size output buffer size
+   * @return string representation of the lattice
+   */
+  virtual const char *toString(char *buf, size_t size) = 0;
+
+  /**
+   * Return string representation of the node.
+   * Result is saved in the specified buffer.
+   * @param node node object
+   * @param buf output buffer
+   * @param size output buffer size
+   * @return string representation of the lattice
+   */
+  virtual const char *toString(const Node *node,
+                               char *buf, size_t size) = 0;
+
+  /**
+   * Return string representation of the N-best result.
+   * Result is saved in the specified.
+   * @param N how many results you want to obtain
+   * @param buf output buffer
+   * @param size output buffer size
+   * @return string representation of the lattice
+   */
+  virtual const char *enumNBestAsString(size_t N, char *buf, size_t size) = 0;
+#endif
+
+  /**
+   * Returns true if any parsing constraint is set
+   */
+  virtual bool has_constraint() const = 0;
+
+  /**
+   * Returns the boundary constraint at the position.
+   * @param pos the position of constraint
+   * @return boundary constraint type
+   */
+  virtual int boundary_constraint(size_t pos) const = 0;
+
+  /**
+   * Returns the token constraint at the position.
+   * @param pos the beginning position of constraint.
+   * @return constrained node starting at the position.
+   */
+  virtual const char *feature_constraint(size_t pos) const = 0;
+
+  /**
+   * Set parsing constraint for partial parsing mode.
+   * @param pos the position of the boundary
+   * @param boundary_constraint_type the type of boundary
+   */
+  virtual void set_boundary_constraint(size_t pos,
+                                       int boundary_constraint_type) = 0;
+
+  /**
+   * Set parsing constraint for partial parsing mode.
+   * @param begin_pos the starting position of the constrained token.
+   * @param end_pos the the ending position of the constrained token.
+   * @param feature the feature of the constrained token.
+   */
+  virtual void set_feature_constraint(
+      size_t begin_pos, size_t end_pos,
+      const char *feature) = 0;
+
+  /**
+   * Set golden parsing results for unittesting.
+   * @param result the parsing result written in the standard mecab output.
+   */
+  virtual void set_result(const char *result) = 0;
+
+  /**
+   * Return error string.
+   * @return error string
+   */
+  virtual const char *what() const            = 0;
+
+  /**
+   * Set error string. given string is copied to the internal buffer.
+   * @param str new error string
+   */
+  virtual void set_what(const char *str)        = 0;
+
+#ifndef SWIG
+  /**
+   * Create new Lattice object
+   * @return new Lattice object
+   */
+  static Lattice *create();
 #endif
 
+  virtual ~Lattice() {}
+};
+
+/**
+ * Model class
+ */
+class MECAB_DLL_CLASS_EXTERN Model {
+public:
+  /**
+   * Return DictionaryInfo linked list.
+   * @return DictionaryInfo linked list
+   */
+  virtual const DictionaryInfo *dictionary_info() const = 0;
+
+  /**
+   * Return transtion cost from rcAttr to lcAttr.
+   * @return transtion cost
+   */
+  virtual int transition_cost(unsigned short rcAttr,
+                              unsigned short lcAttr) const = 0;
+
+  /**
+   * perform common prefix search from the range [begin, end).
+   * |lattice| takes the ownership of return value.
+   * @return node linked list.
+   */
+  virtual Node *lookup(const char *begin, const char *end,
+                       Lattice *lattice) const = 0;
+
+  /**
+   * Create a new Tagger object.
+   * All returned tagger object shares this model object as a parsing model.
+   * Never delete this model object before deleting tagger object.
+   * @return new Tagger object
+   */
+  virtual Tagger  *createTagger() const = 0;
+
+  /**
+   * Create a new Lattice object.
+   * @return new Lattice object
+   */
+  virtual Lattice *createLattice() const = 0;
+
+  /**
+   * Swap the instance with |model|.
+   * The ownership of |model| always moves to this instance,
+   * meaning that passed |model| will no longer be accessible after calling this method.
+   * return true if new model is swapped successfully.
+   * This method is thread safe. All taggers created by
+   * Model::createTagger() method will also be updated asynchronously.
+   * No need to stop the parsing thread excplicitly before swapping model object.
+   * @return boolean
+   * @param model new model which is going to be swapped with the current model.
+   */
+  virtual bool swap(Model *model) = 0;
+
+  /**
+   * Return a version string
+   * @return version string
+   */
+  static const char *version();
+
+  virtual ~Model() {}
+
+#ifndef SIWG
+  /**
+   * Factory method to create a new Model with a specified main's argc/argv-style parameters.
+   * Return NULL if new model cannot be initialized. Use MeCab::getLastError() to obtain the
+   * cause of the errors.
+   * @return new Model object
+   * @param argc number of parameters
+   * @param argv parameter list
+   */
+  static Model* create(int argc, char **argv);
+
+  /**
+   * Factory method to create a new Model with a string parameter representation, i.e.,
+   * "-d /user/local/mecab/dic/ipadic -Ochasen".
+   * Return NULL if new model cannot be initialized. Use MeCab::getLastError() to obtain the
+   * cause of the errors.
+   * @return new Model object
+   * @param arg single string representation of the argment.
+   */
+  static Model* create(const char *arg);
+#endif
+};
+
+/**
+ * Tagger class
+ */
+class MECAB_DLL_CLASS_EXTERN Tagger {
+public:
+  /**
+   * Handy static method.
+   * Return true if lattice is parsed successfully.
+   * This function is equivalent to
+   * {
+   *   Tagger *tagger = model.createModel();
+   *   cosnt bool result = tagger->parse(lattice);
+   *   delete tagger;
+   *   return result;
+   * }
+   * @return boolean
+   */
+  static bool  parse(const Model &model, Lattice *lattice);
+
+  /**
+   * Parse lattice object.
+   * Return true if lattice is parsed successfully.
+   * A sentence must be set to the lattice with Lattice:set_sentence object before calling this method.
+   * Parsed node object can be obtained with Lattice:bos_node.
+   * This method is thread safe.
+   * @return lattice lattice object
+   * @return boolean
+   */
+  virtual bool parse(Lattice *lattice) const                = 0;
+
+  /**
+   * Parse given sentence and return parsed result as string.
+   * You should not delete the returned string. The returned buffer
+   * is overwritten when parse method is called again.
+   * This method is NOT thread safe.
+   * @param str sentence
+   * @return parsed result
+   */
   virtual const char* parse(const char *str)                = 0;
+
+  /**
+   * Parse given sentence and return Node object.
+   * You should not delete the returned node object. The returned buffer
+   * is overwritten when parse method is called again.
+   * You can traverse all nodes via Node::next member.
+   * This method is NOT thread safe.
+   * @param str sentence
+   * @return bos node object
+   */
   virtual const Node* parseToNode(const char *str)          = 0;
+
+  /**
+   * Parse given sentence and obtain N-best results as a string format.
+   * Currently, N must be 1 <= N <= 512 due to the limitation of the buffer size.
+   * You should not delete the returned string. The returned buffer
+   * is overwritten when parse method is called again.
+   * This method is DEPRECATED. Use Lattice class.
+   * @param N how many results you want to obtain
+   * @param str sentence
+   * @return parsed result
+   */
   virtual const char* parseNBest(size_t N, const char *str) = 0;
+
+  /**
+   * Initialize N-best enumeration with a sentence.
+   * Return true if initialization finishes successfully.
+   * N-best result is obtained by calling next() or nextNode() in sequence.
+   * This method is NOT thread safe.
+   * This method is DEPRECATED. Use Lattice class.
+   * @param str sentence
+   * @return boolean
+   */
   virtual bool  parseNBestInit(const char *str)             = 0;
+
+  /**
+   * Return next-best parsed result. You must call parseNBestInit() in advance.
+   * Return NULL if no more reuslt is available.
+   * This method is NOT thread safe.
+   * This method is DEPRECATED. Use Lattice class.
+   * @return node object
+   */
   virtual const Node* nextNode()                            = 0;
+
+  /**
+   * Return next-best parsed result. You must call parseNBestInit() in advance.
+   * Return NULL if no more reuslt is available.
+   * This method is NOT thread safe.
+   * This method is DEPRECATED. Use Lattice class.
+   * @return parsed result
+   */
   virtual const char* next()                                = 0;
+
+  /**
+   * Return formatted node object. The format is specified with
+   * --unk-format, --bos-format, --eos-format, and --eon-format respectively.
+   * You should not delete the returned string. The returned buffer
+   * is overwritten when parse method is called again.
+   * This method is NOT thread safe.
+   * This method is DEPRECATED. Use Lattice class.
+   * @param node node object.
+   * @return parsed result
+   */
   virtual const char* formatNode(const Node *node)          = 0;
 
-  // configuration
+#ifndef SWIG
+  /**
+   * The same as parse() method, but input length and output buffer are passed.
+   * Return parsed result as string. The result pointer is the same as |ostr|.
+   * Return NULL, if parsed result string cannot be stored within |olen| bytes.
+   * @param str sentence
+   * @param len sentence length
+   * @param ostr output buffer
+   * @param olen output buffer length
+   * @return parsed result
+   */
+  virtual const char* parse(const char *str, size_t len, char *ostr, size_t olen) = 0;
+
+  /**
+   * The same as parse() method, but input length can be passed.
+   * @param str sentence
+   * @param len sentence length
+   * @return parsed result
+   */
+  virtual const char* parse(const char *str, size_t len)                          = 0;
+
+  /**
+   * The same as parseToNode(), but input lenth can be passed.
+   * @param str sentence
+   * @param len sentence length
+   * @return node object
+   */
+  virtual const Node* parseToNode(const char *str, size_t len)                    = 0;
+
+  /**
+   * The same as parseNBest(), but input length can be passed.
+   * @param N how many results you want to obtain
+   * @param str sentence
+   * @param len sentence length
+   * @return parsed result
+   */
+  virtual const char* parseNBest(size_t N, const char *str, size_t len)           = 0;
+
+  /**
+   * The same as parseNBestInit(), but input length can be passed.
+   * @param str sentence
+   * @param len sentence length
+   * @return boolean
+   * @return parsed result
+   */
+  virtual bool  parseNBestInit(const char *str, size_t len)                  = 0;
+
+  /**
+   * The same as next(), but output buffer can be passed.
+   * Return NULL if more than |olen| buffer is required to store output string.
+   * @param ostr output buffer
+   * @param olen output buffer length
+   * @return parsed result
+   */
+  virtual const char* next(char *ostr , size_t olen)                        = 0;
+
+  /**
+   * The same as parseNBest(), but input length and output buffer can be passed.
+   * Return NULL if more than |olen| buffer is required to store output string.
+   * @param N how many results you want to obtain
+   * @param str input sentence
+   * @param len input sentence length
+   * @param ostr output buffer
+   * @param olen output buffer length
+   * @return parsed result
+   */
+  virtual const char* parseNBest(size_t N, const char *str,
+                                 size_t len, char *ostr, size_t olen)       = 0;
+
+  /**
+   * The same as formatNode(), but output buffer can be passed.
+   * Return NULL if more than |olen| buffer is required to store output string.
+   * @param node node object
+   * @param ostr output buffer
+   * @param olen output buffer length
+   * @return parsed result
+   */
+  virtual const char* formatNode(const Node *node, char *ostr, size_t olen) = 0;
+#endif
+
+  /**
+   * Set request type.
+   * This method is DEPRECATED. Use Lattice::set_request_type(MECAB_PARTIAL).
+   * @param request_type new request type assigned
+   */
+  virtual void set_request_type(int request_type) = 0;
+
+  /**
+   * Return the current request type.
+   * This method is DEPRECATED. Use Lattice class.
+   * @return request type
+   */
+  virtual int  request_type() const = 0;
+
+  /**
+   * Return true if partial parsing mode is on.
+   * This method is DEPRECATED. Use Lattice::has_request_type(MECAB_PARTIAL).
+   * @return boolean
+   */
   virtual bool  partial() const                             = 0;
+
+  /**
+   * set partial parsing mode.
+   * This method is DEPRECATED. Use Lattice::add_request_type(MECAB_PARTIAL) or Lattice::remove_request_type(MECAB_PARTIAL)
+   * @param partial partial mode
+   */
   virtual void  set_partial(bool partial)                   = 0;
-  virtual float theta() const                               = 0;
-  virtual void  set_theta(float theta)                      = 0;
+
+  /**
+   * Return lattice level.
+   * This method is DEPRECATED. Use Lattice::*_request_type()
+   * @return int lattice level
+   */
   virtual int   lattice_level() const                       = 0;
+
+  /**
+   * Set lattice level.
+   * This method is DEPRECATED. Use Lattice::*_request_type()
+   * @param level lattice level
+   */
   virtual void  set_lattice_level(int level)                = 0;
+
+  /**
+   * Return true if all morphs output mode is on.
+   * This method is DEPRECATED. Use Lattice::has_request_type(MECAB_ALL_MORPHS).
+   * @return boolean
+   */
   virtual bool  all_morphs() const                          = 0;
+
+  /**
+   * set all-morphs output mode.
+   * This method is DEPRECATED. Use Lattice::add_request_type(MECAB_ALL_MORPHS) or Lattice::remove_request_type(MECAB_ALL_MORPHS)
+   * @param all_morphs
+   */
   virtual void  set_all_morphs(bool all_morphs)             = 0;
 
-#ifndef SWIG
-  virtual const char* next(char *ostr , size_t olen)                        = 0;
-  virtual const char* parseNBest(size_t N, const char *str,
-                                 size_t len, char *ostr, size_t olen)       = 0;
-  virtual const char* formatNode(const Node *node, char *ostr, size_t olen) = 0;
-#endif
+  /**
+   * Set temparature parameter theta.
+   * @param theta temparature parameter.
+   */
+  virtual void  set_theta(float theta)                      = 0;
 
+  /**
+   * Return temparature parameter theta.
+   * @return temparature parameter.
+   */
+  virtual float theta() const                               = 0;
+
+  /**
+   * Return DictionaryInfo linked list.
+   * @return DictionaryInfo linked list
+   */
   virtual const DictionaryInfo* dictionary_info() const = 0;
 
-  virtual const char* what() = 0;
+  /**
+   * Return error string.
+   * @return error string
+   */
+  virtual const char* what() const = 0;
 
   virtual ~Tagger() {}
 
 #ifndef SIWG
-  static Tagger* create(int argc, char **argv);
-  static Tagger* create(const char *arg);
+  /**
+   * Factory method to create a new Tagger with a specified main's argc/argv-style parameters.
+   * Return NULL if new model cannot be initialized. Use MeCab::getLastError() to obtain the
+   * cause of the errors.
+   * @return new Tagger object
+   * @param argc number of parameters
+   * @param argv parameter list
+   */
+  static Tagger *create(int argc, char **argv);
+
+  /**
+   * Factory method to create a new Tagger with a string parameter representation, i.e.,
+   * "-d /user/local/mecab/dic/ipadic -Ochasen".
+   * Return NULL if new model cannot be initialized. Use MeCab::getLastError() to obtain the
+   * cause of the errors.
+   * @return new Model object
+   * @param arg single string representation of the argment.
+   */
+  static Tagger *create(const char *arg);
 #endif
 
+  /**
+   * Return a version string
+   * @return version string
+   */
   static const char *version();
 };
 
-/* factory method */
-MECAB_DLL_EXTERN Tagger *createTagger(int argc, char **argv);
-MECAB_DLL_EXTERN Tagger *createTagger(const char *arg);
-MECAB_DLL_EXTERN const char* getTaggerError();
-}
+#ifndef SWIG
+/**
+ * Alias of Lattice::create()
+ */
+MECAB_DLL_EXTERN Lattice     *createLattice();
+
+/**
+ * Alias of Mode::create(argc, argv)
+ */
+MECAB_DLL_EXTERN Model       *createModel(int argc, char **argv);
+
+/**
+ * Alias of Mode::create(arg)
+ */
+MECAB_DLL_EXTERN Model       *createModel(const char *arg);
+
+/**
+ * Alias of Tagger::create(argc, argv)
+ */
+MECAB_DLL_EXTERN Tagger      *createTagger(int argc, char **argv);
 
+/**
+ * Alias of Tagger::create(arg)
+ */
+MECAB_DLL_EXTERN Tagger      *createTagger(const char *arg);
+
+/**
+ * delete Lattice object.
+ * This method calles "delete lattice".
+ * In some environment, e.g., MS-Windows, an object allocated inside a DLL must be deleted in the same DLL too.
+ * @param lattice lattice object
+ */
+MECAB_DLL_EXTERN void        deleteLattice(Lattice *lattice);
+
+
+/**
+ * delete Model object.
+ * This method calles "delete model".
+ * In some environment, e.g., MS-Windows, an object allocated inside a DLL must be deleted in the same DLL too.
+ * @param model model object
+ */
+MECAB_DLL_EXTERN void        deleteModel(Model *model);
+
+/**
+ * delete Tagger object.
+ * This method calles "delete tagger".
+ * In some environment, e.g., MS-Windows, an object allocated inside a DLL must be deleted in the same DLL too.
+ * @param tagger tagger object
+ */
+MECAB_DLL_EXTERN void        deleteTagger(Tagger *tagger);
+
+/**
+ * Return last error string.
+ * @return error string
+ */
+MECAB_DLL_EXTERN const char*  getLastError();
+
+/**
+ * An alias of getLastError.
+ * It is kept for backward compatibility.
+ * @return error string
+ */
+MECAB_DLL_EXTERN const char*  getTaggerError();
 #endif
+}
 #endif
+#endif  /* MECAB_MECAB_H_ */