* Senna API

SennȃSĂ̋@\API֐ʂĒ񋟂܂B

APÍAbasic API, advanced API, low-level API3ނ\܂B
basic APIgăCfbNX̍쐬EXVËʂ̋@\gpł܂B
advanced APIp邱ƂɂāAxׂ̍ȃ`[jO𐧌䂷邱Ƃ\ɂȂ܂B
low-level APIp邱ƂɂSenna̓̃f[^\ɃANZXAɕGȃf[^̑⌟s܂B

* basic API

basic APÍA2̃f[^^Ƃ̑֐AsennaCu֐Ƃō\܂B2̃f[^^Ƃ́ACfbNXt@CɑΉsen_index^ƁA
ʂɑΉsen_records^łB

** Senna֐

 sen_rc sen_init(void);

Senna̋@\gpOɏ֐sen_init()vZXɈxĂяoKv܂B
(}`XbhAvP[V̏ꍇAꂩ̃XbhňxsΏ\łB)

 sen_rc sen_fin(void);

Senna̗p߂ꍇɌĂяo܂B

** sen_index ^

񂩂當Ɍ邽߂̓]uCfbNX()t@CɑΉf[^^łB
IDƕe()̃yAȂ镶o^ƁA
L[ƂāA܂ޕID̏WɎoƂł܂B
sen_index̃CX^X̓t@CVXe̓̃t@CɑΉĂAi[ꂽ͉iIɕۑ܂B
Asen_indexpāAIDɑΉ镶eoƂ͂ł܂B

IDɂ͌Œ蒷̃oCif[^AnulŏI[ϒ̕񂪎gpł܂B

̕ŕIDdĂ͂܂B

ő啶ID8191oCgłB

lɂnulŏI[ϒ̕w肵܂B

lɂ͍ő咷̐͂܂B

lɎw肷镶̃GR[fBÓASHIFT-JIS, EUC-japan, utf-8̂
ꂩIł܂B

lɎw肷镶́̕A`ԑf, N-gram̂ǂ炩Ił܂B

N-gramIꍇAp񂨂ыL𕶎vfɕ邩/Ȃ
Ił܂B

lɎw肷镶ɑ΂āAp̑啶/ASp/p̐K
s/sȂIł܂B

sen_indexCX^X𕡐̃XbhŋL邱Ƃł܂B

̓]uCfbNXt@C𕡐̃vZXœopen邱Ƃł܂B

rȂɍXV̎sƓɎQƑSɎs邱Ƃł܂B
(gUNVuĂ킯ł͂ȂAR~bg̃f[^
QƂꍇ܂B)

̃vZXȂXbh̃CfbNXɑ΂ēɍXV
s邱Ƃ͂ł܂B(ʓrr䂪KvɂȂ܂)

 sen_index *sen_index_create(const char *path, int key_size, int flags, int initial_n_segments, sen_encoding encoding);

pathŗ^ꂽV]uCfbNXt@C쐬A
Ήsen_indexCX^XԂ܂B
sꍇNULLԂ܂B

key_sizeɕID(oCg)^܂B
key_size0w肳ꂽꍇ͉ϒ(nulI[镶)w肳ꂽƂ݂Ȃ܂B

flagsɂ́Aȉflaggݍ킹Ďw肵܂B

: SEN_INDEX_NORMALIZE : p̑啶/ASp/p𐳋KăCfbNXɓo^
: SEN_INDEX_SPLIT_ALPHA : p𕶎vfɕ
: SEN_INDEX_SPLIT_DIGIT : 𕶎vfɕ
: SEN_INDEX_SPLIT_SYMBOL : L𕶎vfɕ
: SEN_INDEX_NGRAM : (`ԑf͂ł͂Ȃ)n-gramp
: SEN_INDEX_DELIMITED : (`ԑf͂ł͂Ȃ)󔒋؂ŒP؂

initial_n_segmentśAobt@TCY^܂B
initial_n_segments * 256Kbytes̗eʂCfbNXƂĊmۂ܂B
̐l(TCYzȂ͈͂)傫قǍXVɂȂ܂B

encodingɂ́Asen_enc_default, sen_enc_none, sen_enc_euc_jp,
sen_enc_utf8, sen_enc_sjis ̂ꂩw肵܂B

 sen_index *sen_index_open(const char *path);

pathŗ^ꂽɍ쐬ς̓]uCfbNXt@CJA
Ήsen_indexCX^XԂ܂B
sꍇNULLԂ܂B

 sen_rc sen_index_close(sen_index *index);

indexɑΉ]uCfbNXt@CA
sen_indexCX^X܂B
 sen_success As΃G[R[hԂ܂B

 sen_rc sen_index_remove(const char *path);

pathŗ^ꂽ]uCfbNXt@C폜܂B
 sen_success As΃G[R[hԂ܂B

 sen_rc sen_index_rename(const char *old_name, const char *new_name);

old_nameŗ^ꂽ]uCfbNXt@C̃t@CA
new_nameɕύX܂B
 sen_success As΃G[R[hԂ܂B

 sen_rc sen_index_upd(sen_index *index, const void *key, const char *oldvalue, const char *newvalue);

indexkeyɑΉ镶̒loldvaluenewvalueɍXV܂B

VKłꍇoldvalueNULLw肵܂B

폜ꍇnewvalueNULLw肵܂B

oldvalueɂ͑Oindexɓo^̒l𐳂w肷Kv܂B

 sen_records *sen_index_sel(sen_index *index, const char *string);

indexlstring܂ޕoAsen_recordsCX^XƂ
ĕԂ܂B

** sen_records ^

ʂƂĕԂ郌R[h̏WɈꎞIɊi[邽߂̃f[^^łB

R[hW̓̈̃R[hJgR[hƂĎQƂĂ܂B

 int sen_records_next(sen_records *r, void *keybuf, int bufsize, int *score);

\ł΃JgR[hi߂܂B
ꍇ̓JgR[hkeyAsꍇ0Ԃ܂B
ꍇ́A
keybufw肳Abufsizekeyȏł΁A
JgR[hkeykeybufɃRs[A
scoreNULLȊO̒lw肳ꂽꍇ̓JgR[h̃XRA*scoreɃZbg܂B

 sen_rc sen_records_rewind(sen_records *records);

JgR[hNA܂Bsen_records_rewind()s
sen_records_next()s΁A
ŏ̃R[h珇ԂɃR[hǂݏoƂł܂B

 int sen_records_curr_score(sen_records *records);

JgR[h̃XRA(NG[ɑ΂Kx)Ԃ܂B

 int sen_records_curr_key(sen_records *records, void *keybuf, int bufsize);

JgR[hkeyԂ܂B
JgR[h݂Ȃꍇ0Ԃ܂B

sen_index_sel(), sen_index_select(), sen_records_rewind()s
JgR[h݂͑܂Bsen_records_nextsKv܂B

recordsIuWFNgɊYindexkey_size0ȊOł΁A
JgR[h݂ꍇ̖߂l͏key_sizeƈv܂B

keybufNULLȊO̒lnAbufsizeJgR[hkeyȏł΁A
keybufɃJgR[hkeyRs[܂B

 int sen_records_nhits(sen_records *records);

recordsɊ܂܂郌R[h̐Ԃ܂B

 int sen_records_find(sen_records *records, const void *key);

recordskeyɑΉ郌R[h܂܂Ă邩ǂ𒲂ׂ܂B
Y郌R[h݂΁ÃR[h̃XRAԂ܂B

 sen_rc sen_records_close(sen_records *records);

recordsCX^X܂B

* advanced API

x̐xׂ̍s߂ advanced API gp܂B
advanced APIłsen_index^sen_records^ɉāACfbNX
o^镶i[sen_values^gp܂B

** sen_values ^

sen_values^́ACfbNXɓo^镶̓eɈꎞIɊi[邽߂̃f[^^łB
basic APIł́A̒l̓tbgȒP̕ƂĈ܂Aadvanced APIł́A̕𕡐̒ȉWƂĈƂł܂B܂Aꂼ̒íAقȂd݂̃XgƂĊǗł܂Bd݂Ƃ́Ał̕񂪋ĂxlŁA錟[hɑ΂āAd݂̑傫ݒ肳ꂽ̕Ƀ}b`̕Kx̂Ƃ݂ȂďʕtsƂł܂B

 sen_values *sen_values_open(void);

Vsen_valuesCX^X𐶐܂B

 sen_rc sen_values_close(sen_values *values);

sen_valuesCX^X܂B

 sen_rc sen_values_add(sen_values *values, const char *str, unsigned int weight);

valuesɏdݒlweightstrǉ܂B

** sen_records ^

advance APIł́Asen_records ɑ΂蕡Gȑ֐񋟂܂B

 sen_records *sen_records_open(sen_rec_unit record_unit, sen_rec_unit subrec_unit, unsigned int max_n_subrecs);

VrecordsCX^X𐶐܂Bbasic APIł͌ʂ͕łAadvanced APIłrecord_unitw肷邱ƂɂăR[h̒Pʂwł܂B܂AR[hɁẢʂ̒PʂŗL̃TuR[hi[邱Ƃł܂BTuR[h̒Pʂ́Asubrec_unitŎw肵܂B
record_unit, subrec_unit͈ȉ̂ꂩw肵܂B

: sen_rec_document : P
: sen_rec_section : iP
: sen_rec_position : oʒuP
: sen_rec_userdef : [U`lP(groupƂ̂ݗLł)
: sen_rec_none : TuR[hi[ȂƂw܂

max_n_subrecśAR[hɊi[TuR[h̍ő吔w肵܂B

 sen_records *sen_records_union(sen_records *a, sen_records *b);

records arecords b̘aWłrecordsԂ܂Bab͔j󂳂܂B
ab͓̃V{\𕶏IDƂCfbNX̌ʂłA
record_unitłȂ΂Ȃ܂B

 sen_records *sen_records_subtract(sen_records *a, sen_records *b);

records arecords b̍WłrecordsԂ܂Bab͔j󂳂܂B
ab͓̃V{\𕶏IDƂCfbNX̌ʂłA
record_unitłȂ΂Ȃ܂B

 sen_records *sen_records_intersect(sen_records *a, sen_records *b);

records arecords b̋ʏWłrecordsԂ܂Bab͔j󂳂܂B
ab͓̃V{\𕶏IDƂCfbNX̌ʂłA
record_unitłȂ΂Ȃ܂B

 int sen_records_difference(sen_records *a, sen_records *b);

records arecords b狤ʂɊ܂܂郌R[h菜܂BʂɊ܂܂ĂR[h̐Ԃ܂B
ab͓̃V{\𕶏IDƂCfbNX̌ʂłA
record_unitłȂ΂Ȃ܂B

 sen_rc sen_records_sort(sen_records *records, int limit, sen_sort_optarg *optarg);

records̃R[h\[gAlimit̗vfsen_records_next()ŏo悤ɂ܂B
optargw肷邱ƂɂA\[g̕@𑀍ł܂Bsen_sort_optarg̍\ȉɎ܂B

 struct _sen_sort_optarg {
   sen_sort_mode mode;
   int (*compar)(sen_records *, sen_recordh *, sen_recordh *, void *);
   void *compar_arg;
 };

modeɂ͈ȉ̂ꂩw肵܂B

: sen_sort_descending : ~
: sen_sort_ascending : 

R[obN֐compaŕAsen_records_sort()Ɏw肳ꂽrecordsA
AOɔrΏۂƂȂ̃R[hnhA
lcompar_argn܂Br֐́ÄÖɑ΂āA 1)A2)A3)傫Ȃ΁A 1)[A2)[A3)[傫̂ꂩԂȂ Ȃ܂B̗vfƂAבւrecordsɂA͖̏`łB

comparNULLw肳ꂽꍇ́AeR[h̃XRAlɂă\[g܂B

optargNULLw肳ꂽꍇ́Amodesen_sort_descendingAcomparNULLw肳ꂽ̂Ƃ݂Ȃ܂B

 sen_rc sen_records_group(sen_records *records, int limit, sen_group_optarg *optarg);

recordsrecord_unit傫ȗx̑傫ȒPʂɕύX܂BVrecord_unit̒lł镡̃R[h͈ɂ܂Ƃ߂ATuR[hƂĊi[܂Blimitɂ͐VȃR[h̃TuR[h̍őlw肵܂B
optargw肷邱ƂɂAO[v̕@𑀍ł܂Bsen_group_optarg̍\ȉɎ܂B

 struct _sen_group_optarg {
   sen_sort_mode mode;
   int (*func)(sen_records *, const sen_recordh *, void **, void *);
   void *func_arg;
   int key_size;
 };

modéAlimitȏ̂̃TuR[h݂ꍇɁAۑΏۂƂTuR[hIяow肵܂B

R[obN֐funcw肷邱ƂɂāAPʁEiPʁEoʒuPʂ̂łȂA[U̒`O[vL[PʂŃR[h܂Ƃ߂邱Ƃł܂BfunćAsen_records_group()Ɏw肳ꂽrecordsAɃR[hnhAOɃO[ṽL[i[obt@Alfunc_argn܂Bfunc̖߂l0ȊOł΁AYR[ĥ͎Ă܂Bfunc̓R[h̓eɊÂkey_sizeoCg̃O[vL[ZoAobt@Ɋi[Ȃ΂Ȃ܂B

 const sen_recordh * sen_records_curr_rec(sen_records *r);

JgR[h̃R[hnhԂ܂B

 const sen_recordh *sen_records_at(sen_records *records, const void *key, unsigned section, unsigned pos, int *score, int *n_subrecs);

records̒AIDkeyŒiԍsectionŏoʒuposł郌R[hÃR[hnhԂ܂Bscore, n_subrecsw肳ꂽꍇ́AY郌R[h̃XRAATuR[hԂ܂B

 sen_rc sen_record_info(sen_records *r, const sen_recordh *rh,
		        void *keybuf, int bufsize, int *keysize,
		        int *section, int *pos, int *score, int *n_subrecs);

records̃R[hrhɊY鑮oA
keybufw肳AbufsizekeyȏłkeybufkeyRs[A
section, pos, score, n_subrecsw肳Ă΁A
ZNVԍAʒuAXRAATuR[hꂼZbg܂B

 sen_rc sen_record_subrec_info(sen_records *r, const sen_recordh *rh, int index,
			       void *keybuf, int bufsize, int *keysize,
			       int *section, int *pos, int *score);

records̃R[hrh́AindexԖڂ̃TuR[h̑oA
keybufw肳AbufsizekeyȏłkeybufkeyRs[A
section, pos, scorew肳Ă΁A
ZNVԍAʒuAXRAꂼZbg܂B

** sen_index ^

advance APIł́Asen_index ɑ΂蕡Gȑ֐񋟂܂B

 sen_index *sen_index_create_with_keys(const char *path, sen_sym *keys,
			     int flags, int initial_n_segments, sen_encoding encoding);

sen_index_createƓlpathŗ^ꂽV]uCfbNXt@C쐬AΉsen_indexCX^XԂ܂AIDǗV{\keysɊsen_symCX^Xw肷邱Ƃł܂B

 sen_index *sen_index_open_with_keys(const char *path, sen_sym *keys);

sen_index_openƓlpathŗ^ꂽɍ쐬ς̓]uCfbNXt@CJAΉsen_indexCX^XԂ܂AIDǗV{\keysɊsen_symCX^Xw肷邱Ƃł܂B

 sen_rc sen_index_update(sen_index *index, const void *key, unsigned int section, sen_values *oldvalue, sen_values *newvalue);

keyɊY镶sectionԖڂ̒i̓eoldvaluenewvalueɍXV܂B

 sen_rc sen_index_select(sen_index *index, const char *string, sen_records *records, sen_sel_operator op, sen_select_optarg *optarg);

indexstringɃ}b`镶AZqopɏ]recordsɌʂ𔽉f܂B
Zqop͈ȉ̂ꂩw肵܂B

: sen_sel_or : stringɃ}b`郌R[hrecordsɒǉ܂B
: sen_sel_and : stringɃ}b`ȂR[hrecords폜܂B
: sen_sel_but : stringɃ}b`郌R[hrecords폜܂B
: sen_sel_adjust : stringɃ}b`郌R[hrecordsɌX܂܂Ăꍇɂ̃XRAlZ܂B

܂Aoptargw肷邱ƂɂAindexstringɃ}b`郌R[h铮𐧌ł܂Bsen_select_optarg̍\ȉɎ܂B

 struct _sen_select_optarg {
   sen_sel_mode mode;
   int similarity_threshold;
   int max_interval;
   int *weight_vector;
   int vector_size;
   int (*func)(sen_records *, const void *, int, void *);
   void *func_arg;
 };

modeɂ͈ȉ̂ꂩw肵܂B

: sen_sel_exact : stringꋫEƈvČ郌R[ĥ݂܂
: sen_sel_partial : string̗̈ꕔƕv郌R[h܂
: sen_sel_unsplit : string킩Ɍ̈ꕔɈv郌R[h܂
: sen_sel_near : string킩eꂪmax_interval͈͓̔Ɍ郌R[h܂
: sen_sel_similar : string킩̂Aidfl傫similarity_threshold̌̂ꂩ܂ރR[h܂B

optargNULLw肳ꂽꍇ́Asen_sel_exactw肳ꂽƂ݂Ȃ܂B

̒i\ꍇA̒iΏۂƂAXRAグ肷邽߂ɁAweight_vectorp܂Bweight_vectorint̔zw肵Az̑傫vector_sizeɎw肷ƁAstringꂽi(1x[X)ɑΉz̗vf̒lXRAlɏZ܂Bl0łꍇ́AΉi͌Ώۂ珜O܂B

ɂĒiweightقȂꍇɂ́AR[obN֐funcw肵܂B
stringɃ}b`郌R[hxɁArecords, ID, iԍ, func_arg
ƂăR[obN֐funcĂяoA̖߂lweightƂăXRAlZo܂B

 sen_rc sen_index_info(sen_index *index, int *key_size, int *flags, int *initial_n_segments, sen_encoding *encoding);

indexcreateꂽɎw肳ꂽkey_size, flags, initial_n_segments,
encoding̒l擾Aꂼ̈̎QƂAhXɊi[܂B
AOAlA܈NULLw肳ꂽꍇ́Ä͖Ali[܂B

 sen_set * sen_index_related_terms(sen_index *index, const char *string,	const char *(*fetcher)(void *, void *), void *fetcher_arg);

stringɎw肳ꂽƊ֘AP𒊏oAindex->lexiconidL[Ƃsen_setIuWFNgɊi[ĕԂ܂BfetcheŕAindex̃L[Afetcher_argw肵ČĂ΂ƁA̓e𕶎ƂĕԂ֐w肵Ȃ΂Ȃ܂B

** sen_query

sen_querýA܂܂ȏŎw肳ꂽNGi[f[^^łB

 sen_query *sen_query_open(const char *str, sen_sel_operator default_op,
                           int max_exprs, sen_encoding encoding);

Vsen_queryCX^X𐶐܂B
strɏtNGw肵܂B

default_opɁA
Zq̊l(Zqȗꍇɂǂ̉Zs)w肵܂B
ȉ̂ꂩ̒lw肵܂B

: sen_sel_or : Zq̋Kl'or'Ƃ܂iftHgj
: sen_sel_and : Zq̋Kl'and'Ƃ܂iʏ̌GWł̌NGƓgpłj
: sen_sel_but : Zq̋Kl'-'Ƃ܂
: sen_sel_adjust : Zq̋Kl'>'Ƃ܂

max_exprsɁANGɎw肷鎮̍őlw肵܂B

encodingɁANG̕R[hA
sen_enc_default, sen_enc_none, sen_enc_euc_jp,
sen_enc_utf8, sen_enc_sjis ̂ꂩŎw肵܂B

 const char *sen_query_rest(sen_query *q);

sen_query_openĂяoɁAĎ󂯕tȂ̌NGԂ܂B

 sen_rc sen_query_exec(sen_index *i, sen_query *q, sen_records *r, sen_sel_operator op);

w肵sen_indexɑ΂āAsen_query̏ŌsAʂwsen_recordsɔf܂B

Zqop͈ȉ̂ꂩw肵܂B

: sen_sel_or : Ƀ}b`郌R[hrɒǉ܂B
: sen_sel_and : Ƀ}b`ȂR[hr폜܂B
: sen_sel_but : Ƀ}b`郌R[hr폜܂B
: sen_sel_adjust : Ƀ}b`郌R[hrɌX܂܂Ăꍇɂ̃XRAlZ܂B

** sen_index
 sen_rc sen_index_del(sen_index *i, const void *key);

w肵sen_indexkeyɑΉ镶ɍ폜tO𗧂āAΏۂO܂B
ʏsen_index_updpč폜sĂB

* low-level API

low-level APIp邱ƂɂSenna̓̃f[^\ɃANZXAɕGȃf[^̑⌟ł܂B
low-level APIł́AiIȃV{\

** sen_set

L[ƒl̃yAȂ郌R[h̏Wōɑ삷邽߂̃f[^^łB
ʂ̏WAb̏W𑀍삷̂Ɏgp܂B(sen_records^sen_sethf[^^ł)
sen_set̓L[d̃R[hi[邱Ƃ͂ł܂B

 sen_set *sen_set_open(unsigned key_size, unsigned value_size, unsigned index_size);

Vsen_setCX^X𐶐܂B
key_sizeɃL[Avalue_sizeɒl̒w肵܂B
index_sizeɂ͏Ԃł̃obt@̃TCYw肵܂B
key_size0w肳ꂽꍇ͉ϒ(nulI[镶)w肳ꂽƂ݂Ȃ܂B
value_size0w肳ꂽꍇ́Ali[̈mۂ܂B

 sen_rc sen_set_close(sen_set *set);

sen_setCX^X܂B

 sen_rc sen_set_info(sen_set *set, unsigned *key_size, unsigned *value_size, unsigned *n_entries);

setCX^X𐶐Ɏw肵key_size, value_sizeAъi[Ă郌R[h̐擾܂BAOAlNULLw肳ꂽꍇ́Ä͖Ali[܂B

 sen_set_eh *sen_set_get(sen_set *set, const void *key, void **value);

setɁAkeyɊY郌R[ho^AR[hւ̃nhԂ܂B
valueɂ̓R[h̒lɊY|C^Ԃ܂̂ŁA
ĒlQ/XVł܂B

 sen_set_eh *sen_set_at(sen_set *set, const void *key, void **value);

setAkeyɊY郌R[hAR[hւ̃nhԂ܂B
YL[݂ȂꍇNULLԂ܂B
valueɂ̓R[h̒lɊY|C^Ԃ܂̂ŁA
ĒlQ/XVł܂B

 sen_rc sen_set_del(sen_set *set, sen_set_eh *eh);

ehɎw肵R[hnhɊY郌R[hset폜܂B

 sen_set_cursor *sen_set_cursor_open(sen_set *set);

setɓo^Ă郌R[hԂɎo߂̃J[\𐶐܂B

 sen_set_eh *sen_set_cursor_next(sen_set_cursor *cursor, void **key, void **value);

cursorɏ]set玟̃R[hoAR[hւ̃nhԂ܂B
AONULLȊÕ|C^nƁAkeyɂ̓R[h̃L[ɊY|C^valueɂ̓R[h̒lɊY|C^Ԃ܂B

 sen_rc sen_set_cursor_close(sen_set_cursor *cursor);

cursorCX^X܂B

 sen_rc sen_set_element_info(sen_set *set, const sen_set_eh *eh, void **key, void **value);

setɊ܂܂郌R[hnhehɑΉ郌R[h́AL[ւ̃|C^keyɁAlւ̃|C^valueɃZbg܂BOAlNULLw肳ꂽꍇ́Ä͖Ali[܂B

 sen_set *sen_set_union(sen_set *a, sen_set *b);

2set̘aWƂȂsetԂ܂B̊֐ďoɂa, b͉܂B
L[̃R[ha, b̗Ɋ܂܂Ăꍇ́AaɊ܂܂ĂR[h
lp܂B

 sen_set *sen_set_subtract(sen_set *a, sen_set *b);

2set̍WƂȂsetԂ܂B̊֐ďoɂa, b͉܂B

 sen_set *sen_set_intersect(sen_set *a, sen_set *b);

2set̗ɓ̃L[݂郌R[hȂsetԂ܂B
̊֐ďoɂa, b͉܂B
Ԃlset̃R[h̒lɂ́AaɊ܂܂ĂR[h̒lp܂B

 int sen_set_difference(sen_set *a, sen_set *b);

set aset b狤ʂɊ܂܂郌R[h菜܂BʂɊ܂܂ĂR[h̐Ԃ܂B

 sen_set_eh *sen_set_sort(sen_set *set, int limit, sen_set_sort_optarg *optarg);

set̃R[h\[gAlimit̃R[hnh̔zԂ܂B
optargw肷邱ƂɂA\[g̕@𑀍ł܂Bsen_sort_optarg̍\ȉɎ܂B߂l̔z͌ĂяofreeɂĉȂ΂Ȃ܂B

 struct _sen_set_sort_optarg {
   sen_sort_mode mode;
   int (*compar)(sen_set *, sen_set_eh *, sen_set_eh *, void *);
   void *compar_arg;
   sen_set *compar_arg0;
 };

R[obN֐compaŕAcompar_arg0A
AOɔrΏۂƂȂ̃R[hnhA
lcompar_argn܂Br֐́ÄÖɑ΂āA 1)A2)A3)傫Ȃ΁A 1)[A2)[A3)[傫̂ꂩԂȂ Ȃ܂B̗vfƂAבւʂɂA͖̏`łB

comparNULLw肳ꂽꍇɂ́AR[h̒l̐擪4byteuint32Ƃ݂ȂA~Ƀ\[g܂B

compar_arg0NULLw肳ꂽꍇɂ́Asen_set_sort()̑Ɏw肳ꂽsetcomparɓn܂B

optargNULLw肳ꂽꍇɂ́Amodesen_sort_descendingAcomparNULLw肳ꂽ̂Ƃ݂Ȃ܂B

** sen_sym

Œ蒷̃oCif[^nulŏI[ϒ̕ɈӂȔԍ蓖ĂV{\t@CɑΉf[^^łB
sen_sym̃CX^X̓t@CVXe̓̃t@CɑΉĂAi[ꂽ͉iIɕۑ܂B

Ȃsen_indexCX^X2sym_symCX^X܂ł܂B

: keys : IDƃR[hIDƂΉt
: lexicon : ̓e𕪂bƌbIDƂΉt

 sen_sym * sen_sym_create(const char *path, unsigned key_size, unsigned flags, sen_encoding encoding);

pathŗ^ꂽVV{\t@C쐬AΉsen_symCX^XԂ܂BsꍇNULLԂ܂B

key_sizeɃL[(oCg)^܂Bkey_size0w肳ꂽꍇ͉ϒ(nulI[镶)w肳ꂽƂ݂Ȃ܂B

flags SEN_SYM_WITH_SIS w肵ꍇ́Ao^ꂽL[ɑ΂v
\ɂȂ܂B

encodingɂ́Asen_enc_default, sen_enc_none, sen_enc_euc_jp,
sen_enc_utf8, sen_enc_sjis ̂ꂩw肵܂B

 sen_sym * sen_sym_open(const char *path);

pathŗ^ꂽɍ쐬ς̃V{\t@CJAΉsen_symCX^XԂ܂BsꍇNULLԂ܂B

 sen_rc sen_sym_info(sen_sym *sym, int *key_size, unsigned *flags, sen_encoding *encoding, unsigned *nrecords);

symCX^X𐶐Ɏw肵key_size, flags, encodingAъi[Ă郌R[h̐擾܂BAOAlA܈NULLw肳ꂽꍇ́Ä͖Ali[܂B

 sen_rc sen_sym_close(sen_sym *sym);

symɑΉV{\t@CAsen_symCX^X܂B
 sen_success As΃G[R[hԂ܂B

 sen_rc sen_sym_remove(const char *path);

pathŗ^ꂽV{\t@C폜܂B sen_success As΃G[R[hԂ܂B

 sen_id sen_sym_get(sen_sym *sym, const unsigned char *key);

V{\symkeyo^AΉIDԂ܂B

 sen_id sen_sym_at(sen_sym *sym, const unsigned char *key);

V{\symkeyɑΉIDԂ܂Bo^łꍇ SEN_SYM_NIL Ԃ܂B

 sen_rc sen_sym_del(sen_sym *sym, const unsigned char *key);

V{\symkey폜܂B

 unsigned int sen_sym_size(sen_sym *sym);

V{\symɊ܂܂L[̐Ԃ܂B

 int sen_sym_key(sen_sym *sym, sen_id id, unsigned char *keybuf, int bufsize);

V{\symIDɑΉL[Ԃ܂B
ΉL[ꍇkeyԂ܂B
Ȃꍇ0Ԃ܂B
ΉL[̌ɐA
܂keybufw肳Abufsize̒keyȏłꍇ́A
keybufɊYkeyRs[ĕԂ܂B

 sen_set * sen_sym_prefix_search(sen_sym *sym, const unsigned char *key);

keyɑOvSẴGg𒊏oAIDL[Ƃsen_setCX^XԂ܂B

 sen_set * sen_sym_suffix_search(sen_sym *sym, const unsigned char *key);

keyɌvSẴGg𒊏oAIDL[Ƃsen_setCX^XԂ܂B(sym쐬SEN_SYM_WITH_SISw肵ꍇ̂ݗLł)

 sen_id sen_sym_common_prefix_search(sen_sym *sym, const unsigned char *key);

keyƃL[񂪍łOvGgAIDԂ܂B

 int sen_sym_pocket_get(sen_sym *sym, sen_id id);

sen_sym̎wID̃GgɊi[ꂽo܂B

 sen_rc sen_sym_pocket_set(sen_sym *sym, sen_id id, unsigned int value);

sen_sym̎wID̃Ggvaluei[܂B

 sen_id sen_sym_next(sen_sym *sym, sen_id id);

sen_sym̎wID̎̃GgIDԂ܂B

* snippet API

snippet(KWIC)쐬邽߂APIB

 sen_snip *sen_snip_open(sen_encoding encoding, int flags, size_t width, unsigned int max_results,
                         const char *defaultopentag, const char *defaultclosetag,
                         sen_snip_mapping *mapping);

Vsen_snipCX^X𐶐܂B

encodingɂ́Asen_enc_default, sen_enc_none, sen_enc_euc_jp, sen_enc_utf8, sen_enc_sjis ̂ꂩw肵܂B

flagsɂ́ASEN_SNIP_NORMALIZE(KČs)wł܂B

width́Asnippet̕oCgŎw肵܂Beucsjis̏ꍇɂ͂̔Autf-8̏ꍇɂ͂1/3̒̓{ꂪi[łł傤B

max_resultśAsnippeťw肵܂B

defaultopentaǵAsnippeťP̑Oɂ镶w肵܂B

defaultclosetaǵAsnippeťP̌ɂ镶w肵܂B

mappinǵA(݂)NULL-1w肵ĂB-1w肷ƁAHTML̃^GR[hsnippeto͂܂B

''defaultopentag,defaultclosetag̎wéAsen_snip_closeĂԂ܂ŕύXȂłB''

 sen_rc sen_snip_close(sen_snip *snip);

sen_snipCX^Xj܂B

 sen_rc sen_snip_add_cond(sen_snip *snip, const char *keyword,
                          const char *opentag, const char *closetag);

Ώۂ̒PƁA̒P̑Oɕt^镶w肵܂B

snipɂ́Asen_snip_openŐsen_snipCX^Xw肵܂B

keyword́AΏۂ̒Pw肵܂B

opentaǵAsnippeťP̑Oɂ镶w肵܂B
NULLw肵ꍇɂ́Asen_snip_openŎw肵defaultopentaggp܂B

closetaǵAsnippeťP̌ɂ镶w肵܂B
NULLw肵ꍇɂ́Asen_snip_openŎw肵defaultclosetaggp܂B

''opentag,closetag̎wéAsen_snip_closeĂԂ܂ŕύXȂłB''

 sen_rc sen_snip_exec(sen_snip *snip, const char *string, unsigned int *nresults,
                      size_t *max_tagged_len);

Ώۂ̒PAsnippet𐶐܂B

snipɂ́Asen_snip_openŐsen_snipCX^Xw肵܂B

stringɂ́Asnippet𐶐Ώۂ̕w肵܂B

nresultsɂ́Asnippetۂɐłi[܂B

max_tagged_lenɂ́Aꂽsnippet̂AԒsnippet̃i܂߂i[܂B

 sen_rc sen_snip_get_result(sen_snip *snip, const unsigned int index, char *result);

sen_snip_execŐsnippeto܂B

index́Asnippet0͂܂CfbNXw肵܂B

resultɂ́Asnippet̕񂪊i[܂B
