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 /* Force xapian.BAD_VALUENO to be handled as a constant rather than a
  75  * read-only variable (ticket#297).
  76  */
  77 %ignore Xapian::BAD_VALUENO;
  78 %constant Xapian::valueno BAD_VALUENO = Xapian::BAD_VALUENO;
  79
  80 %{
  81 namespace Xapian {
  82     Query *get_py_query(PyObject *obj) {
  83         PyObject * mythis = PyObject_GetAttrString(obj, "this");
  84         if (!mythis)
  85             return 0;
  86
  87         Query * retval = 0;
  88         int res = SWIG_ConvertPtr(mythis, (void **)&retval,
  89                                   SWIGTYPE_p_Xapian__Query, 0);
  90         if (!SWIG_IsOK(res)) {
  91             retval = 0;
  92         }
  93         Py_DECREF(mythis);
  94         return retval;
  95     }
  96 }
  97 %}
  98
  99 namespace Xapian {
 100     %extend TermIterator {
 101         bool __eq__(const TermIterator &other) {
 102             return (*self)==other;
 103         }
 104         bool __ne__(const TermIterator &other) {
 105             return (*self)!=other;
 106         }
 107     }
 108     %rename(_TermIterator) TermIterator;
 109
 110     %extend PositionIterator {
 111         bool __eq__(const PositionIterator &other) {
 112             return (*self)==other;
 113         }
 114         bool __ne__(const PositionIterator &other) {
 115             return (*self)!=other;
 116         }
 117     }
 118     %rename(_PositionIterator) PositionIterator;
 119
 120     %extend PostingIterator {
 121         bool __eq__(const PostingIterator &other) {
 122             return (*self)==other;
 123         }
 124         bool __ne__(const PostingIterator &other) {
 125             return (*self)!=other;
 126         }
 127     }
 128     %rename(_PostingIterator) PostingIterator;
 129
 130     %extend ValueIterator {
 131         bool __eq__(const ValueIterator &other) {
 132             return (*self)==other;
 133         }
 134         bool __ne__(const ValueIterator &other) {
 135             return (*self)!=other;
 136         }
 137     }
 138     %rename(_ValueIterator) ValueIterator;
 139
 140     %extend MSetIterator {
 141         bool __eq__(const MSetIterator &other) {
 142             return (*self)==other;
 143         }
 144         bool __ne__(const MSetIterator &other) {
 145             return (*self)!=other;
 146         }
 147     }
 148     %rename(_MSetIterator) MSetIterator;
 149
 150     %extend ESetIterator {
 151         bool __eq__(const ESetIterator &other) {
 152             return (*self)==other;
 153         }
 154         bool __ne__(const ESetIterator &other) {
 155             return (*self)!=other;
 156         }
 157     }
 158     %rename(_ESetIterator) ESetIterator;
 159
 160     %extend MSet {
 161         // for comparison
 162         int __cmp__(const MSet &other) {
 163             if (self->get_max_possible() != other.get_max_possible()) {
 164                 return (self->get_max_possible() < other.get_max_possible())? -1 : 1;
 165             }
 166             if (self->size() != other.size()) {
 167                 return (self->size() < other.size())? -1 : 1;
 168             }
 169
 170             for (size_t i=0; i<self->size(); ++i) {
 171                 if (*(*self)[i] != *other[i]) {
 172                     return (*(*self)[i] < *other[i])? -1 : 1;
 173                 }
 174                 if ((*self)[i].get_weight() != other[i].get_weight()) {
 175                     return ((*self)[i].get_weight() < other[i].get_weight())? -1 : 1;
 176                 }
 177             }
 178             return 0;
 179         }
 180     }
 181 }
 182
 183 %fragment("XapianSWIG_anystring_as_ptr", "header", fragment="SWIG_AsPtr_std_string") {
 184 /* Utility function which works like SWIG_AsPtr_std_string, but
 185  * converts unicode strings to UTF-8 simple strings first. */
 186 static int
 187 XapianSWIG_anystring_as_ptr(PyObject * obj, std::string **val)
 188 {
 189     if (PyUnicode_Check(obj)) {
 190         PyObject * strobj = PyUnicode_EncodeUTF8(PyUnicode_AS_UNICODE(obj), PyUnicode_GET_SIZE(obj), "ignore");
 191         if (strobj == NULL) return SWIG_ERROR;
 192         int res = SWIG_AsPtr_std_string(strobj, val);
 193         Py_DECREF(strobj);
 194         return res;
 195     } else {
 196         return SWIG_AsPtr_std_string(obj, val);
 197     }
 198 }
 199 }
 200
 201 /* These typemaps depends somewhat heavily on the internals of SWIG, so
 202  * might break with future versions of SWIG.
 203  */
 204 %typemap(in, fragment="XapianSWIG_anystring_as_ptr") const std::string &(int res = SWIG_OLDOBJ) {
 205     std::string *ptr = (std::string *)0;
 206     res = XapianSWIG_anystring_as_ptr($input, &ptr);
 207     if (!SWIG_IsOK(res)) {
 208         %argument_fail(res, "$type", $symname, $argnum);
 209     }
 210     if (!ptr) {
 211         %argument_nullref("$type", $symname, $argnum);
 212     }
 213     $1 = ptr;
 214 }
 215 %typemap(in, fragment="XapianSWIG_anystring_as_ptr") std::string {
 216     std::string *ptr = (std::string *)0;
 217     int res = XapianSWIG_anystring_as_ptr($input, &ptr);
 218     if (!SWIG_IsOK(res) || !ptr) {
 219         %argument_fail((ptr ? res : SWIG_TypeError), "$type", $symname, $argnum);
 220     }
 221     $1 = *ptr;
 222     if (SWIG_IsNewObj(res)) delete ptr;
 223 }
 224 %typemap(freearg, noblock=1, match="in") const std::string & {
 225     if (SWIG_IsNewObj(res$argnum)) %delete($1);
 226 }
 227 %typemap(typecheck, noblock=1, precedence=900, fragment="XapianSWIG_anystring_as_ptr") const std::string & {
 228     int res = XapianSWIG_anystring_as_ptr($input, (std::string**)(0));
 229     $1 = SWIG_CheckState(res);
 230 }
 231
 232 %typemap(in, fragment="XapianSWIG_anystring_as_ptr") const std::string *(int res = SWIG_OLDOBJ) {
 233     std::string *ptr = (std::string *)0;
 234     if ($input != Py_None) {
 235         res = XapianSWIG_anystring_as_ptr($input, &ptr);
 236         if (!SWIG_IsOK(res)) {
 237             %argument_fail(res, "$type", $symname, $argnum);
 238         }
 239     }
 240     $1 = ptr;
 241 }
 242 %typemap(freearg, noblock=1, match="in") const std::string * {
 243     if (SWIG_IsNewObj(res$argnum)) %delete($1);
 244 }
 245 %typemap(typecheck, noblock=1, precedence=900, fragment="XapianSWIG_anystring_as_ptr") const std::string * {
 246     if ($input == Py_None) {
 247         $1 = 1;
 248     } else {
 249         int res = XapianSWIG_anystring_as_ptr($input, (std::string**)(0));
 250         $1 = SWIG_CheckState(res);
 251     }
 252 }
 253
 254 /* This typemap is only currently needed for returning a value from the
 255  * get_description() method of a Stopper subclass to a C++ caller, but might be
 256  * more generally useful in future.
 257  */
 258 %typemap(directorout, noblock=1, fragment="XapianSWIG_anystring_as_ptr") std::string {
 259     std::string *swig_optr = 0;
 260     int swig_ores;
 261     {
 262         PyObject * tmp = $input;
 263         Py_INCREF(tmp);
 264         swig_ores = XapianSWIG_anystring_as_ptr(tmp, &swig_optr);
 265         Py_DECREF(tmp);
 266     }
 267     if (!SWIG_IsOK(swig_ores) || !swig_optr) {
 268         %dirout_fail((swig_optr ? swig_ores : SWIG_TypeError), "$type");
 269     }
 270     $result = *swig_optr;
 271     if (SWIG_IsNewObj(swig_ores)) %delete(swig_optr);
 272 }
 273
 274 /** This pair of typemaps implements conversion of the return value of
 275  *  ValueRangeProcessor subclasses implemented in Python from a tuple of
 276  *  (valueno, begin, end) to a return value of valueno, and assigning the new
 277  *  values of begin and end to the parameters.
 278  */
 279 %typemap(directorin,noblock=1) std::string & {
 280     $input = SWIG_From_std_string(static_cast< std::string >($1_name));
 281 }
 282 %typemap(directorout,noblock=1) Xapian::valueno {
 283     if (!PyTuple_Check($input)) {
 284         %dirout_fail(SWIG_TypeError, "($type, std::string, std::string)");
 285     }
 286     if (PyTuple_Size($input) != 3) {
 287         %dirout_fail(SWIG_IndexError, "($type, std::string, std::string)");
 288     }
 289
 290     // Set the return value from the first item of the tuple.
 291     unsigned int swig_val;
 292     int swig_res = SWIG_AsVal_unsigned_SS_int(PyTuple_GET_ITEM((PyObject *)$input, 0), &swig_val);
 293     if (!SWIG_IsOK(swig_res)) {
 294         %dirout_fail(swig_res, "($type, std::string, std::string)");
 295     }
 296     c_result = static_cast< Xapian::valueno >(swig_val);
 297
 298     // Set "begin" from the second item of the tuple.
 299     std::string *ptr = (std::string *)0;
 300     swig_res = SWIG_AsPtr_std_string(PyTuple_GET_ITEM((PyObject *)$input, 1), &ptr);
 301     if (!SWIG_IsOK(swig_res) || !ptr) {
 302         delete ptr;
 303         ptr = (std::string *)0;
 304         %dirout_fail((ptr ? swig_res : SWIG_TypeError), "($type, std::string, std::string)");
 305     }
 306     begin = *ptr;
 307     delete ptr;
 308     ptr = (std::string *)0;
 309
 310     // Set "end" from the third item of the tuple.
 311     swig_res = SWIG_AsPtr_std_string(PyTuple_GET_ITEM((PyObject *)$input, 2), &ptr);
 312     if (!SWIG_IsOK(swig_res) || !ptr) {
 313         delete ptr;
 314         ptr = (std::string *)0;
 315         %dirout_fail((ptr ? swig_res : SWIG_TypeError), "($type, std::string, std::string)");
 316     }
 317     end = *ptr;
 318     delete ptr;
 319     ptr = (std::string *)0;
 320 }
 321
 322 /* These typemaps handle ValueRangeProcessors, which take non-const references
 323  * to std::string and modify the strings.
 324  */
 325 %typemap(in) std::string &begin (std::string temp),
 326              std::string &end (std::string temp) {
 327     std::string *ptr = (std::string *)0;
 328     int res = SWIG_AsPtr_std_string($input, &ptr);
 329     if (!SWIG_IsOK(res) || !ptr) {
 330         %argument_fail((ptr ? res : SWIG_TypeError), "$type", $symname, $argnum);
 331     }
 332     temp = *ptr;
 333     $1 = &temp;
 334     if (SWIG_IsNewObj(res)) delete ptr;
 335 }
 336 %typemap(argout) (std::string &begin, std::string &end) {
 337     PyObject * str;
 338     PyObject * newresult;
 339
 340     // Put the existing result into the first item of a new 3-tuple.
 341     newresult = PyTuple_New(3);
 342     if (newresult == 0) {
 343         Py_DECREF($result);
 344         $result = NULL;
 345         SWIG_fail;
 346     }
 347     PyTuple_SET_ITEM(newresult, 0, $result);
 348     $result = newresult;
 349
 350     str = PyString_FromStringAndSize($1->data(), $1->size());
 351     if (str == 0) {
 352         Py_DECREF($result);
 353         $result = NULL;
 354         SWIG_fail;
 355     }
 356     PyTuple_SET_ITEM($result, 1, str);
 357
 358     str = PyString_FromStringAndSize($2->data(), $2->size());
 359     if (str == 0) {
 360         Py_DECREF($result);
 361         $result = NULL;
 362         SWIG_fail;
 363     }
 364
 365     PyTuple_SET_ITEM($result, 2, str);
 366 }
 367
 368 %typemap(directorin) (size_t num_tags, const std::string tags[]) {
 369     PyObject * result = PyList_New(num_tags);
 370     if (result == 0) {
 371         return NULL;
 372     }
 373
 374     for (size_t i = 0; i != num_tags; ++i) {
 375         PyObject * str = PyString_FromStringAndSize(tags[i].data(), tags[i].size());
 376         if (str == 0) {
 377             Py_DECREF(result);
 378             return NULL;
 379         }
 380
 381         PyList_SET_ITEM(result, i, str);
 382     }
 383     $input = result;
 384 }
 385
 386 /* vim:set syntax=cpp:set noexpandtab: */