xapian-bindings/python3/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,2016,2017,2019 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 /* So iterator objects match the Python3 iterator API. */
  34 %rename(__next__) next;
  35
  36 /* Hide "unsafe" C++ iterator methods. */
  37 %rename(_allterms_begin) Xapian::Database::allterms_begin;
  38 %rename(_allterms_end) Xapian::Database::allterms_end;
  39 %rename(_metadata_keys_begin) Xapian::Database::metadata_keys_begin;
  40 %rename(_metadata_keys_end) Xapian::Database::metadata_keys_end;
  41 %rename(_synonym_keys_begin) Xapian::Database::synonym_keys_begin;
  42 %rename(_synonym_keys_end) Xapian::Database::synonym_keys_end;
  43 %rename(_synonyms_begin) Xapian::Database::synonyms_begin;
  44 %rename(_synonyms_end) Xapian::Database::synonyms_end;
  45 %rename(_spellings_begin) Xapian::Database::spellings_begin;
  46 %rename(_spellings_end) Xapian::Database::spellings_end;
  47 %rename(_positionlist_begin) Xapian::Database::positionlist_begin;
  48 %rename(_positionlist_end) Xapian::Database::positionlist_end;
  49 %rename(_postlist_begin) Xapian::Database::postlist_begin;
  50 %rename(_postlist_end) Xapian::Database::postlist_end;
  51 %rename(_termlist_begin) Xapian::Database::termlist_begin;
  52 %rename(_termlist_end) Xapian::Database::termlist_end;
  53 %rename(_termlist_begin) Xapian::Document::termlist_begin;
  54 %rename(_termlist_end) Xapian::Document::termlist_end;
  55 %rename(_values_begin) Xapian::Document::values_begin;
  56 %rename(_values_end) Xapian::Document::values_end;
  57 %rename(_get_matching_terms_begin) Xapian::Enquire::get_matching_terms_begin;
  58 %rename(_get_matching_terms_end) Xapian::Enquire::get_matching_terms_end;
  59 %rename(_begin) Xapian::ESet::begin;
  60 %rename(_end) Xapian::ESet::end;
  61 %rename(_begin) Xapian::MSet::begin;
  62 %rename(_end) Xapian::MSet::end;
  63 %rename(_positionlist_begin) Xapian::PostingIterator::positionlist_begin;
  64 %rename(_positionlist_end) Xapian::PostingIterator::positionlist_end;
  65 %rename(_get_terms_begin) Xapian::Query::get_terms_begin;
  66 %rename(_get_terms_end) Xapian::Query::get_terms_end;
  67 %rename(_stoplist_begin) Xapian::QueryParser::stoplist_begin;
  68 %rename(_stoplist_end) Xapian::QueryParser::stoplist_end;
  69 %rename(_unstem_begin) Xapian::QueryParser::unstem_begin;
  70 %rename(_unstem_end) Xapian::QueryParser::unstem_end;
  71 %rename(_positionlist_begin) Xapian::TermIterator::positionlist_begin;
  72 %rename(_positionlist_end) Xapian::TermIterator::positionlist_end;
  73
  74 /* We replace the get_hit() method with one which returns an MSetitem. */
  75 %rename(_get_hit_internal) Xapian::MSet::get_hit;
  76
  77 %{
  78 namespace Xapian {
  79     Query *get_py_query(PyObject *obj) {
  80         PyObject * mythis = PyObject_GetAttrString(obj, "this");
  81         if (!mythis)
  82             return 0;
  83
  84         Query * retval = 0;
  85         int res = SWIG_ConvertPtr(mythis, (void **)&retval,
  86                                   SWIGTYPE_p_Xapian__Query, 0);
  87         if (!SWIG_IsOK(res)) {
  88             retval = 0;
  89         }
  90         Py_DECREF(mythis);
  91         return retval;
  92     }
  93 }
  94 %}
  95
  96 namespace Xapian {
  97     %extend TermIterator {
  98         bool __eq__(const TermIterator &other) {
  99             return (*self)==other;
 100         }
 101         bool __ne__(const TermIterator &other) {
 102             return (*self)!=other;
 103         }
 104     }
 105     %rename(_TermIterator) TermIterator;
 106
 107     %extend PositionIterator {
 108         bool __eq__(const PositionIterator &other) {
 109             return (*self)==other;
 110         }
 111         bool __ne__(const PositionIterator &other) {
 112             return (*self)!=other;
 113         }
 114     }
 115     %rename(_PositionIterator) PositionIterator;
 116
 117     %extend PostingIterator {
 118         bool __eq__(const PostingIterator &other) {
 119             return (*self)==other;
 120         }
 121         bool __ne__(const PostingIterator &other) {
 122             return (*self)!=other;
 123         }
 124     }
 125     %rename(_PostingIterator) PostingIterator;
 126
 127     %extend ValueIterator {
 128         bool __eq__(const ValueIterator &other) {
 129             return (*self)==other;
 130         }
 131         bool __ne__(const ValueIterator &other) {
 132             return (*self)!=other;
 133         }
 134     }
 135     %rename(_ValueIterator) ValueIterator;
 136
 137     %extend MSetIterator {
 138         bool __eq__(const MSetIterator &other) {
 139             return (*self)==other;
 140         }
 141         bool __ne__(const MSetIterator &other) {
 142             return (*self)!=other;
 143         }
 144     }
 145     %rename(_MSetIterator) MSetIterator;
 146
 147     %extend ESetIterator {
 148         bool __eq__(const ESetIterator &other) {
 149             return (*self)==other;
 150         }
 151         bool __ne__(const ESetIterator &other) {
 152             return (*self)!=other;
 153         }
 154     }
 155     %rename(_ESetIterator) ESetIterator;
 156 }
 157
 158 %fragment("XapianSWIG_anystring_as_ptr", "header", fragment="SWIG_AsPtr_std_string") {
 159 /* Utility function which works like SWIG_AsPtr_std_string, but
 160  * converts unicode strings to UTF-8 simple strings first. */
 161 static int
 162 XapianSWIG_anystring_as_ptr(PyObject * obj, std::string **val)
 163 {
 164     if (PyUnicode_Check(obj)) {
 165         PyObject* strobj = PyUnicode_AsUTF8String(obj);
 166         if (strobj == NULL) return INT_MIN;
 167         char *p;
 168         Py_ssize_t len;
 169         PyBytes_AsStringAndSize(strobj, &p, &len);
 170         if (val) *val = new std::string(p, len);
 171         Py_DECREF(strobj);
 172         return SWIG_NEWOBJ;
 173     } else if (PyBytes_Check(obj)) {
 174         char *p;
 175         Py_ssize_t len;
 176         PyBytes_AsStringAndSize(obj, &p, &len);
 177         if (val) *val = new std::string(p, len);
 178         return SWIG_NEWOBJ;
 179     } else {
 180         return SWIG_AsPtr_std_string(obj, val);
 181     }
 182 }
 183 }
 184
 185 /* These typemaps depends somewhat heavily on the internals of SWIG, so
 186  * might break with future versions of SWIG.
 187  */
 188 %typemap(in, fragment="XapianSWIG_anystring_as_ptr") const std::string &(int res = SWIG_OLDOBJ) {
 189     std::string *ptr = (std::string *)0;
 190     res = XapianSWIG_anystring_as_ptr($input, &ptr);
 191     if (!SWIG_IsOK(res)) {
 192         if (res == INT_MIN) SWIG_fail;
 193         %argument_fail(res, "$type", $symname, $argnum);
 194     }
 195     if (!ptr) {
 196         %argument_nullref("$type", $symname, $argnum);
 197     }
 198     $1 = ptr;
 199 }
 200 %typemap(in, fragment="XapianSWIG_anystring_as_ptr") std::string {
 201     std::string *ptr = (std::string *)0;
 202     int res = XapianSWIG_anystring_as_ptr($input, &ptr);
 203     if (!SWIG_IsOK(res) || !ptr) {
 204         if (res == INT_MIN) SWIG_fail;
 205         %argument_fail((ptr ? res : SWIG_TypeError), "$type", $symname, $argnum);
 206     }
 207     $1 = *ptr;
 208     if (SWIG_IsNewObj(res)) delete ptr;
 209 }
 210 %typemap(freearg, noblock=1, match="in") const std::string & {
 211     if (SWIG_IsNewObj(res$argnum)) %delete($1);
 212 }
 213 %typemap(typecheck, noblock=1, precedence=900) const std::string & {
 214     if (PyUnicode_Check($input)) {
 215         $1 = 1;
 216     } else if (PyBytes_Check($input)) {
 217         $1 = 1;
 218     } else {
 219         int res = SWIG_AsPtr_std_string($input, (std::string**)(0));
 220         $1 = SWIG_CheckState(res);
 221     }
 222 }
 223
 224 %typemap(in, fragment="XapianSWIG_anystring_as_ptr") const std::string *(int res = SWIG_OLDOBJ) {
 225     std::string *ptr = (std::string *)0;
 226     if ($input != Py_None) {
 227         res = XapianSWIG_anystring_as_ptr($input, &ptr);
 228         if (!SWIG_IsOK(res)) {
 229             if (res == INT_MIN) SWIG_fail;
 230             %argument_fail(res, "$type", $symname, $argnum);
 231         }
 232     }
 233     $1 = ptr;
 234 }
 235 %typemap(freearg, noblock=1, match="in") const std::string * {
 236     if (SWIG_IsNewObj(res$argnum)) %delete($1);
 237 }
 238 %typemap(typecheck, noblock=1, precedence=900) const std::string * {
 239     if ($input == Py_None) {
 240         $1 = 1;
 241     } else if (PyUnicode_Check($input)) {
 242         $1 = 1;
 243     } else if (PyBytes_Check($input)) {
 244         $1 = 1;
 245     } else {
 246         int res = SWIG_AsPtr_std_string($input, (std::string**)(0));
 247         $1 = SWIG_CheckState(res);
 248     }
 249 }
 250
 251 /* This typemap is only currently needed for returning a value from the
 252  * get_description() method of a Stopper subclass to a C++ caller, but might be
 253  * more generally useful in future.
 254  */
 255 %typemap(directorout, noblock=1, fragment="XapianSWIG_anystring_as_ptr") std::string {
 256     std::string *swig_optr = 0;
 257     int swig_ores;
 258     {
 259         PyObject * tmp = $input;
 260         Py_INCREF(tmp);
 261         swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
 262         Py_DECREF(tmp);
 263     }
 264     if (!SWIG_IsOK(swig_ores) || !swig_optr) {
 265         %dirout_fail((swig_optr ? swig_ores : SWIG_TypeError), "$type");
 266     }
 267     $result = *swig_optr;
 268     if (SWIG_IsNewObj(swig_ores)) %delete(swig_optr);
 269 }
 270
 271 /** This pair of typemaps implements conversion of the return value of
 272  *  ValueRangeProcessor subclasses implemented in Python from a tuple of
 273  *  (valueno, begin, end) to a return value of valueno, and assigning the new
 274  *  values of begin and end to the parameters.
 275  */
 276 %typemap(directorin,noblock=1) std::string & {
 277     $input = SWIG_From_std_string(static_cast< std::string >($1_name));
 278 }
 279 %typemap(directorout,noblock=1) Xapian::valueno {
 280     if (!PyTuple_Check($input)) {
 281         %dirout_fail(SWIG_TypeError, "($type, std::string, std::string)");
 282     }
 283     if (PyTuple_Size($input) != 3) {
 284         %dirout_fail(SWIG_IndexError, "($type, std::string, std::string)");
 285     }
 286
 287     // Set the return value from the first item of the tuple.
 288     unsigned int swig_val;
 289     int swig_res = SWIG_AsVal_unsigned_SS_int(PyTuple_GET_ITEM((PyObject *)$input, 0), &swig_val);
 290     if (!SWIG_IsOK(swig_res)) {
 291         %dirout_fail(swig_res, "($type, std::string, std::string)");
 292     }
 293     c_result = static_cast< Xapian::valueno >(swig_val);
 294
 295     // Set "begin" from the second item of the tuple.
 296     std::string *ptr = (std::string *)0;
 297     swig_res = SWIG_AsPtr_std_string(PyTuple_GET_ITEM((PyObject *)$input, 1), &ptr);
 298     if (!SWIG_IsOK(swig_res) || !ptr) {
 299         delete ptr;
 300         ptr = (std::string *)0;
 301         %dirout_fail((ptr ? swig_res : SWIG_TypeError), "($type, std::string, std::string)");
 302     }
 303     begin = *ptr;
 304     delete ptr;
 305     ptr = (std::string *)0;
 306
 307     // Set "end" from the third item of the tuple.
 308     swig_res = SWIG_AsPtr_std_string(PyTuple_GET_ITEM((PyObject *)$input, 2), &ptr);
 309     if (!SWIG_IsOK(swig_res) || !ptr) {
 310         delete ptr;
 311         ptr = (std::string *)0;
 312         %dirout_fail((ptr ? swig_res : SWIG_TypeError), "($type, std::string, std::string)");
 313     }
 314     end = *ptr;
 315     delete ptr;
 316     ptr = (std::string *)0;
 317 }
 318
 319 /* These typemaps handle ValueRangeProcessors, which take non-const references
 320  * to std::string and modify the strings.
 321  */
 322 %typemap(in) std::string &begin (std::string temp),
 323              std::string &end (std::string temp) {
 324     std::string *ptr = (std::string *)0;
 325     int res = XapianSWIG_anystring_as_ptr($input, &ptr);
 326     if (!SWIG_IsOK(res) || !ptr) {
 327         %argument_fail((ptr ? res : SWIG_TypeError), "$type", $symname, $argnum);
 328     }
 329     temp = *ptr;
 330     $1 = &temp;
 331     if (SWIG_IsNewObj(res)) delete ptr;
 332 }
 333 %typemap(argout) (std::string &begin, std::string &end) {
 334     PyObject * str;
 335     PyObject * newresult;
 336
 337     // Put the existing result into the first item of a new 3-tuple.
 338     newresult = PyTuple_New(3);
 339     if (newresult == 0) {
 340         Py_DECREF($result);
 341         $result = NULL;
 342         SWIG_fail;
 343     }
 344     PyTuple_SET_ITEM(newresult, 0, $result);
 345     $result = newresult;
 346
 347     str = PyBytes_FromStringAndSize($1->data(), $1->size());
 348     if (str == 0) {
 349         Py_DECREF($result);
 350         $result = NULL;
 351         SWIG_fail;
 352     }
 353     PyTuple_SET_ITEM($result, 1, str);
 354
 355     str = PyBytes_FromStringAndSize($2->data(), $2->size());
 356     if (str == 0) {
 357         Py_DECREF($result);
 358         $result = NULL;
 359         SWIG_fail;
 360     }
 361
 362     PyTuple_SET_ITEM($result, 2, str);
 363 }
 364
 365 %typemap(directorin) (size_t num_tags, const std::string tags[]) {
 366     PyObject * result = PyList_New(num_tags);
 367     if (result == 0) {
 368         return NULL;
 369     }
 370
 371     for (size_t i = 0; i != num_tags; ++i) {
 372         PyObject * str = PyBytes_FromStringAndSize(tags[i].data(), tags[i].size());
 373         if (str == 0) {
 374             Py_DECREF(result);
 375             return NULL;
 376         }
 377
 378         PyList_SET_ITEM(result, i, str);
 379     }
 380     $input = result;
 381 }
 382
 383 /* vim:set syntax=cpp:set noexpandtab: */