xapian-bindings/python/util.i

   1 %{
   2 /* python/util.i: custom Python typemaps for xapian-bindings
   3  *
   4  * Copyright (C) 1999,2000,2001 BrightStation PLC
   5  * Copyright (C) 2002 Ananova Ltd
   6  * Copyright (C) 2002,2003 James Aylett
   7  * Copyright (C) 2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2013,2017 Olly Betts
   8  * Copyright (C) 2007 Lemur Consulting Ltd
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation; either version 2 of the
  13  * License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
  23  * USA
  24  */
  25 %}
  26
  27 %include typemaps.i
  28 %include stl.i
  29
  30 /* Wrap get_description() methods as str(). */
  31 %rename(__str__) get_description;
  32
  33 /* Hide "unsafe" C++ iterator methods. */
  34 %rename(_allterms_begin) Xapian::Database::allterms_begin;
  35 %rename(_allterms_end) Xapian::Database::allterms_end;
  36 %rename(_metadata_keys_begin) Xapian::Database::metadata_keys_begin;
  37 %rename(_metadata_keys_end) Xapian::Database::metadata_keys_end;
  38 %rename(_synonym_keys_begin) Xapian::Database::synonym_keys_begin;
  39 %rename(_synonym_keys_end) Xapian::Database::synonym_keys_end;
  40 %rename(_synonyms_begin) Xapian::Database::synonyms_begin;
  41 %rename(_synonyms_end) Xapian::Database::synonyms_end;
  42 %rename(_spellings_begin) Xapian::Database::spellings_begin;
  43 %rename(_spellings_end) Xapian::Database::spellings_end;
  44 %rename(_positionlist_begin) Xapian::Database::positionlist_begin;
  45 %rename(_positionlist_end) Xapian::Database::positionlist_end;
  46 %rename(_postlist_begin) Xapian::Database::postlist_begin;
  47 %rename(_postlist_end) Xapian::Database::postlist_end;
  48 %rename(_termlist_begin) Xapian::Database::termlist_begin;
  49 %rename(_termlist_end) Xapian::Database::termlist_end;
  50 %rename(_termlist_begin) Xapian::Document::termlist_begin;
  51 %rename(_termlist_end) Xapian::Document::termlist_end;
  52 %rename(_values_begin) Xapian::Document::values_begin;
  53 %rename(_values_end) Xapian::Document::values_end;
  54 %rename(_get_matching_terms_begin) Xapian::Enquire::get_matching_terms_begin;
  55 %rename(_get_matching_terms_end) Xapian::Enquire::get_matching_terms_end;
  56 %rename(_begin) Xapian::ESet::begin;
  57 %rename(_end) Xapian::ESet::end;
  58 %rename(_begin) Xapian::MSet::begin;
  59 %rename(_end) Xapian::MSet::end;
  60 %rename(_positionlist_begin) Xapian::PostingIterator::positionlist_begin;
  61 %rename(_positionlist_end) Xapian::PostingIterator::positionlist_end;
  62 %rename(_get_terms_begin) Xapian::Query::get_terms_begin;
  63 %rename(_get_terms_end) Xapian::Query::get_terms_end;
  64 %rename(_stoplist_begin) Xapian::QueryParser::stoplist_begin;
  65 %rename(_stoplist_end) Xapian::QueryParser::stoplist_end;
  66 %rename(_unstem_begin) Xapian::QueryParser::unstem_begin;
  67 %rename(_unstem_end) Xapian::QueryParser::unstem_end;
  68 %rename(_positionlist_begin) Xapian::TermIterator::positionlist_begin;
  69 %rename(_positionlist_end) Xapian::TermIterator::positionlist_end;
  70
  71 /* We replace the get_hit() method with one which returns an MSetitem. */
  72 %rename(_get_hit_internal) Xapian::MSet::get_hit;
  73
  74 %{
  75 namespace Xapian {
  76     Query *get_py_query(PyObject *obj) {
  77         PyObject * mythis = PyObject_GetAttrString(obj, "this");
  78         if (!mythis)
  79             return 0;
  80
  81         Query * retval = 0;
  82         int res = SWIG_ConvertPtr(mythis, (void **)&retval,
  83                                   SWIGTYPE_p_Xapian__Query, 0);
  84         if (!SWIG_IsOK(res)) {
  85             retval = 0;
  86         }
  87         Py_DECREF(mythis);
  88         return retval;
  89     }
  90 }
  91 %}
  92
  93 %typedef PyObject *LangSpecificListType;
  94
  95 %inline %{
  96 #define MSET_DID 0
  97 #define MSET_WT 1
  98 #define MSET_RANK 2
  99 #define MSET_PERCENT 3
 100 #define MSET_DOCUMENT 4
 101
 102 #define ESET_TNAME 0
 103 #define ESET_WT 1
 104 %}
 105
 106 %feature("nothread") Xapian::MSet::items;
 107 %{
 108 /* The GIL must be held when this is called. */
 109 PyObject *Xapian_MSet_items_get(Xapian::MSet *mset)
 110 {
 111     PyObject *retval = PyList_New(mset->size());
 112     if (retval == 0) {
 113         return NULL;
 114     }
 115
 116     Py_ssize_t idx = 0;
 117     for (Xapian::MSetIterator i = mset->begin(); i != mset->end(); ++i) {
 118         PyObject *t = PyTuple_New(4);
 119         if (!t) {
 120             Py_DECREF(retval);
 121             return NULL;
 122         }
 123
 124         PyList_SET_ITEM(retval, idx++, t);
 125
 126         PyTuple_SET_ITEM(t, MSET_DID, PyInt_FromLong(*i));
 127         PyTuple_SET_ITEM(t, MSET_WT, PyFloat_FromDouble(i.get_weight()));
 128         PyTuple_SET_ITEM(t, MSET_RANK, PyInt_FromLong(i.get_rank()));
 129         PyTuple_SET_ITEM(t, MSET_PERCENT, PyInt_FromLong(i.get_percent()));
 130     }
 131     return retval;
 132 }
 133 %}
 134
 135 %feature("nothread") Xapian::ESet::items;
 136 %{
 137 /* The GIL must be held when this is called. */
 138 PyObject *Xapian_ESet_items_get(Xapian::ESet *eset)
 139 {
 140     PyObject *retval = PyList_New(eset->size());
 141     if (retval == 0) {
 142         return NULL;
 143     }
 144
 145     Py_ssize_t idx = 0;
 146     for (Xapian::ESetIterator i = eset->begin(); i != eset->end(); ++i) {
 147         PyObject *t = PyTuple_New(2);
 148         if (!t) {
 149             Py_DECREF(retval);
 150             return NULL;
 151         }
 152
 153         PyList_SET_ITEM(retval, idx++, t);
 154
 155         PyObject * str = PyString_FromStringAndSize((*i).data(), (*i).size());
 156         if (str == 0) {
 157             Py_DECREF(retval);
 158             return NULL;
 159         }
 160
 161         PyTuple_SET_ITEM(t, ESET_TNAME, str);
 162         PyTuple_SET_ITEM(t, ESET_WT, PyFloat_FromDouble(i.get_weight()));
 163     }
 164     return retval;
 165 }
 166 %}
 167
 168 namespace Xapian {
 169     %extend TermIterator {
 170         bool __eq__(const TermIterator &other) {
 171             return (*self)==other;
 172         }
 173         bool __ne__(const TermIterator &other) {
 174             return (*self)!=other;
 175         }
 176     }
 177     %rename(_TermIterator) TermIterator;
 178
 179     %extend PositionIterator {
 180         bool __eq__(const PositionIterator &other) {
 181             return (*self)==other;
 182         }
 183         bool __ne__(const PositionIterator &other) {
 184             return (*self)!=other;
 185         }
 186     }
 187     %rename(_PositionIterator) PositionIterator;
 188
 189     %extend PostingIterator {
 190         bool __eq__(const PostingIterator &other) {
 191             return (*self)==other;
 192         }
 193         bool __ne__(const PostingIterator &other) {
 194             return (*self)!=other;
 195         }
 196     }
 197     %rename(_PostingIterator) PostingIterator;
 198
 199     %extend ValueIterator {
 200         bool __eq__(const ValueIterator &other) {
 201             return (*self)==other;
 202         }
 203         bool __ne__(const ValueIterator &other) {
 204             return (*self)!=other;
 205         }
 206     }
 207     %rename(_ValueIterator) ValueIterator;
 208
 209     %extend MSetIterator {
 210         bool __eq__(const MSetIterator &other) {
 211             return (*self)==other;
 212         }
 213         bool __ne__(const MSetIterator &other) {
 214             return (*self)!=other;
 215         }
 216     }
 217     %rename(_MSetIterator) MSetIterator;
 218
 219     %extend ESetIterator {
 220         bool __eq__(const ESetIterator &other) {
 221             return (*self)==other;
 222         }
 223         bool __ne__(const ESetIterator &other) {
 224             return (*self)!=other;
 225         }
 226     }
 227     %rename(_ESetIterator) ESetIterator;
 228
 229     %extend MSet {
 230         %immutable;
 231         // access to the items array
 232         PyObject *items;
 233         %mutable;
 234
 235         // for comparison
 236         int __cmp__(const MSet &other) {
 237             if (self->get_max_possible() != other.get_max_possible()) {
 238                 return (self->get_max_possible() < other.get_max_possible())? -1 : 1;
 239             }
 240             if (self->size() != other.size()) {
 241                 return (self->size() < other.size())? -1 : 1;
 242             }
 243
 244             for (size_t i=0; i<self->size(); ++i) {
 245                 if (*(*self)[i] != *other[i]) {
 246                     return (*(*self)[i] < *other[i])? -1 : 1;
 247                 }
 248                 if ((*self)[i].get_weight() != other[i].get_weight()) {
 249                     return ((*self)[i].get_weight() < other[i].get_weight())? -1 : 1;
 250                 }
 251             }
 252             return 0;
 253         }
 254     }
 255
 256     //%apply LangSpecificListType items { PyObject *items }
 257
 258     %extend ESet {
 259         %immutable;
 260         PyObject *items;
 261         %mutable;
 262     }
 263 }
 264
 265 %fragment("XapianSWIG_anystring_as_ptr", "header", fragment="SWIG_AsPtr_std_string") {
 266 /* Utility function which works like SWIG_AsPtr_std_string, but
 267  * converts unicode strings to UTF-8 simple strings first. */
 268 static int
 269 XapianSWIG_anystring_as_ptr(PyObject * obj, std::string **val)
 270 {
 271     if (PyUnicode_Check(obj)) {
 272         PyObject * strobj = PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(obj), PyUnicode_GET_SIZE(obj), "ignore");
 273         if (strobj == NULL) return SWIG_ERROR;
 274         int res = SWIG_AsPtr_std_string(strobj, val);
 275         Py_DECREF(strobj);
 276         return res;
 277     } else {
 278         return SWIG_AsPtr_std_string(obj, val);
 279     }
 280 }
 281 }
 282
 283 /* These typemaps depends somewhat heavily on the internals of SWIG, so
 284  * might break with future versions of SWIG.
 285  */
 286 %typemap(in, fragment="XapianSWIG_anystring_as_ptr") const std::string &(int res = SWIG_OLDOBJ) {
 287     std::string *ptr = (std::string *)0;
 288     res = XapianSWIG_anystring_as_ptr($input, &ptr);
 289     if (!SWIG_IsOK(res)) {
 290         %argument_fail(res, "$type", $symname, $argnum);
 291     }
 292     if (!ptr) {
 293         %argument_nullref("$type", $symname, $argnum);
 294     }
 295     $1 = ptr;
 296 }
 297 %typemap(in, fragment="XapianSWIG_anystring_as_ptr") std::string {
 298     std::string *ptr = (std::string *)0;
 299     int res = XapianSWIG_anystring_as_ptr($input, &ptr);
 300     if (!SWIG_IsOK(res) || !ptr) {
 301         %argument_fail((ptr ? res : SWIG_TypeError), "$type", $symname, $argnum);
 302     }
 303     $1 = *ptr;
 304     if (SWIG_IsNewObj(res)) delete ptr;
 305 }
 306 %typemap(freearg, noblock=1, match="in") const std::string & {
 307     if (SWIG_IsNewObj(res$argnum)) %delete($1);
 308 }
 309 %typemap(typecheck, noblock=1, precedence=900, fragment="XapianSWIG_anystring_as_ptr") const std::string & {
 310     int res = XapianSWIG_anystring_as_ptr($input, (std::string**)(0));
 311     $1 = SWIG_CheckState(res);
 312 }
 313
 314 %typemap(in, fragment="XapianSWIG_anystring_as_ptr") const std::string *(int res = SWIG_OLDOBJ) {
 315     std::string *ptr = (std::string *)0;
 316     if ($input != Py_None) {
 317         res = XapianSWIG_anystring_as_ptr($input, &ptr);
 318         if (!SWIG_IsOK(res)) {
 319             %argument_fail(res, "$type", $symname, $argnum);
 320         }
 321     }
 322     $1 = ptr;
 323 }
 324 %typemap(freearg, noblock=1, match="in") const std::string * {
 325     if (SWIG_IsNewObj(res$argnum)) %delete($1);
 326 }
 327 %typemap(typecheck, noblock=1, precedence=900, fragment="XapianSWIG_anystring_as_ptr") const std::string * {
 328     if ($input == Py_None) {
 329         $1 = 1;
 330     } else {
 331         int res = XapianSWIG_anystring_as_ptr($input, (std::string**)(0));
 332         $1 = SWIG_CheckState(res);
 333     }
 334 }
 335
 336 /* This typemap is only currently needed for returning a value from the
 337  * get_description() method of a Stopper subclass to a C++ caller, but might be
 338  * more generally useful in future.
 339  */
 340 %typemap(directorout, noblock=1, fragment="XapianSWIG_anystring_as_ptr") std::string {
 341     std::string *swig_optr = 0;
 342     int swig_ores;
 343     {
 344         PyObject * tmp = $input;
 345         Py_INCREF(tmp);
 346         swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
 347         Py_DECREF(tmp);
 348     }
 349     if (!SWIG_IsOK(swig_ores) || !swig_optr) {
 350         %dirout_fail((swig_optr ? swig_ores : SWIG_TypeError), "$type");
 351     }
 352     $result = *swig_optr;
 353     if (SWIG_IsNewObj(swig_ores)) %delete(swig_optr);
 354 }
 355
 356 /** This pair of typemaps implements conversion of the return value of
 357  *  ValueRangeProcessor subclasses implemented in Python from a tuple of
 358  *  (valueno, begin, end) to a return value of valueno, and assigning the new
 359  *  values of begin and end to the parameters.
 360  */
 361 %typemap(directorin,noblock=1) std::string & {
 362     $input = SWIG_From_std_string(static_cast< std::string >($1_name));
 363 }
 364 %typemap(directorout,noblock=1) Xapian::valueno {
 365     if (!PyTuple_Check($input)) {
 366         %dirout_fail(SWIG_TypeError, "($type, std::string, std::string)");
 367     }
 368     if (PyTuple_Size($input) != 3) {
 369         %dirout_fail(SWIG_IndexError, "($type, std::string, std::string)");
 370     }
 371
 372     // Set the return value from the first item of the tuple.
 373     unsigned int swig_val;
 374     int swig_res = SWIG_AsVal_unsigned_SS_int(PyTuple_GET_ITEM((PyObject *)$input, 0), &swig_val);
 375     if (!SWIG_IsOK(swig_res)) {
 376         %dirout_fail(swig_res, "($type, std::string, std::string)");
 377     }
 378     c_result = static_cast< Xapian::valueno >(swig_val);
 379
 380     // Set "begin" from the second item of the tuple.
 381     std::string *ptr = (std::string *)0;
 382     swig_res = SWIG_AsPtr_std_string(PyTuple_GET_ITEM((PyObject *)$input, 1), &ptr);
 383     if (!SWIG_IsOK(swig_res) || !ptr) {
 384         delete ptr;
 385         ptr = (std::string *)0;
 386         %dirout_fail((ptr ? swig_res : SWIG_TypeError), "($type, std::string, std::string)");
 387     }
 388     begin = *ptr;
 389     delete ptr;
 390     ptr = (std::string *)0;
 391
 392     // Set "end" from the third item of the tuple.
 393     swig_res = SWIG_AsPtr_std_string(PyTuple_GET_ITEM((PyObject *)$input, 2), &ptr);
 394     if (!SWIG_IsOK(swig_res) || !ptr) {
 395         delete ptr;
 396         ptr = (std::string *)0;
 397         %dirout_fail((ptr ? swig_res : SWIG_TypeError), "($type, std::string, std::string)");
 398     }
 399     end = *ptr;
 400     delete ptr;
 401     ptr = (std::string *)0;
 402 }
 403
 404 /* These typemaps handle ValueRangeProcessors, which take non-const references
 405  * to std::string and modify the strings.
 406  */
 407 %typemap(in) std::string &begin (std::string temp),
 408              std::string &end (std::string temp) {
 409     std::string *ptr = (std::string *)0;
 410     int res = SWIG_AsPtr_std_string($input, &ptr);
 411     if (!SWIG_IsOK(res) || !ptr) {
 412         %argument_fail((ptr ? res : SWIG_TypeError), "$type", $symname, $argnum);
 413     }
 414     temp = *ptr;
 415     $1 = &temp;
 416     if (SWIG_IsNewObj(res)) delete ptr;
 417 }
 418 %typemap(argout) (std::string &begin, std::string &end) {
 419     PyObject * str;
 420     PyObject * newresult;
 421
 422     // Put the existing result into the first item of a new 3-tuple.
 423     newresult = PyTuple_New(3);
 424     if (newresult == 0) {
 425         Py_DECREF($result);
 426         $result = NULL;
 427         SWIG_fail;
 428     }
 429     PyTuple_SET_ITEM(newresult, 0, $result);
 430     $result = newresult;
 431
 432     str = PyString_FromStringAndSize($1->data(), $1->size());
 433     if (str == 0) {
 434         Py_DECREF($result);
 435         $result = NULL;
 436         SWIG_fail;
 437     }
 438     PyTuple_SET_ITEM($result, 1, str);
 439
 440     str = PyString_FromStringAndSize($2->data(), $2->size());
 441     if (str == 0) {
 442         Py_DECREF($result);
 443         $result = NULL;
 444         SWIG_fail;
 445     }
 446
 447     PyTuple_SET_ITEM($result, 2, str);
 448 }
 449
 450 %typemap(directorin) (size_t num_tags, const std::string tags[]) {
 451     PyObject * result = PyList_New(num_tags);
 452     if (result == 0) {
 453         return NULL;
 454     }
 455
 456     for (size_t i = 0; i != num_tags; ++i) {
 457         PyObject * str = PyString_FromStringAndSize(tags[i].data(), tags[i].size());
 458         if (str == 0) {
 459             Py_DECREF(result);
 460             return NULL;
 461         }
 462
 463         PyList_SET_ITEM(result, i, str);
 464     }
 465     $input = result;
 466 }
 467
 468 /* vim:set syntax=cpp:set noexpandtab: */