source/gameengine/Expressions/ListValue.cpp

   1 // ListValue.cpp: implementation of the CListValue class.
   2 //
   3 //////////////////////////////////////////////////////////////////////
   4 /*
   5  * Copyright (c) 1996-2000 Erwin Coumans <coockie@acm.org>
   6  *
   7  * Permission to use, copy, modify, distribute and sell this software
   8  * and its documentation for any purpose is hereby granted without fee,
   9  * provided that the above copyright notice appear in all copies and
  10  * that both that copyright notice and this permission notice appear
  11  * in supporting documentation.  Erwin Coumans makes no
  12  * representations about the suitability of this software for any
  13  * purpose.  It is provided "as is" without express or implied warranty.
  14  *
  15  */
  16
  17 #include "ListValue.h"
  18 #include "StringValue.h"
  19 #include "VoidValue.h"
  20 #include <algorithm>
  21 #include "BoolValue.h"
  22
  23 #include "BLO_sys_types.h" /* for intptr_t support */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #include <config.h>
  27 #endif
  28
  29 #if  ((PY_MAJOR_VERSION == 2) &&(PY_MINOR_VERSION < 5))
  30 #define Py_ssize_t int
  31 #endif
  32
  33 Py_ssize_t listvalue_bufferlen(PyObject* self)
  34 {
  35         CListValue *list= static_cast<CListValue *>(BGE_PROXY_REF(self));
  36         if (list==NULL)
  37                 return 0;
  38
  39         return (Py_ssize_t)list->GetCount();
  40 }
  41
  42 PyObject* listvalue_buffer_item(PyObject* self, Py_ssize_t index)
  43 {
  44         CListValue *list= static_cast<CListValue *>(BGE_PROXY_REF(self));
  45         CValue *cval;
  46
  47         if (list==NULL) {
  48                 PyErr_SetString(PyExc_SystemError, "val = CList[i], "BGE_PROXY_ERROR_MSG);
  49                 return NULL;
  50         }
  51
  52         int count = list->GetCount();
  53
  54         if (index < 0)
  55                 index = count+index;
  56
  57         if (index < 0 || index >= count) {
  58                 PyErr_SetString(PyExc_IndexError, "CList[i]: Python ListIndex out of range in CValueList");
  59                 return NULL;
  60         }
  61
  62         cval= list->GetValue(index);
  63
  64         PyObject* pyobj = cval->ConvertValueToPython();
  65         if (pyobj)
  66                 return pyobj;
  67         else
  68                 return cval->GetProxy();
  69 }
  70
  71 PyObject* listvalue_mapping_subscript(PyObject* self, PyObject* pyindex)
  72 {
  73         CListValue *list= static_cast<CListValue *>(BGE_PROXY_REF(self));
  74         if (list==NULL) {
  75                 PyErr_SetString(PyExc_SystemError, "value = CList[i], "BGE_PROXY_ERROR_MSG);
  76                 return NULL;
  77         }
  78
  79         if (PyUnicode_Check(pyindex))
  80         {
  81                 CValue *item = ((CListValue*) list)->FindValue(_PyUnicode_AsString(pyindex));
  82                 if (item) {
  83                         PyObject* pyobj = item->ConvertValueToPython();
  84                         if(pyobj)
  85                                 return pyobj;
  86                         else
  87                                 return item->GetProxy();
  88                 }
  89         }
  90         else if (PyLong_Check(pyindex))
  91         {
  92                 int index = PyLong_AsSsize_t(pyindex);
  93                 return listvalue_buffer_item(self, index); /* wont add a ref */
  94         }
  95
  96         PyObject *pyindex_str = PyObject_Repr(pyindex); /* new ref */
  97         PyErr_Format(PyExc_KeyError, "CList[key]: '%s' key not in list", _PyUnicode_AsString(pyindex_str));
  98         Py_DECREF(pyindex_str);
  99         return NULL;
 100 }
 101
 102
 103 /* just slice it into a python list... */
 104 PyObject* listvalue_buffer_slice(PyObject* self,Py_ssize_t ilow, Py_ssize_t ihigh)
 105 {
 106         CListValue *list= static_cast<CListValue *>(BGE_PROXY_REF(self));
 107         if (list==NULL) {
 108                 PyErr_SetString(PyExc_SystemError, "val = CList[i:j], "BGE_PROXY_ERROR_MSG);
 109                 return NULL;
 110         }
 111
 112         int i, j;
 113         PyObject *newlist;
 114
 115         if (ilow < 0) ilow = 0;
 116
 117         int n = ((CListValue*) list)->GetCount();
 118
 119         if (ihigh >= n)
 120                 ihigh = n;
 121     if (ihigh < ilow)
 122         ihigh = ilow;
 123
 124         newlist = PyList_New(ihigh - ilow);
 125         if (!newlist)
 126                 return NULL;
 127
 128         for (i = ilow, j = 0; i < ihigh; i++, j++)
 129         {
 130                 PyObject* pyobj = list->GetValue(i)->ConvertValueToPython();
 131                 if (!pyobj)
 132                         pyobj = list->GetValue(i)->GetProxy();
 133                 PyList_SET_ITEM(newlist, i, pyobj);
 134         }
 135         return newlist;
 136 }
 137
 138
 139 /* clist + list, return a list that python owns */
 140 static PyObject *listvalue_buffer_concat(PyObject * self, PyObject * other)
 141 {
 142         CListValue *listval= static_cast<CListValue *>(BGE_PROXY_REF(self));
 143         int i, numitems, numitems_orig;
 144
 145         if (listval==NULL) {
 146                 PyErr_SetString(PyExc_SystemError, "CList+other, "BGE_PROXY_ERROR_MSG);
 147                 return NULL;
 148         }
 149
 150         numitems_orig= listval->GetCount();
 151
 152         // for now, we support CListValue concatenated with items
 153         // and CListValue concatenated to Python Lists
 154         // and CListValue concatenated with another CListValue
 155
 156         /* Shallow copy, dont use listval->GetReplica(), it will screw up with KX_GameObjects */
 157         CListValue* listval_new = new CListValue();
 158
 159         if (PyList_Check(other))
 160         {
 161                 CValue* listitemval;
 162                 bool error = false;
 163
 164                 numitems = PyList_Size(other);
 165
 166                 /* copy the first part of the list */
 167                 listval_new->Resize(numitems_orig + numitems);
 168                 for (i=0;i<numitems_orig;i++)
 169                         listval_new->SetValue(i, listval->GetValue(i)->AddRef());
 170
 171                 for (i=0;i<numitems;i++)
 172                 {
 173                         listitemval = listval->ConvertPythonToValue(PyList_GetItem(other,i), "cList + pyList: CListValue, ");
 174
 175                         if (listitemval) {
 176                                 listval_new->SetValue(i+numitems_orig, listitemval);
 177                         } else {
 178                                 error= true;
 179                                 break;
 180                         }
 181                 }
 182
 183                 if (error) {
 184                         listval_new->Resize(numitems_orig+i); /* resize so we dont try release NULL pointers */
 185                         listval_new->Release();
 186                         return NULL; /* ConvertPythonToValue above sets the error */
 187                 }
 188
 189         }
 190         else if (PyObject_TypeCheck(other, &CListValue::Type)) {
 191                 // add items from otherlist to this list
 192                 CListValue* otherval = static_cast<CListValue *>(BGE_PROXY_REF(other));
 193                 if(otherval==NULL) {
 194                         listval_new->Release();
 195                         PyErr_SetString(PyExc_SystemError, "CList+other, "BGE_PROXY_ERROR_MSG);
 196                         return NULL;
 197                 }
 198
 199                 numitems = otherval->GetCount();
 200
 201                 /* copy the first part of the list */
 202                 listval_new->Resize(numitems_orig + numitems); /* resize so we dont try release NULL pointers */
 203                 for (i=0;i<numitems_orig;i++)
 204                         listval_new->SetValue(i, listval->GetValue(i)->AddRef());
 205
 206                 /* now copy the other part of the list */
 207                 for (i=0;i<numitems;i++)
 208                         listval_new->SetValue(i+numitems_orig, otherval->GetValue(i)->AddRef());
 209
 210         }
 211         return listval_new->NewProxy(true); /* python owns this list */
 212 }
 213
 214 static int listvalue_buffer_contains(PyObject *self_v, PyObject *value)
 215 {
 216         CListValue *self= static_cast<CListValue *>(BGE_PROXY_REF(self_v));
 217
 218         if (self==NULL) {
 219                 PyErr_SetString(PyExc_SystemError, "val in CList, "BGE_PROXY_ERROR_MSG);
 220                 return -1;
 221         }
 222
 223         if (PyUnicode_Check(value)) {
 224                 if (self->FindValue((const char *)_PyUnicode_AsString(value))) {
 225                         return 1;
 226                 }
 227         }
 228         else if (PyObject_TypeCheck(value, &CValue::Type)) { /* not dict like at all but this worked before __contains__ was used */
 229                 CValue *item= static_cast<CValue *>(BGE_PROXY_REF(value));
 230                 for (int i=0; i < self->GetCount(); i++)
 231                         if (self->GetValue(i) == item) // Com
 232                                 return 1;
 233
 234         } // not using CheckEqual
 235
 236         return 0;
 237 }
 238
 239
 240 static  PySequenceMethods listvalue_as_sequence = {
 241         listvalue_bufferlen,//(inquiry)buffer_length, /*sq_length*/
 242         listvalue_buffer_concat, /*sq_concat*/
 243         NULL, /*sq_repeat*/
 244         listvalue_buffer_item, /*sq_item*/
 245 #if (PY_VERSION_HEX >= 0x03000000) // TODO, slicing in py3?
 246         NULL,
 247         NULL,
 248         NULL,
 249 #else
 250         listvalue_buffer_slice, /*sq_slice*/
 251         NULL, /*sq_ass_item*/
 252         NULL, /*sq_ass_slice*/
 253 #endif
 254         (objobjproc)listvalue_buffer_contains,  /* sq_contains */
 255 };
 256
 257
 258
 259 /* Is this one used ? */
 260 static  PyMappingMethods instance_as_mapping = {
 261         listvalue_bufferlen, /*mp_length*/
 262         listvalue_mapping_subscript, /*mp_subscript*/
 263         NULL /*mp_ass_subscript*/
 264 };
 265
 266
 267
 268 PyTypeObject CListValue::Type = {
 269 #if (PY_VERSION_HEX >= 0x02060000)
 270         PyVarObject_HEAD_INIT(NULL, 0)
 271 #else
 272         /* python 2.5 and below */
 273         PyObject_HEAD_INIT( NULL )  /* required py macro */
 274         0,                              /*ob_size*/
 275 #endif
 276         "CListValue",                   /*tp_name*/
 277         sizeof(PyObjectPlus_Proxy), /*tp_basicsize*/
 278         0,                              /*tp_itemsize*/
 279         /* methods */
 280         py_base_dealloc,                        /*tp_dealloc*/
 281         0,                              /*tp_print*/
 282         0,                      /*tp_getattr*/
 283         0,                      /*tp_setattr*/
 284         0,                              /*tp_compare*/
 285         py_base_repr,                           /*tp_repr*/
 286         0,                              /*tp_as_number*/
 287         &listvalue_as_sequence, /*tp_as_sequence*/
 288         &instance_as_mapping,           /*tp_as_mapping*/
 289         0,                              /*tp_hash*/
 290         0,                              /*tp_call */
 291         0,
 292         NULL,
 293         NULL,
 294         0,
 295         Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 296         0,0,0,0,0,0,0,
 297         Methods,
 298         0,
 299         0,
 300         &CValue::Type,
 301         0,0,0,0,0,0,
 302         py_base_new
 303 };
 304
 305 PyMethodDef CListValue::Methods[] = {
 306         /* List style access */
 307         {"append", (PyCFunction)CListValue::sPyappend,METH_O},
 308         {"reverse", (PyCFunction)CListValue::sPyreverse,METH_NOARGS},
 309         {"index", (PyCFunction)CListValue::sPyindex,METH_O},
 310         {"count", (PyCFunction)CListValue::sPycount,METH_O},
 311
 312         /* Dict style access */
 313         {"get", (PyCFunction)CListValue::sPyget,METH_VARARGS},
 314         {"has_key", (PyCFunction)CListValue::sPyhas_key,METH_O},
 315
 316         /* Own cvalue funcs */
 317         {"from_id", (PyCFunction)CListValue::sPyfrom_id,METH_O},
 318
 319         {NULL,NULL} //Sentinel
 320 };
 321
 322 PyAttributeDef CListValue::Attributes[] = {
 323         { NULL }        //Sentinel
 324 };
 325
 326 //////////////////////////////////////////////////////////////////////
 327 // Construction/Destruction
 328 //////////////////////////////////////////////////////////////////////
 329
 330 CListValue::CListValue()
 331 : CPropValue()
 332 {
 333         m_bReleaseContents=true;
 334 }
 335
 336
 337
 338 CListValue::~CListValue()
 339 {
 340
 341         if (m_bReleaseContents) {
 342                 for (unsigned int i=0;i<m_pValueArray.size();i++) {
 343                         m_pValueArray[i]->Release();
 344                 }
 345         }
 346 }
 347
 348
 349 static STR_String gstrListRep=STR_String("List");
 350
 351 const STR_String & CListValue::GetText()
 352 {
 353         gstrListRep = "[";
 354         STR_String commastr = "";
 355
 356         for (int i=0;i<GetCount();i++)
 357         {
 358                 gstrListRep += commastr;
 359                 gstrListRep += GetValue(i)->GetText();
 360                 commastr = ",";
 361         }
 362         gstrListRep += "]";
 363
 364         return gstrListRep;
 365 }
 366
 367
 368
 369 CValue* CListValue::GetReplica() {
 370         CListValue* replica = new CListValue(*this);
 371
 372         replica->ProcessReplica();
 373
 374         replica->m_bReleaseContents=true; // for copy, complete array is copied for now...
 375         // copy all values
 376         int numelements = m_pValueArray.size();
 377         unsigned int i=0;
 378         replica->m_pValueArray.resize(numelements);
 379         for (i=0;i<m_pValueArray.size();i++)
 380                 replica->m_pValueArray[i] = m_pValueArray[i]->GetReplica();
 381
 382
 383         return replica;
 384 };
 385
 386
 387
 388 void CListValue::SetValue(int i, CValue *val)
 389 {
 390         assertd(i < m_pValueArray.size());
 391         m_pValueArray[i]=val;
 392 }
 393
 394
 395
 396 void CListValue::Resize(int num)
 397 {
 398         m_pValueArray.resize(num);
 399 }
 400
 401
 402
 403 void CListValue::Remove(int i)
 404 {
 405         assertd(i<m_pValueArray.size());
 406         m_pValueArray.erase(m_pValueArray.begin()+i);
 407 }
 408
 409
 410
 411 void CListValue::ReleaseAndRemoveAll()
 412 {
 413         for (unsigned int i=0;i<m_pValueArray.size();i++)
 414                 m_pValueArray[i]->Release();
 415         m_pValueArray.clear();//.Clear();
 416 }
 417
 418
 419
 420 CValue* CListValue::FindValue(const STR_String & name)
 421 {
 422         for (int i=0; i < GetCount(); i++)
 423                 if (GetValue(i)->GetName() == name)
 424                         return GetValue(i);
 425
 426         return NULL;
 427 }
 428
 429 CValue* CListValue::FindValue(const char * name)
 430 {
 431         for (int i=0; i < GetCount(); i++)
 432                 if (GetValue(i)->GetName() == name)
 433                         return GetValue(i);
 434
 435         return NULL;
 436 }
 437
 438 bool CListValue::SearchValue(CValue *val)
 439 {
 440         for (int i=0;i<GetCount();i++)
 441                 if (val == GetValue(i))
 442                         return true;
 443         return false;
 444 }
 445
 446
 447
 448 void CListValue::SetReleaseOnDestruct(bool bReleaseContents)
 449 {
 450         m_bReleaseContents = bReleaseContents;
 451 }
 452
 453
 454
 455 bool CListValue::RemoveValue(CValue *val)
 456 {
 457         bool result=false;
 458
 459         for (int i=GetCount()-1;i>=0;i--)
 460                 if (val == GetValue(i))
 461                 {
 462                         Remove(i);
 463                         result=true;
 464                 }
 465         return result;
 466 }
 467
 468
 469
 470 void CListValue::MergeList(CListValue *otherlist)
 471 {
 472
 473         int numelements = this->GetCount();
 474         int numotherelements = otherlist->GetCount();
 475
 476
 477         Resize(numelements+numotherelements);
 478
 479         for (int i=0;i<numotherelements;i++)
 480         {
 481                 SetValue(i+numelements,otherlist->GetValue(i)->AddRef());
 482         }
 483 }
 484
 485
 486 PyObject* CListValue::Pyappend(PyObject* value)
 487 {
 488         CValue* objval = ConvertPythonToValue(value, "CList.append(i): CValueList, ");
 489
 490         if (!objval) /* ConvertPythonToValue sets the error */
 491                 return NULL;
 492
 493         if (!BGE_PROXY_PYOWNS(m_proxy)) {
 494                 PyErr_SetString(PyExc_TypeError, "CList.append(i): this CValueList is used internally for the game engine and can't be modified");
 495                 return NULL;
 496         }
 497
 498         Add(objval);
 499
 500         Py_RETURN_NONE;
 501 }
 502
 503
 504
 505 PyObject* CListValue::Pyreverse()
 506 {
 507         std::reverse(m_pValueArray.begin(),m_pValueArray.end());
 508         Py_RETURN_NONE;
 509 }
 510
 511
 512
 513 bool CListValue::CheckEqual(CValue* first,CValue* second)
 514 {
 515         bool result = false;
 516
 517         CValue* eqval =  ((CValue*)first)->Calc(VALUE_EQL_OPERATOR,(CValue*)second);
 518
 519         if (eqval==NULL)
 520                 return false;
 521         const STR_String& text = eqval->GetText();
 522         if (&text==&CBoolValue::sTrueString)
 523         {
 524                 result = true;
 525         }
 526         eqval->Release();
 527         return result;
 528
 529 }
 530
 531
 532
 533 PyObject* CListValue::Pyindex(PyObject *value)
 534 {
 535         PyObject* result = NULL;
 536
 537         CValue* checkobj = ConvertPythonToValue(value, "val = cList[i]: CValueList, ");
 538         if (checkobj==NULL)
 539                 return NULL; /* ConvertPythonToValue sets the error */
 540
 541         int numelem = GetCount();
 542         for (int i=0;i<numelem;i++)
 543         {
 544                 CValue* elem =                  GetValue(i);
 545                 if (checkobj==elem || CheckEqual(checkobj,elem))
 546                 {
 547                         result = PyLong_FromSsize_t(i);
 548                         break;
 549                 }
 550         }
 551         checkobj->Release();
 552
 553         if (result==NULL) {
 554                 PyErr_SetString(PyExc_ValueError, "CList.index(x): x not in CListValue");
 555         }
 556         return result;
 557
 558 }
 559
 560
 561
 562 PyObject* CListValue::Pycount(PyObject* value)
 563 {
 564         int numfound = 0;
 565
 566         CValue* checkobj = ConvertPythonToValue(value, ""); /* error ignored */
 567
 568         if (checkobj==NULL) { /* in this case just return that there are no items in the list */
 569                 PyErr_Clear();
 570                 return PyLong_FromSsize_t(0);
 571         }
 572
 573         int numelem = GetCount();
 574         for (int i=0;i<numelem;i++)
 575         {
 576                 CValue* elem =                  GetValue(i);
 577                 if (checkobj==elem || CheckEqual(checkobj,elem))
 578                 {
 579                         numfound ++;
 580                 }
 581         }
 582         checkobj->Release();
 583
 584         return PyLong_FromSsize_t(numfound);
 585 }
 586
 587 /* Matches python dict.get(key, [default]) */
 588 PyObject* CListValue::Pyget(PyObject *args)
 589 {
 590         char *key;
 591         PyObject* def = Py_None;
 592
 593         if (!PyArg_ParseTuple(args, "s|O:get", &key, &def))
 594                 return NULL;
 595
 596         CValue *item = FindValue((const char *)key);
 597         if (item) {
 598                 PyObject* pyobj = item->ConvertValueToPython();
 599                 if (pyobj)
 600                         return pyobj;
 601                 else
 602                         return item->GetProxy();
 603         }
 604         Py_INCREF(def);
 605         return def;
 606 }
 607
 608 /* Matches python dict.has_key() */
 609 PyObject* CListValue::Pyhas_key(PyObject* value)
 610 {
 611         if (PyUnicode_Check(value) && FindValue((const char *)_PyUnicode_AsString(value)))
 612                 Py_RETURN_TRUE;
 613
 614         Py_RETURN_FALSE;
 615 }
 616
 617 PyObject* CListValue::Pyfrom_id(PyObject* value)
 618 {
 619         uintptr_t id= (uintptr_t)PyLong_AsVoidPtr(value);
 620
 621         if (PyErr_Occurred())
 622                 return NULL;
 623
 624         int numelem = GetCount();
 625         for (int i=0;i<numelem;i++)
 626         {
 627                 if (reinterpret_cast<uintptr_t>(m_pValueArray[i]->m_proxy) == id)
 628                         return GetValue(i)->GetProxy();
 629         }
 630         PyErr_SetString(PyExc_IndexError, "from_id(#): id not found in CValueList");
 631         return NULL;
 632
 633 }
 634
 635
 636 /* ---------------------------------------------------------------------
 637  * Some stuff taken from the header
 638  * --------------------------------------------------------------------- */
 639 CValue* CListValue::Calc(VALUE_OPERATOR op,CValue *val)
 640 {
 641         //assert(false); // todo: implement me!
 642         static int error_printed =  0;
 643         if (error_printed==0) {
 644                 fprintf(stderr, "CValueList::Calc not yet implimented\n");
 645                 error_printed = 1;
 646         }
 647         return NULL;
 648 }
 649
 650 CValue* CListValue::CalcFinal(VALUE_DATA_TYPE dtype,
 651                                                           VALUE_OPERATOR op,
 652                                                           CValue* val)
 653 {
 654         //assert(false); // todo: implement me!
 655         static int error_printed =  0;
 656         if (error_printed==0) {
 657                 fprintf(stderr, "CValueList::CalcFinal not yet implimented\n");
 658                 error_printed = 1;
 659         }
 660         return NULL;
 661 }
 662
 663
 664
 665 void CListValue::Add(CValue* value)
 666 {
 667         m_pValueArray.push_back(value);
 668 }
 669
 670
 671
 672 double CListValue::GetNumber()
 673 {
 674         return -1;
 675 }
 676
 677
 678
 679 void CListValue::SetModified(bool bModified)
 680 {
 681         CValue::SetModified(bModified);
 682         int numels = GetCount();
 683
 684         for (int i=0;i<numels;i++)
 685                 GetValue(i)->SetModified(bModified);
 686 }
 687
 688
 689
 690 bool CListValue::IsModified()
 691 {
 692         bool bmod = CValue::IsModified(); //normal own flag
 693         int numels = GetCount();
 694
 695         for (int i=0;i<numels;i++)
 696                 bmod = bmod || GetValue(i)->IsModified();
 697
 698         return bmod;
 699 }