1 // Protocol Buffers - Google's data interchange format 2 // Copyright 2008 Google Inc. All rights reserved. 3 // http://code.google.com/p/protobuf/ 4 // 5 // Redistribution and use in source and binary forms, with or without 6 // modification, are permitted provided that the following conditions are 7 // met: 8 // 9 // * Redistributions of source code must retain the above copyright 10 // notice, this list of conditions and the following disclaimer. 11 // * Redistributions in binary form must reproduce the above 12 // copyright notice, this list of conditions and the following disclaimer 13 // in the documentation and/or other materials provided with the 14 // distribution. 15 // * Neither the name of Google Inc. nor the names of its 16 // contributors may be used to endorse or promote products derived from 17 // this software without specific prior written permission. 18 // 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 30 31 // Author: petar (at) google.com (Petar Petrov) 32 33 #include <Python.h> 34 #include <map> 35 #include <string> 36 #include <vector> 37 38 #include <google/protobuf/stubs/common.h> 39 #include <google/protobuf/pyext/python_descriptor.h> 40 #include <google/protobuf/io/coded_stream.h> 41 #include <google/protobuf/descriptor.h> 42 #include <google/protobuf/dynamic_message.h> 43 #include <google/protobuf/message.h> 44 #include <google/protobuf/unknown_field_set.h> 45 #include <google/protobuf/pyext/python_protobuf.h> 46 47 /* Is 64bit */ 48 #define IS_64BIT (SIZEOF_LONG == 8) 49 50 #define FIELD_BELONGS_TO_MESSAGE(field_descriptor, message) \ 51 ((message)->GetDescriptor() == (field_descriptor)->containing_type()) 52 53 #define FIELD_IS_REPEATED(field_descriptor) \ 54 ((field_descriptor)->label() == google::protobuf::FieldDescriptor::LABEL_REPEATED) 55 56 #define GOOGLE_CHECK_GET_INT32(arg, value) \ 57 int32 value; \ 58 if (!CheckAndGetInteger(arg, &value, kint32min_py, kint32max_py)) { \ 59 return NULL; \ 60 } 61 62 #define GOOGLE_CHECK_GET_INT64(arg, value) \ 63 int64 value; \ 64 if (!CheckAndGetInteger(arg, &value, kint64min_py, kint64max_py)) { \ 65 return NULL; \ 66 } 67 68 #define GOOGLE_CHECK_GET_UINT32(arg, value) \ 69 uint32 value; \ 70 if (!CheckAndGetInteger(arg, &value, kPythonZero, kuint32max_py)) { \ 71 return NULL; \ 72 } 73 74 #define GOOGLE_CHECK_GET_UINT64(arg, value) \ 75 uint64 value; \ 76 if (!CheckAndGetInteger(arg, &value, kPythonZero, kuint64max_py)) { \ 77 return NULL; \ 78 } 79 80 #define GOOGLE_CHECK_GET_FLOAT(arg, value) \ 81 float value; \ 82 if (!CheckAndGetFloat(arg, &value)) { \ 83 return NULL; \ 84 } \ 85 86 #define GOOGLE_CHECK_GET_DOUBLE(arg, value) \ 87 double value; \ 88 if (!CheckAndGetDouble(arg, &value)) { \ 89 return NULL; \ 90 } 91 92 #define GOOGLE_CHECK_GET_BOOL(arg, value) \ 93 bool value; \ 94 if (!CheckAndGetBool(arg, &value)) { \ 95 return NULL; \ 96 } 97 98 #define C(str) const_cast<char*>(str) 99 100 // --- Globals: 101 102 // Constants used for integer type range checking. 103 static PyObject* kPythonZero; 104 static PyObject* kint32min_py; 105 static PyObject* kint32max_py; 106 static PyObject* kuint32max_py; 107 static PyObject* kint64min_py; 108 static PyObject* kint64max_py; 109 static PyObject* kuint64max_py; 110 111 namespace google { 112 namespace protobuf { 113 namespace python { 114 115 // --- Support Routines: 116 117 static void AddConstants(PyObject* module) { 118 struct NameValue { 119 char* name; 120 int32 value; 121 } constants[] = { 122 // Labels: 123 {"LABEL_OPTIONAL", google::protobuf::FieldDescriptor::LABEL_OPTIONAL}, 124 {"LABEL_REQUIRED", google::protobuf::FieldDescriptor::LABEL_REQUIRED}, 125 {"LABEL_REPEATED", google::protobuf::FieldDescriptor::LABEL_REPEATED}, 126 // CPP types: 127 {"CPPTYPE_MESSAGE", google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE}, 128 // Field Types: 129 {"TYPE_MESSAGE", google::protobuf::FieldDescriptor::TYPE_MESSAGE}, 130 // End. 131 {NULL, 0} 132 }; 133 134 for (NameValue* constant = constants; 135 constant->name != NULL; constant++) { 136 PyModule_AddIntConstant(module, constant->name, constant->value); 137 } 138 } 139 140 // --- CMessage Custom Type: 141 142 // ------ Type Forward Declaration: 143 144 struct CMessage; 145 struct CMessage_Type; 146 147 static void CMessageDealloc(CMessage* self); 148 static int CMessageInit(CMessage* self, PyObject *args, PyObject *kwds); 149 static PyObject* CMessageStr(CMessage* self); 150 151 static PyObject* CMessage_AddMessage(CMessage* self, PyObject* args); 152 static PyObject* CMessage_AddRepeatedScalar(CMessage* self, PyObject* args); 153 static PyObject* CMessage_AssignRepeatedScalar(CMessage* self, PyObject* args); 154 static PyObject* CMessage_ByteSize(CMessage* self, PyObject* args); 155 static PyObject* CMessage_Clear(CMessage* self, PyObject* args); 156 static PyObject* CMessage_ClearField(CMessage* self, PyObject* args); 157 static PyObject* CMessage_ClearFieldByDescriptor( 158 CMessage* self, PyObject* args); 159 static PyObject* CMessage_CopyFrom(CMessage* self, PyObject* args); 160 static PyObject* CMessage_DebugString(CMessage* self, PyObject* args); 161 static PyObject* CMessage_DeleteRepeatedField(CMessage* self, PyObject* args); 162 static PyObject* CMessage_Equals(CMessage* self, PyObject* args); 163 static PyObject* CMessage_FieldLength(CMessage* self, PyObject* args); 164 static PyObject* CMessage_FindInitializationErrors(CMessage* self); 165 static PyObject* CMessage_GetRepeatedMessage(CMessage* self, PyObject* args); 166 static PyObject* CMessage_GetRepeatedScalar(CMessage* self, PyObject* args); 167 static PyObject* CMessage_GetScalar(CMessage* self, PyObject* args); 168 static PyObject* CMessage_HasField(CMessage* self, PyObject* args); 169 static PyObject* CMessage_HasFieldByDescriptor(CMessage* self, PyObject* args); 170 static PyObject* CMessage_IsInitialized(CMessage* self, PyObject* args); 171 static PyObject* CMessage_ListFields(CMessage* self, PyObject* args); 172 static PyObject* CMessage_MergeFrom(CMessage* self, PyObject* args); 173 static PyObject* CMessage_MergeFromString(CMessage* self, PyObject* args); 174 static PyObject* CMessage_MutableMessage(CMessage* self, PyObject* args); 175 static PyObject* CMessage_NewSubMessage(CMessage* self, PyObject* args); 176 static PyObject* CMessage_SetScalar(CMessage* self, PyObject* args); 177 static PyObject* CMessage_SerializePartialToString( 178 CMessage* self, PyObject* args); 179 static PyObject* CMessage_SerializeToString(CMessage* self, PyObject* args); 180 static PyObject* CMessage_SetInParent(CMessage* self, PyObject* args); 181 static PyObject* CMessage_SwapRepeatedFieldElements( 182 CMessage* self, PyObject* args); 183 184 // ------ Object Definition: 185 186 typedef struct CMessage { 187 PyObject_HEAD 188 189 struct CMessage* parent; // NULL if wasn't created from another message. 190 CFieldDescriptor* parent_field; 191 const char* full_name; 192 google::protobuf::Message* message; 193 bool free_message; 194 bool read_only; 195 } CMessage; 196 197 // ------ Method Table: 198 199 #define CMETHOD(name, args, doc) \ 200 { C(#name), (PyCFunction)CMessage_##name, args, C(doc) } 201 static PyMethodDef CMessageMethods[] = { 202 CMETHOD(AddMessage, METH_O, 203 "Adds a new message to a repeated composite field."), 204 CMETHOD(AddRepeatedScalar, METH_VARARGS, 205 "Adds a scalar to a repeated scalar field."), 206 CMETHOD(AssignRepeatedScalar, METH_VARARGS, 207 "Clears and sets the values of a repeated scalar field."), 208 CMETHOD(ByteSize, METH_NOARGS, 209 "Returns the size of the message in bytes."), 210 CMETHOD(Clear, METH_O, 211 "Clears a protocol message."), 212 CMETHOD(ClearField, METH_VARARGS, 213 "Clears a protocol message field by name."), 214 CMETHOD(ClearFieldByDescriptor, METH_O, 215 "Clears a protocol message field by descriptor."), 216 CMETHOD(CopyFrom, METH_O, 217 "Copies a protocol message into the current message."), 218 CMETHOD(DebugString, METH_NOARGS, 219 "Returns the debug string of a protocol message."), 220 CMETHOD(DeleteRepeatedField, METH_VARARGS, 221 "Deletes a slice of values from a repeated field."), 222 CMETHOD(Equals, METH_O, 223 "Checks if two protocol messages are equal (by identity)."), 224 CMETHOD(FieldLength, METH_O, 225 "Returns the number of elements in a repeated field."), 226 CMETHOD(FindInitializationErrors, METH_NOARGS, 227 "Returns the initialization errors of a message."), 228 CMETHOD(GetRepeatedMessage, METH_VARARGS, 229 "Returns a message from a repeated composite field."), 230 CMETHOD(GetRepeatedScalar, METH_VARARGS, 231 "Returns a scalar value from a repeated scalar field."), 232 CMETHOD(GetScalar, METH_O, 233 "Returns the scalar value of a field."), 234 CMETHOD(HasField, METH_O, 235 "Checks if a message field is set."), 236 CMETHOD(HasFieldByDescriptor, METH_O, 237 "Checks if a message field is set by given its descriptor"), 238 CMETHOD(IsInitialized, METH_NOARGS, 239 "Checks if all required fields of a protocol message are set."), 240 CMETHOD(ListFields, METH_NOARGS, 241 "Lists all set fields of a message."), 242 CMETHOD(MergeFrom, METH_O, 243 "Merges a protocol message into the current message."), 244 CMETHOD(MergeFromString, METH_O, 245 "Merges a serialized message into the current message."), 246 CMETHOD(MutableMessage, METH_O, 247 "Returns a new instance of a nested protocol message."), 248 CMETHOD(NewSubMessage, METH_O, 249 "Creates and returns a python message given the descriptor of a " 250 "composite field of the current message."), 251 CMETHOD(SetScalar, METH_VARARGS, 252 "Sets the value of a singular scalar field."), 253 CMETHOD(SerializePartialToString, METH_VARARGS, 254 "Serializes the message to a string, even if it isn't initialized."), 255 CMETHOD(SerializeToString, METH_NOARGS, 256 "Serializes the message to a string, only for initialized messages."), 257 CMETHOD(SetInParent, METH_NOARGS, 258 "Sets the has bit of the given field in its parent message."), 259 CMETHOD(SwapRepeatedFieldElements, METH_VARARGS, 260 "Swaps the elements in two positions in a repeated field."), 261 { NULL, NULL } 262 }; 263 #undef CMETHOD 264 265 static PyMemberDef CMessageMembers[] = { 266 { C("full_name"), T_STRING, offsetof(CMessage, full_name), 0, "Full name" }, 267 { NULL } 268 }; 269 270 // ------ Type Definition: 271 272 // The definition for the type object that captures the type of CMessage 273 // in Python. 274 PyTypeObject CMessage_Type = { 275 PyObject_HEAD_INIT(&PyType_Type) 276 0, 277 C("google.protobuf.internal." 278 "_net_proto2___python." 279 "CMessage"), // tp_name 280 sizeof(CMessage), // tp_basicsize 281 0, // tp_itemsize 282 (destructor)CMessageDealloc, // tp_dealloc 283 0, // tp_print 284 0, // tp_getattr 285 0, // tp_setattr 286 0, // tp_compare 287 0, // tp_repr 288 0, // tp_as_number 289 0, // tp_as_sequence 290 0, // tp_as_mapping 291 0, // tp_hash 292 0, // tp_call 293 (reprfunc)CMessageStr, // tp_str 294 0, // tp_getattro 295 0, // tp_setattro 296 0, // tp_as_buffer 297 Py_TPFLAGS_DEFAULT, // tp_flags 298 C("A ProtocolMessage"), // tp_doc 299 0, // tp_traverse 300 0, // tp_clear 301 0, // tp_richcompare 302 0, // tp_weaklistoffset 303 0, // tp_iter 304 0, // tp_iternext 305 CMessageMethods, // tp_methods 306 CMessageMembers, // tp_members 307 0, // tp_getset 308 0, // tp_base 309 0, // tp_dict 310 0, // tp_descr_get 311 0, // tp_descr_set 312 0, // tp_dictoffset 313 (initproc)CMessageInit, // tp_init 314 PyType_GenericAlloc, // tp_alloc 315 PyType_GenericNew, // tp_new 316 PyObject_Del, // tp_free 317 }; 318 319 // ------ Helper Functions: 320 321 static void FormatTypeError(PyObject* arg, char* expected_types) { 322 PyObject* repr = PyObject_Repr(arg); 323 PyErr_Format(PyExc_TypeError, 324 "%.100s has type %.100s, but expected one of: %s", 325 PyString_AS_STRING(repr), 326 arg->ob_type->tp_name, 327 expected_types); 328 Py_DECREF(repr); 329 } 330 331 template <class T> 332 static bool CheckAndGetInteger( 333 PyObject* arg, T* value, PyObject* min, PyObject* max) { 334 bool is_long = PyLong_Check(arg); 335 if (!PyInt_Check(arg) && !is_long) { 336 FormatTypeError(arg, "int, long"); 337 return false; 338 } 339 340 if (PyObject_Compare(min, arg) > 0 || PyObject_Compare(max, arg) < 0) { 341 PyObject* s = PyObject_Str(arg); 342 PyErr_Format(PyExc_ValueError, 343 "Value out of range: %s", 344 PyString_AS_STRING(s)); 345 Py_DECREF(s); 346 return false; 347 } 348 if (is_long) { 349 if (min == kPythonZero) { 350 *value = static_cast<T>(PyLong_AsUnsignedLongLong(arg)); 351 } else { 352 *value = static_cast<T>(PyLong_AsLongLong(arg)); 353 } 354 } else { 355 *value = static_cast<T>(PyInt_AsLong(arg)); 356 } 357 return true; 358 } 359 360 static bool CheckAndGetDouble(PyObject* arg, double* value) { 361 if (!PyInt_Check(arg) && !PyLong_Check(arg) && 362 !PyFloat_Check(arg)) { 363 FormatTypeError(arg, "int, long, float"); 364 return false; 365 } 366 *value = PyFloat_AsDouble(arg); 367 return true; 368 } 369 370 static bool CheckAndGetFloat(PyObject* arg, float* value) { 371 double double_value; 372 if (!CheckAndGetDouble(arg, &double_value)) { 373 return false; 374 } 375 *value = static_cast<float>(double_value); 376 return true; 377 } 378 379 static bool CheckAndGetBool(PyObject* arg, bool* value) { 380 if (!PyInt_Check(arg) && !PyBool_Check(arg) && !PyLong_Check(arg)) { 381 FormatTypeError(arg, "int, long, bool"); 382 return false; 383 } 384 *value = static_cast<bool>(PyInt_AsLong(arg)); 385 return true; 386 } 387 388 google::protobuf::DynamicMessageFactory* global_message_factory = NULL; 389 static const google::protobuf::Message* CreateMessage(const char* message_type) { 390 string message_name(message_type); 391 const google::protobuf::Descriptor* descriptor = 392 GetDescriptorPool()->FindMessageTypeByName(message_name); 393 if (descriptor == NULL) { 394 return NULL; 395 } 396 return global_message_factory->GetPrototype(descriptor); 397 } 398 399 static void ReleaseSubMessage(google::protobuf::Message* message, 400 const google::protobuf::FieldDescriptor* field_descriptor, 401 CMessage* child_cmessage) { 402 Message* released_message = message->GetReflection()->ReleaseMessage( 403 message, field_descriptor, global_message_factory); 404 GOOGLE_DCHECK(child_cmessage->message != NULL); 405 // ReleaseMessage will return NULL which differs from 406 // child_cmessage->message, if the field does not exist. In this case, 407 // the latter points to the default instance via a const_cast<>, so we 408 // have to reset it to a new mutable object since we are taking ownership. 409 if (released_message == NULL) { 410 const Message* prototype = global_message_factory->GetPrototype( 411 child_cmessage->message->GetDescriptor()); 412 GOOGLE_DCHECK(prototype != NULL); 413 child_cmessage->message = prototype->New(); 414 } 415 child_cmessage->parent = NULL; 416 child_cmessage->parent_field = NULL; 417 child_cmessage->free_message = true; 418 child_cmessage->read_only = false; 419 } 420 421 static bool CheckAndSetString( 422 PyObject* arg, google::protobuf::Message* message, 423 const google::protobuf::FieldDescriptor* descriptor, 424 const google::protobuf::Reflection* reflection, 425 bool append, 426 int index) { 427 GOOGLE_DCHECK(descriptor->type() == google::protobuf::FieldDescriptor::TYPE_STRING || 428 descriptor->type() == google::protobuf::FieldDescriptor::TYPE_BYTES); 429 if (descriptor->type() == google::protobuf::FieldDescriptor::TYPE_STRING) { 430 if (!PyString_Check(arg) && !PyUnicode_Check(arg)) { 431 FormatTypeError(arg, "str, unicode"); 432 return false; 433 } 434 435 if (PyString_Check(arg)) { 436 PyObject* unicode = PyUnicode_FromEncodedObject(arg, "ascii", NULL); 437 if (unicode == NULL) { 438 PyObject* repr = PyObject_Repr(arg); 439 PyErr_Format(PyExc_ValueError, 440 "%s has type str, but isn't in 7-bit ASCII " 441 "encoding. Non-ASCII strings must be converted to " 442 "unicode objects before being added.", 443 PyString_AS_STRING(repr)); 444 Py_DECREF(repr); 445 return false; 446 } else { 447 Py_DECREF(unicode); 448 } 449 } 450 } else if (!PyString_Check(arg)) { 451 FormatTypeError(arg, "str"); 452 return false; 453 } 454 455 PyObject* encoded_string = NULL; 456 if (descriptor->type() == google::protobuf::FieldDescriptor::TYPE_STRING) { 457 if (PyString_Check(arg)) { 458 encoded_string = PyString_AsEncodedObject(arg, "utf-8", NULL); 459 } else { 460 encoded_string = PyUnicode_AsEncodedObject(arg, "utf-8", NULL); 461 } 462 } else { 463 // In this case field type is "bytes". 464 encoded_string = arg; 465 Py_INCREF(encoded_string); 466 } 467 468 if (encoded_string == NULL) { 469 return false; 470 } 471 472 char* value; 473 Py_ssize_t value_len; 474 if (PyString_AsStringAndSize(encoded_string, &value, &value_len) < 0) { 475 Py_DECREF(encoded_string); 476 return false; 477 } 478 479 string value_string(value, value_len); 480 if (append) { 481 reflection->AddString(message, descriptor, value_string); 482 } else if (index < 0) { 483 reflection->SetString(message, descriptor, value_string); 484 } else { 485 reflection->SetRepeatedString(message, descriptor, index, value_string); 486 } 487 Py_DECREF(encoded_string); 488 return true; 489 } 490 491 static PyObject* ToStringObject( 492 const google::protobuf::FieldDescriptor* descriptor, string value) { 493 if (descriptor->type() != google::protobuf::FieldDescriptor::TYPE_STRING) { 494 return PyString_FromStringAndSize(value.c_str(), value.length()); 495 } 496 497 PyObject* result = PyUnicode_DecodeUTF8(value.c_str(), value.length(), NULL); 498 // If the string can't be decoded in UTF-8, just return a string object that 499 // contains the raw bytes. This can't happen if the value was assigned using 500 // the members of the Python message object, but can happen if the values were 501 // parsed from the wire (binary). 502 if (result == NULL) { 503 PyErr_Clear(); 504 result = PyString_FromStringAndSize(value.c_str(), value.length()); 505 } 506 return result; 507 } 508 509 static void AssureWritable(CMessage* self) { 510 if (self == NULL || 511 self->parent == NULL || 512 self->parent_field == NULL) { 513 return; 514 } 515 516 if (!self->read_only) { 517 return; 518 } 519 520 AssureWritable(self->parent); 521 522 google::protobuf::Message* message = self->parent->message; 523 const google::protobuf::Reflection* reflection = message->GetReflection(); 524 self->message = reflection->MutableMessage( 525 message, self->parent_field->descriptor, global_message_factory); 526 self->read_only = false; 527 } 528 529 static PyObject* InternalGetScalar( 530 google::protobuf::Message* message, 531 const google::protobuf::FieldDescriptor* field_descriptor) { 532 const google::protobuf::Reflection* reflection = message->GetReflection(); 533 534 if (!FIELD_BELONGS_TO_MESSAGE(field_descriptor, message)) { 535 PyErr_SetString( 536 PyExc_KeyError, "Field does not belong to message!"); 537 return NULL; 538 } 539 540 PyObject* result = NULL; 541 switch (field_descriptor->cpp_type()) { 542 case google::protobuf::FieldDescriptor::CPPTYPE_INT32: { 543 int32 value = reflection->GetInt32(*message, field_descriptor); 544 result = PyInt_FromLong(value); 545 break; 546 } 547 case google::protobuf::FieldDescriptor::CPPTYPE_INT64: { 548 int64 value = reflection->GetInt64(*message, field_descriptor); 549 #if IS_64BIT 550 result = PyInt_FromLong(value); 551 #else 552 result = PyLong_FromLongLong(value); 553 #endif 554 break; 555 } 556 case google::protobuf::FieldDescriptor::CPPTYPE_UINT32: { 557 uint32 value = reflection->GetUInt32(*message, field_descriptor); 558 #if IS_64BIT 559 result = PyInt_FromLong(value); 560 #else 561 result = PyLong_FromLongLong(value); 562 #endif 563 break; 564 } 565 case google::protobuf::FieldDescriptor::CPPTYPE_UINT64: { 566 uint64 value = reflection->GetUInt64(*message, field_descriptor); 567 #if IS_64BIT 568 if (value <= static_cast<uint64>(kint64max)) { 569 result = PyInt_FromLong(static_cast<uint64>(value)); 570 } 571 #else 572 if (value <= static_cast<uint32>(kint32max)) { 573 result = PyInt_FromLong(static_cast<uint32>(value)); 574 } 575 #endif 576 else { // NOLINT 577 result = PyLong_FromUnsignedLongLong(value); 578 } 579 break; 580 } 581 case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT: { 582 float value = reflection->GetFloat(*message, field_descriptor); 583 result = PyFloat_FromDouble(value); 584 break; 585 } 586 case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE: { 587 double value = reflection->GetDouble(*message, field_descriptor); 588 result = PyFloat_FromDouble(value); 589 break; 590 } 591 case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: { 592 bool value = reflection->GetBool(*message, field_descriptor); 593 result = PyBool_FromLong(value); 594 break; 595 } 596 case google::protobuf::FieldDescriptor::CPPTYPE_STRING: { 597 string value = reflection->GetString(*message, field_descriptor); 598 result = ToStringObject(field_descriptor, value); 599 break; 600 } 601 case google::protobuf::FieldDescriptor::CPPTYPE_ENUM: { 602 if (!message->GetReflection()->HasField(*message, field_descriptor)) { 603 // Look for the value in the unknown fields. 604 google::protobuf::UnknownFieldSet* unknown_field_set = 605 message->GetReflection()->MutableUnknownFields(message); 606 for (int i = 0; i < unknown_field_set->field_count(); ++i) { 607 if (unknown_field_set->field(i).number() == 608 field_descriptor->number()) { 609 result = PyInt_FromLong(unknown_field_set->field(i).varint()); 610 break; 611 } 612 } 613 } 614 615 if (result == NULL) { 616 const google::protobuf::EnumValueDescriptor* enum_value = 617 message->GetReflection()->GetEnum(*message, field_descriptor); 618 result = PyInt_FromLong(enum_value->number()); 619 } 620 break; 621 } 622 default: 623 PyErr_Format( 624 PyExc_SystemError, "Getting a value from a field of unknown type %d", 625 field_descriptor->cpp_type()); 626 } 627 628 return result; 629 } 630 631 static PyObject* InternalSetScalar( 632 google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field_descriptor, 633 PyObject* arg) { 634 const google::protobuf::Reflection* reflection = message->GetReflection(); 635 636 if (!FIELD_BELONGS_TO_MESSAGE(field_descriptor, message)) { 637 PyErr_SetString( 638 PyExc_KeyError, "Field does not belong to message!"); 639 return NULL; 640 } 641 642 switch (field_descriptor->cpp_type()) { 643 case google::protobuf::FieldDescriptor::CPPTYPE_INT32: { 644 GOOGLE_CHECK_GET_INT32(arg, value); 645 reflection->SetInt32(message, field_descriptor, value); 646 break; 647 } 648 case google::protobuf::FieldDescriptor::CPPTYPE_INT64: { 649 GOOGLE_CHECK_GET_INT64(arg, value); 650 reflection->SetInt64(message, field_descriptor, value); 651 break; 652 } 653 case google::protobuf::FieldDescriptor::CPPTYPE_UINT32: { 654 GOOGLE_CHECK_GET_UINT32(arg, value); 655 reflection->SetUInt32(message, field_descriptor, value); 656 break; 657 } 658 case google::protobuf::FieldDescriptor::CPPTYPE_UINT64: { 659 GOOGLE_CHECK_GET_UINT64(arg, value); 660 reflection->SetUInt64(message, field_descriptor, value); 661 break; 662 } 663 case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT: { 664 GOOGLE_CHECK_GET_FLOAT(arg, value); 665 reflection->SetFloat(message, field_descriptor, value); 666 break; 667 } 668 case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE: { 669 GOOGLE_CHECK_GET_DOUBLE(arg, value); 670 reflection->SetDouble(message, field_descriptor, value); 671 break; 672 } 673 case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: { 674 GOOGLE_CHECK_GET_BOOL(arg, value); 675 reflection->SetBool(message, field_descriptor, value); 676 break; 677 } 678 case google::protobuf::FieldDescriptor::CPPTYPE_STRING: { 679 if (!CheckAndSetString( 680 arg, message, field_descriptor, reflection, false, -1)) { 681 return NULL; 682 } 683 break; 684 } 685 case google::protobuf::FieldDescriptor::CPPTYPE_ENUM: { 686 GOOGLE_CHECK_GET_INT32(arg, value); 687 const google::protobuf::EnumDescriptor* enum_descriptor = 688 field_descriptor->enum_type(); 689 const google::protobuf::EnumValueDescriptor* enum_value = 690 enum_descriptor->FindValueByNumber(value); 691 if (enum_value != NULL) { 692 reflection->SetEnum(message, field_descriptor, enum_value); 693 } else { 694 bool added = false; 695 // Add the value to the unknown fields. 696 google::protobuf::UnknownFieldSet* unknown_field_set = 697 message->GetReflection()->MutableUnknownFields(message); 698 for (int i = 0; i < unknown_field_set->field_count(); ++i) { 699 if (unknown_field_set->field(i).number() == 700 field_descriptor->number()) { 701 unknown_field_set->mutable_field(i)->set_varint(value); 702 added = true; 703 break; 704 } 705 } 706 707 if (!added) { 708 unknown_field_set->AddVarint(field_descriptor->number(), value); 709 } 710 reflection->ClearField(message, field_descriptor); 711 } 712 break; 713 } 714 default: 715 PyErr_Format( 716 PyExc_SystemError, "Setting value to a field of unknown type %d", 717 field_descriptor->cpp_type()); 718 } 719 720 Py_RETURN_NONE; 721 } 722 723 static PyObject* InternalAddRepeatedScalar( 724 google::protobuf::Message* message, const google::protobuf::FieldDescriptor* field_descriptor, 725 PyObject* arg) { 726 727 if (!FIELD_BELONGS_TO_MESSAGE(field_descriptor, message)) { 728 PyErr_SetString( 729 PyExc_KeyError, "Field does not belong to message!"); 730 return NULL; 731 } 732 733 const google::protobuf::Reflection* reflection = message->GetReflection(); 734 switch (field_descriptor->cpp_type()) { 735 case google::protobuf::FieldDescriptor::CPPTYPE_INT32: { 736 GOOGLE_CHECK_GET_INT32(arg, value); 737 reflection->AddInt32(message, field_descriptor, value); 738 break; 739 } 740 case google::protobuf::FieldDescriptor::CPPTYPE_INT64: { 741 GOOGLE_CHECK_GET_INT64(arg, value); 742 reflection->AddInt64(message, field_descriptor, value); 743 break; 744 } 745 case google::protobuf::FieldDescriptor::CPPTYPE_UINT32: { 746 GOOGLE_CHECK_GET_UINT32(arg, value); 747 reflection->AddUInt32(message, field_descriptor, value); 748 break; 749 } 750 case google::protobuf::FieldDescriptor::CPPTYPE_UINT64: { 751 GOOGLE_CHECK_GET_UINT64(arg, value); 752 reflection->AddUInt64(message, field_descriptor, value); 753 break; 754 } 755 case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT: { 756 GOOGLE_CHECK_GET_FLOAT(arg, value); 757 reflection->AddFloat(message, field_descriptor, value); 758 break; 759 } 760 case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE: { 761 GOOGLE_CHECK_GET_DOUBLE(arg, value); 762 reflection->AddDouble(message, field_descriptor, value); 763 break; 764 } 765 case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: { 766 GOOGLE_CHECK_GET_BOOL(arg, value); 767 reflection->AddBool(message, field_descriptor, value); 768 break; 769 } 770 case google::protobuf::FieldDescriptor::CPPTYPE_STRING: { 771 if (!CheckAndSetString( 772 arg, message, field_descriptor, reflection, true, -1)) { 773 return NULL; 774 } 775 break; 776 } 777 case google::protobuf::FieldDescriptor::CPPTYPE_ENUM: { 778 GOOGLE_CHECK_GET_INT32(arg, value); 779 const google::protobuf::EnumDescriptor* enum_descriptor = 780 field_descriptor->enum_type(); 781 const google::protobuf::EnumValueDescriptor* enum_value = 782 enum_descriptor->FindValueByNumber(value); 783 if (enum_value != NULL) { 784 reflection->AddEnum(message, field_descriptor, enum_value); 785 } else { 786 PyObject* s = PyObject_Str(arg); 787 PyErr_Format(PyExc_ValueError, "Unknown enum value: %s", 788 PyString_AS_STRING(s)); 789 Py_DECREF(s); 790 return NULL; 791 } 792 break; 793 } 794 default: 795 PyErr_Format( 796 PyExc_SystemError, "Adding value to a field of unknown type %d", 797 field_descriptor->cpp_type()); 798 } 799 800 Py_RETURN_NONE; 801 } 802 803 static PyObject* InternalGetRepeatedScalar( 804 CMessage* cmessage, const google::protobuf::FieldDescriptor* field_descriptor, 805 int index) { 806 google::protobuf::Message* message = cmessage->message; 807 const google::protobuf::Reflection* reflection = message->GetReflection(); 808 809 int field_size = reflection->FieldSize(*message, field_descriptor); 810 if (index < 0) { 811 index = field_size + index; 812 } 813 if (index < 0 || index >= field_size) { 814 PyErr_Format(PyExc_IndexError, 815 "list assignment index (%d) out of range", index); 816 return NULL; 817 } 818 819 PyObject* result = NULL; 820 switch (field_descriptor->cpp_type()) { 821 case google::protobuf::FieldDescriptor::CPPTYPE_INT32: { 822 int32 value = reflection->GetRepeatedInt32( 823 *message, field_descriptor, index); 824 result = PyInt_FromLong(value); 825 break; 826 } 827 case google::protobuf::FieldDescriptor::CPPTYPE_INT64: { 828 int64 value = reflection->GetRepeatedInt64( 829 *message, field_descriptor, index); 830 result = PyLong_FromLongLong(value); 831 break; 832 } 833 case google::protobuf::FieldDescriptor::CPPTYPE_UINT32: { 834 uint32 value = reflection->GetRepeatedUInt32( 835 *message, field_descriptor, index); 836 result = PyLong_FromLongLong(value); 837 break; 838 } 839 case google::protobuf::FieldDescriptor::CPPTYPE_UINT64: { 840 uint64 value = reflection->GetRepeatedUInt64( 841 *message, field_descriptor, index); 842 result = PyLong_FromUnsignedLongLong(value); 843 break; 844 } 845 case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT: { 846 float value = reflection->GetRepeatedFloat( 847 *message, field_descriptor, index); 848 result = PyFloat_FromDouble(value); 849 break; 850 } 851 case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE: { 852 double value = reflection->GetRepeatedDouble( 853 *message, field_descriptor, index); 854 result = PyFloat_FromDouble(value); 855 break; 856 } 857 case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: { 858 bool value = reflection->GetRepeatedBool( 859 *message, field_descriptor, index); 860 result = PyBool_FromLong(value ? 1 : 0); 861 break; 862 } 863 case google::protobuf::FieldDescriptor::CPPTYPE_ENUM: { 864 const google::protobuf::EnumValueDescriptor* enum_value = 865 message->GetReflection()->GetRepeatedEnum( 866 *message, field_descriptor, index); 867 result = PyInt_FromLong(enum_value->number()); 868 break; 869 } 870 case google::protobuf::FieldDescriptor::CPPTYPE_STRING: { 871 string value = reflection->GetRepeatedString( 872 *message, field_descriptor, index); 873 result = ToStringObject(field_descriptor, value); 874 break; 875 } 876 case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE: { 877 CMessage* py_cmsg = PyObject_New(CMessage, &CMessage_Type); 878 if (py_cmsg == NULL) { 879 return NULL; 880 } 881 const google::protobuf::Message& msg = reflection->GetRepeatedMessage( 882 *message, field_descriptor, index); 883 py_cmsg->parent = cmessage; 884 py_cmsg->full_name = field_descriptor->full_name().c_str(); 885 py_cmsg->message = const_cast<google::protobuf::Message*>(&msg); 886 py_cmsg->free_message = false; 887 py_cmsg->read_only = false; 888 result = reinterpret_cast<PyObject*>(py_cmsg); 889 break; 890 } 891 default: 892 PyErr_Format( 893 PyExc_SystemError, 894 "Getting value from a repeated field of unknown type %d", 895 field_descriptor->cpp_type()); 896 } 897 898 return result; 899 } 900 901 static PyObject* InternalGetRepeatedScalarSlice( 902 CMessage* cmessage, const google::protobuf::FieldDescriptor* field_descriptor, 903 PyObject* slice) { 904 Py_ssize_t from; 905 Py_ssize_t to; 906 Py_ssize_t step; 907 Py_ssize_t length; 908 bool return_list = false; 909 google::protobuf::Message* message = cmessage->message; 910 911 if (PyInt_Check(slice)) { 912 from = to = PyInt_AsLong(slice); 913 } else if (PyLong_Check(slice)) { 914 from = to = PyLong_AsLong(slice); 915 } else if (PySlice_Check(slice)) { 916 const google::protobuf::Reflection* reflection = message->GetReflection(); 917 length = reflection->FieldSize(*message, field_descriptor); 918 PySlice_GetIndices( 919 reinterpret_cast<PySliceObject*>(slice), length, &from, &to, &step); 920 return_list = true; 921 } else { 922 PyErr_SetString(PyExc_TypeError, "list indices must be integers"); 923 return NULL; 924 } 925 926 if (!return_list) { 927 return InternalGetRepeatedScalar(cmessage, field_descriptor, from); 928 } 929 930 PyObject* list = PyList_New(0); 931 if (list == NULL) { 932 return NULL; 933 } 934 935 if (from <= to) { 936 if (step < 0) return list; 937 for (Py_ssize_t index = from; index < to; index += step) { 938 if (index < 0 || index >= length) break; 939 PyObject* s = InternalGetRepeatedScalar( 940 cmessage, field_descriptor, index); 941 PyList_Append(list, s); 942 Py_DECREF(s); 943 } 944 } else { 945 if (step > 0) return list; 946 for (Py_ssize_t index = from; index > to; index += step) { 947 if (index < 0 || index >= length) break; 948 PyObject* s = InternalGetRepeatedScalar( 949 cmessage, field_descriptor, index); 950 PyList_Append(list, s); 951 Py_DECREF(s); 952 } 953 } 954 return list; 955 } 956 957 // ------ C Constructor/Destructor: 958 959 static int CMessageInit(CMessage* self, PyObject *args, PyObject *kwds) { 960 self->message = NULL; 961 return 0; 962 } 963 964 static void CMessageDealloc(CMessage* self) { 965 if (self->free_message) { 966 if (self->read_only) { 967 PyErr_WriteUnraisable(reinterpret_cast<PyObject*>(self)); 968 } 969 delete self->message; 970 } 971 self->ob_type->tp_free(reinterpret_cast<PyObject*>(self)); 972 } 973 974 // ------ Methods: 975 976 static PyObject* CMessage_Clear(CMessage* self, PyObject* arg) { 977 AssureWritable(self); 978 google::protobuf::Message* message = self->message; 979 980 // This block of code is equivalent to the following: 981 // for cfield_descriptor, child_cmessage in arg: 982 // ReleaseSubMessage(cfield_descriptor, child_cmessage) 983 if (!PyList_Check(arg)) { 984 PyErr_SetString(PyExc_TypeError, "Must be a list"); 985 return NULL; 986 } 987 PyObject* messages_to_clear = arg; 988 Py_ssize_t num_messages_to_clear = PyList_GET_SIZE(messages_to_clear); 989 for(int i = 0; i < num_messages_to_clear; ++i) { 990 PyObject* message_tuple = PyList_GET_ITEM(messages_to_clear, i); 991 if (!PyTuple_Check(message_tuple) || PyTuple_GET_SIZE(message_tuple) != 2) { 992 PyErr_SetString(PyExc_TypeError, "Must be a tuple of size 2"); 993 return NULL; 994 } 995 996 PyObject* py_cfield_descriptor = PyTuple_GET_ITEM(message_tuple, 0); 997 PyObject* py_child_cmessage = PyTuple_GET_ITEM(message_tuple, 1); 998 if (!PyObject_TypeCheck(py_cfield_descriptor, &CFieldDescriptor_Type) || 999 !PyObject_TypeCheck(py_child_cmessage, &CMessage_Type)) { 1000 PyErr_SetString(PyExc_ValueError, "Invalid Tuple"); 1001 return NULL; 1002 } 1003 1004 CFieldDescriptor* cfield_descriptor = reinterpret_cast<CFieldDescriptor *>( 1005 py_cfield_descriptor); 1006 CMessage* child_cmessage = reinterpret_cast<CMessage *>(py_child_cmessage); 1007 ReleaseSubMessage(message, cfield_descriptor->descriptor, child_cmessage); 1008 } 1009 1010 message->Clear(); 1011 Py_RETURN_NONE; 1012 } 1013 1014 static PyObject* CMessage_IsInitialized(CMessage* self, PyObject* args) { 1015 return PyBool_FromLong(self->message->IsInitialized() ? 1 : 0); 1016 } 1017 1018 static PyObject* CMessage_HasField(CMessage* self, PyObject* arg) { 1019 char* field_name; 1020 if (PyString_AsStringAndSize(arg, &field_name, NULL) < 0) { 1021 return NULL; 1022 } 1023 1024 google::protobuf::Message* message = self->message; 1025 const google::protobuf::Descriptor* descriptor = message->GetDescriptor(); 1026 const google::protobuf::FieldDescriptor* field_descriptor = 1027 descriptor->FindFieldByName(field_name); 1028 if (field_descriptor == NULL) { 1029 PyErr_Format(PyExc_ValueError, "Unknown field %s.", field_name); 1030 return NULL; 1031 } 1032 1033 bool has_field = 1034 message->GetReflection()->HasField(*message, field_descriptor); 1035 return PyBool_FromLong(has_field ? 1 : 0); 1036 } 1037 1038 static PyObject* CMessage_HasFieldByDescriptor(CMessage* self, PyObject* arg) { 1039 CFieldDescriptor* cfield_descriptor = NULL; 1040 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), 1041 &CFieldDescriptor_Type)) { 1042 PyErr_SetString(PyExc_TypeError, "Must be a field descriptor"); 1043 return NULL; 1044 } 1045 cfield_descriptor = reinterpret_cast<CFieldDescriptor*>(arg); 1046 1047 google::protobuf::Message* message = self->message; 1048 const google::protobuf::FieldDescriptor* field_descriptor = 1049 cfield_descriptor->descriptor; 1050 1051 if (!FIELD_BELONGS_TO_MESSAGE(field_descriptor, message)) { 1052 PyErr_SetString(PyExc_KeyError, 1053 "Field does not belong to message!"); 1054 return NULL; 1055 } 1056 1057 if (FIELD_IS_REPEATED(field_descriptor)) { 1058 PyErr_SetString(PyExc_KeyError, 1059 "Field is repeated. A singular method is required."); 1060 return NULL; 1061 } 1062 1063 bool has_field = 1064 message->GetReflection()->HasField(*message, field_descriptor); 1065 return PyBool_FromLong(has_field ? 1 : 0); 1066 } 1067 1068 static PyObject* CMessage_ClearFieldByDescriptor( 1069 CMessage* self, PyObject* arg) { 1070 CFieldDescriptor* cfield_descriptor = NULL; 1071 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), 1072 &CFieldDescriptor_Type)) { 1073 PyErr_SetString(PyExc_TypeError, "Must be a field descriptor"); 1074 return NULL; 1075 } 1076 cfield_descriptor = reinterpret_cast<CFieldDescriptor*>(arg); 1077 1078 google::protobuf::Message* message = self->message; 1079 const google::protobuf::FieldDescriptor* field_descriptor = 1080 cfield_descriptor->descriptor; 1081 1082 if (!FIELD_BELONGS_TO_MESSAGE(field_descriptor, message)) { 1083 PyErr_SetString(PyExc_KeyError, 1084 "Field does not belong to message!"); 1085 return NULL; 1086 } 1087 1088 message->GetReflection()->ClearField(message, field_descriptor); 1089 Py_RETURN_NONE; 1090 } 1091 1092 static PyObject* CMessage_ClearField(CMessage* self, PyObject* args) { 1093 char* field_name; 1094 CMessage* child_cmessage = NULL; 1095 if (!PyArg_ParseTuple(args, C("s|O!:ClearField"), &field_name, 1096 &CMessage_Type, &child_cmessage)) { 1097 return NULL; 1098 } 1099 1100 google::protobuf::Message* message = self->message; 1101 const google::protobuf::Descriptor* descriptor = message->GetDescriptor(); 1102 const google::protobuf::FieldDescriptor* field_descriptor = 1103 descriptor->FindFieldByName(field_name); 1104 if (field_descriptor == NULL) { 1105 PyErr_Format(PyExc_ValueError, "Unknown field %s.", field_name); 1106 return NULL; 1107 } 1108 1109 if (child_cmessage != NULL && !FIELD_IS_REPEATED(field_descriptor)) { 1110 ReleaseSubMessage(message, field_descriptor, child_cmessage); 1111 } else { 1112 message->GetReflection()->ClearField(message, field_descriptor); 1113 } 1114 Py_RETURN_NONE; 1115 } 1116 1117 static PyObject* CMessage_GetScalar(CMessage* self, PyObject* arg) { 1118 CFieldDescriptor* cdescriptor = NULL; 1119 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), 1120 &CFieldDescriptor_Type)) { 1121 PyErr_SetString(PyExc_TypeError, "Must be a field descriptor"); 1122 return NULL; 1123 } 1124 cdescriptor = reinterpret_cast<CFieldDescriptor*>(arg); 1125 1126 google::protobuf::Message* message = self->message; 1127 return InternalGetScalar(message, cdescriptor->descriptor); 1128 } 1129 1130 static PyObject* CMessage_GetRepeatedScalar(CMessage* self, PyObject* args) { 1131 CFieldDescriptor* cfield_descriptor; 1132 PyObject* slice; 1133 if (!PyArg_ParseTuple(args, C("O!O:GetRepeatedScalar"), 1134 &CFieldDescriptor_Type, &cfield_descriptor, &slice)) { 1135 return NULL; 1136 } 1137 1138 return InternalGetRepeatedScalarSlice( 1139 self, cfield_descriptor->descriptor, slice); 1140 } 1141 1142 static PyObject* CMessage_AssignRepeatedScalar(CMessage* self, PyObject* args) { 1143 CFieldDescriptor* cfield_descriptor; 1144 PyObject* slice; 1145 if (!PyArg_ParseTuple(args, C("O!O:AssignRepeatedScalar"), 1146 &CFieldDescriptor_Type, &cfield_descriptor, &slice)) { 1147 return NULL; 1148 } 1149 1150 AssureWritable(self); 1151 google::protobuf::Message* message = self->message; 1152 message->GetReflection()->ClearField(message, cfield_descriptor->descriptor); 1153 1154 PyObject* iter = PyObject_GetIter(slice); 1155 PyObject* next; 1156 while ((next = PyIter_Next(iter)) != NULL) { 1157 if (InternalAddRepeatedScalar( 1158 message, cfield_descriptor->descriptor, next) == NULL) { 1159 Py_DECREF(next); 1160 Py_DECREF(iter); 1161 return NULL; 1162 } 1163 Py_DECREF(next); 1164 } 1165 Py_DECREF(iter); 1166 Py_RETURN_NONE; 1167 } 1168 1169 static PyObject* CMessage_DeleteRepeatedField(CMessage* self, PyObject* args) { 1170 CFieldDescriptor* cfield_descriptor; 1171 PyObject* slice; 1172 if (!PyArg_ParseTuple(args, C("O!O:DeleteRepeatedField"), 1173 &CFieldDescriptor_Type, &cfield_descriptor, &slice)) { 1174 return NULL; 1175 } 1176 AssureWritable(self); 1177 1178 Py_ssize_t length, from, to, step, slice_length; 1179 google::protobuf::Message* message = self->message; 1180 const google::protobuf::FieldDescriptor* field_descriptor = 1181 cfield_descriptor->descriptor; 1182 const google::protobuf::Reflection* reflection = message->GetReflection(); 1183 int min, max; 1184 length = reflection->FieldSize(*message, field_descriptor); 1185 1186 if (PyInt_Check(slice) || PyLong_Check(slice)) { 1187 from = to = PyLong_AsLong(slice); 1188 if (from < 0) { 1189 from = to = length + from; 1190 } 1191 step = 1; 1192 min = max = from; 1193 1194 // Range check. 1195 if (from < 0 || from >= length) { 1196 PyErr_Format(PyExc_IndexError, "list assignment index out of range"); 1197 return NULL; 1198 } 1199 } else if (PySlice_Check(slice)) { 1200 from = to = step = slice_length = 0; 1201 PySlice_GetIndicesEx( 1202 reinterpret_cast<PySliceObject*>(slice), 1203 length, &from, &to, &step, &slice_length); 1204 if (from < to) { 1205 min = from; 1206 max = to - 1; 1207 } else { 1208 min = to + 1; 1209 max = from; 1210 } 1211 } else { 1212 PyErr_SetString(PyExc_TypeError, "list indices must be integers"); 1213 return NULL; 1214 } 1215 1216 Py_ssize_t i = from; 1217 std::vector<bool> to_delete(length, false); 1218 while (i >= min && i <= max) { 1219 to_delete[i] = true; 1220 i += step; 1221 } 1222 1223 to = 0; 1224 for (i = 0; i < length; ++i) { 1225 if (!to_delete[i]) { 1226 if (i != to) { 1227 reflection->SwapElements(message, field_descriptor, i, to); 1228 } 1229 ++to; 1230 } 1231 } 1232 1233 while (i > to) { 1234 reflection->RemoveLast(message, field_descriptor); 1235 --i; 1236 } 1237 1238 Py_RETURN_NONE; 1239 } 1240 1241 1242 static PyObject* CMessage_SetScalar(CMessage* self, PyObject* args) { 1243 CFieldDescriptor* cfield_descriptor; 1244 PyObject* arg; 1245 if (!PyArg_ParseTuple(args, C("O!O:SetScalar"), 1246 &CFieldDescriptor_Type, &cfield_descriptor, &arg)) { 1247 return NULL; 1248 } 1249 AssureWritable(self); 1250 1251 return InternalSetScalar(self->message, cfield_descriptor->descriptor, arg); 1252 } 1253 1254 static PyObject* CMessage_AddRepeatedScalar(CMessage* self, PyObject* args) { 1255 CFieldDescriptor* cfield_descriptor; 1256 PyObject* value; 1257 if (!PyArg_ParseTuple(args, C("O!O:AddRepeatedScalar"), 1258 &CFieldDescriptor_Type, &cfield_descriptor, &value)) { 1259 return NULL; 1260 } 1261 AssureWritable(self); 1262 1263 return InternalAddRepeatedScalar( 1264 self->message, cfield_descriptor->descriptor, value); 1265 } 1266 1267 static PyObject* CMessage_FieldLength(CMessage* self, PyObject* arg) { 1268 CFieldDescriptor* cfield_descriptor; 1269 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), 1270 &CFieldDescriptor_Type)) { 1271 PyErr_SetString(PyExc_TypeError, "Must be a field descriptor"); 1272 return NULL; 1273 } 1274 cfield_descriptor = reinterpret_cast<CFieldDescriptor*>(arg); 1275 1276 google::protobuf::Message* message = self->message; 1277 int length = message->GetReflection()->FieldSize( 1278 *message, cfield_descriptor->descriptor); 1279 return PyInt_FromLong(length); 1280 } 1281 1282 static PyObject* CMessage_DebugString(CMessage* self, PyObject* args) { 1283 return PyString_FromString(self->message->DebugString().c_str()); 1284 } 1285 1286 static PyObject* CMessage_SerializeToString(CMessage* self, PyObject* args) { 1287 int size = self->message->ByteSize(); 1288 if (size <= 0) { 1289 return PyString_FromString(""); 1290 } 1291 PyObject* result = PyString_FromStringAndSize(NULL, size); 1292 if (result == NULL) { 1293 return NULL; 1294 } 1295 char* buffer = PyString_AS_STRING(result); 1296 self->message->SerializeWithCachedSizesToArray( 1297 reinterpret_cast<uint8*>(buffer)); 1298 return result; 1299 } 1300 1301 static PyObject* CMessage_SerializePartialToString( 1302 CMessage* self, PyObject* args) { 1303 string contents; 1304 self->message->SerializePartialToString(&contents); 1305 return PyString_FromStringAndSize(contents.c_str(), contents.size()); 1306 } 1307 1308 static PyObject* CMessageStr(CMessage* self) { 1309 char str[1024]; 1310 str[sizeof(str) - 1] = 0; 1311 snprintf(str, sizeof(str) - 1, "CMessage: <%p>", self->message); 1312 return PyString_FromString(str); 1313 } 1314 1315 static PyObject* CMessage_MergeFrom(CMessage* self, PyObject* arg) { 1316 CMessage* other_message; 1317 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), &CMessage_Type)) { 1318 PyErr_SetString(PyExc_TypeError, "Must be a message"); 1319 return NULL; 1320 } 1321 1322 other_message = reinterpret_cast<CMessage*>(arg); 1323 if (other_message->message->GetDescriptor() != 1324 self->message->GetDescriptor()) { 1325 PyErr_Format(PyExc_TypeError, 1326 "Tried to merge from a message with a different type. " 1327 "to: %s, from: %s", 1328 self->message->GetDescriptor()->full_name().c_str(), 1329 other_message->message->GetDescriptor()->full_name().c_str()); 1330 return NULL; 1331 } 1332 AssureWritable(self); 1333 1334 self->message->MergeFrom(*other_message->message); 1335 Py_RETURN_NONE; 1336 } 1337 1338 static PyObject* CMessage_CopyFrom(CMessage* self, PyObject* arg) { 1339 CMessage* other_message; 1340 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), &CMessage_Type)) { 1341 PyErr_SetString(PyExc_TypeError, "Must be a message"); 1342 return NULL; 1343 } 1344 1345 other_message = reinterpret_cast<CMessage*>(arg); 1346 if (other_message->message->GetDescriptor() != 1347 self->message->GetDescriptor()) { 1348 PyErr_Format(PyExc_TypeError, 1349 "Tried to copy from a message with a different type. " 1350 "to: %s, from: %s", 1351 self->message->GetDescriptor()->full_name().c_str(), 1352 other_message->message->GetDescriptor()->full_name().c_str()); 1353 return NULL; 1354 } 1355 1356 AssureWritable(self); 1357 1358 self->message->CopyFrom(*other_message->message); 1359 Py_RETURN_NONE; 1360 } 1361 1362 static PyObject* CMessage_MergeFromString(CMessage* self, PyObject* arg) { 1363 const void* data; 1364 Py_ssize_t data_length; 1365 if (PyObject_AsReadBuffer(arg, &data, &data_length) < 0) { 1366 return NULL; 1367 } 1368 1369 AssureWritable(self); 1370 google::protobuf::io::CodedInputStream input( 1371 reinterpret_cast<const uint8*>(data), data_length); 1372 input.SetExtensionRegistry(GetDescriptorPool(), global_message_factory); 1373 bool success = self->message->MergePartialFromCodedStream(&input); 1374 if (success) { 1375 return PyInt_FromLong(self->message->ByteSize()); 1376 } else { 1377 return PyInt_FromLong(-1); 1378 } 1379 } 1380 1381 static PyObject* CMessage_ByteSize(CMessage* self, PyObject* args) { 1382 return PyLong_FromLong(self->message->ByteSize()); 1383 } 1384 1385 static PyObject* CMessage_SetInParent(CMessage* self, PyObject* args) { 1386 AssureWritable(self); 1387 Py_RETURN_NONE; 1388 } 1389 1390 static PyObject* CMessage_SwapRepeatedFieldElements( 1391 CMessage* self, PyObject* args) { 1392 CFieldDescriptor* cfield_descriptor; 1393 int index1, index2; 1394 if (!PyArg_ParseTuple(args, C("O!ii:SwapRepeatedFieldElements"), 1395 &CFieldDescriptor_Type, &cfield_descriptor, 1396 &index1, &index2)) { 1397 return NULL; 1398 } 1399 1400 google::protobuf::Message* message = self->message; 1401 const google::protobuf::Reflection* reflection = message->GetReflection(); 1402 1403 reflection->SwapElements( 1404 message, cfield_descriptor->descriptor, index1, index2); 1405 Py_RETURN_NONE; 1406 } 1407 1408 static PyObject* CMessage_AddMessage(CMessage* self, PyObject* arg) { 1409 CFieldDescriptor* cfield_descriptor; 1410 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), 1411 &CFieldDescriptor_Type)) { 1412 PyErr_SetString(PyExc_TypeError, "Must be a field descriptor"); 1413 return NULL; 1414 } 1415 cfield_descriptor = reinterpret_cast<CFieldDescriptor*>(arg); 1416 AssureWritable(self); 1417 1418 CMessage* py_cmsg = PyObject_New(CMessage, &CMessage_Type); 1419 if (py_cmsg == NULL) { 1420 return NULL; 1421 } 1422 1423 google::protobuf::Message* message = self->message; 1424 const google::protobuf::Reflection* reflection = message->GetReflection(); 1425 google::protobuf::Message* sub_message = 1426 reflection->AddMessage(message, cfield_descriptor->descriptor); 1427 1428 py_cmsg->parent = NULL; 1429 py_cmsg->full_name = sub_message->GetDescriptor()->full_name().c_str(); 1430 py_cmsg->message = sub_message; 1431 py_cmsg->free_message = false; 1432 py_cmsg->read_only = false; 1433 return reinterpret_cast<PyObject*>(py_cmsg); 1434 } 1435 1436 static PyObject* CMessage_GetRepeatedMessage(CMessage* self, PyObject* args) { 1437 CFieldDescriptor* cfield_descriptor; 1438 PyObject* slice; 1439 if (!PyArg_ParseTuple(args, C("O!O:GetRepeatedMessage"), 1440 &CFieldDescriptor_Type, &cfield_descriptor, &slice)) { 1441 return NULL; 1442 } 1443 1444 return InternalGetRepeatedScalarSlice( 1445 self, cfield_descriptor->descriptor, slice); 1446 } 1447 1448 static PyObject* CMessage_NewSubMessage(CMessage* self, PyObject* arg) { 1449 CFieldDescriptor* cfield_descriptor; 1450 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), 1451 &CFieldDescriptor_Type)) { 1452 PyErr_SetString(PyExc_TypeError, "Must be a field descriptor"); 1453 return NULL; 1454 } 1455 cfield_descriptor = reinterpret_cast<CFieldDescriptor*>(arg); 1456 1457 CMessage* py_cmsg = PyObject_New(CMessage, &CMessage_Type); 1458 if (py_cmsg == NULL) { 1459 return NULL; 1460 } 1461 1462 google::protobuf::Message* message = self->message; 1463 const google::protobuf::Reflection* reflection = message->GetReflection(); 1464 const google::protobuf::Message& sub_message = 1465 reflection->GetMessage(*message, cfield_descriptor->descriptor, 1466 global_message_factory); 1467 1468 py_cmsg->full_name = sub_message.GetDescriptor()->full_name().c_str(); 1469 py_cmsg->parent = self; 1470 py_cmsg->parent_field = cfield_descriptor; 1471 py_cmsg->message = const_cast<google::protobuf::Message*>(&sub_message); 1472 py_cmsg->free_message = false; 1473 py_cmsg->read_only = true; 1474 return reinterpret_cast<PyObject*>(py_cmsg); 1475 } 1476 1477 static PyObject* CMessage_MutableMessage(CMessage* self, PyObject* arg) { 1478 CFieldDescriptor* cfield_descriptor; 1479 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), 1480 &CFieldDescriptor_Type)) { 1481 PyErr_SetString(PyExc_TypeError, "Must be a field descriptor"); 1482 return NULL; 1483 } 1484 cfield_descriptor = reinterpret_cast<CFieldDescriptor*>(arg); 1485 AssureWritable(self); 1486 1487 CMessage* py_cmsg = PyObject_New(CMessage, &CMessage_Type); 1488 if (py_cmsg == NULL) { 1489 return NULL; 1490 } 1491 1492 google::protobuf::Message* message = self->message; 1493 const google::protobuf::Reflection* reflection = message->GetReflection(); 1494 google::protobuf::Message* mutable_message = 1495 reflection->MutableMessage(message, cfield_descriptor->descriptor, 1496 global_message_factory); 1497 1498 py_cmsg->full_name = mutable_message->GetDescriptor()->full_name().c_str(); 1499 py_cmsg->message = mutable_message; 1500 py_cmsg->free_message = false; 1501 py_cmsg->read_only = false; 1502 return reinterpret_cast<PyObject*>(py_cmsg); 1503 } 1504 1505 static PyObject* CMessage_Equals(CMessage* self, PyObject* arg) { 1506 CMessage* other_message; 1507 if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), &CMessage_Type)) { 1508 PyErr_SetString(PyExc_TypeError, "Must be a message"); 1509 return NULL; 1510 } 1511 other_message = reinterpret_cast<CMessage*>(arg); 1512 1513 if (other_message->message == self->message) { 1514 return PyBool_FromLong(1); 1515 } 1516 1517 if (other_message->message->GetDescriptor() != 1518 self->message->GetDescriptor()) { 1519 return PyBool_FromLong(0); 1520 } 1521 1522 return PyBool_FromLong(1); 1523 } 1524 1525 static PyObject* CMessage_ListFields(CMessage* self, PyObject* args) { 1526 google::protobuf::Message* message = self->message; 1527 const google::protobuf::Reflection* reflection = message->GetReflection(); 1528 vector<const google::protobuf::FieldDescriptor*> fields; 1529 reflection->ListFields(*message, &fields); 1530 1531 PyObject* list = PyList_New(fields.size()); 1532 if (list == NULL) { 1533 return NULL; 1534 } 1535 1536 for (unsigned int i = 0; i < fields.size(); ++i) { 1537 bool is_extension = fields[i]->is_extension(); 1538 PyObject* t = PyTuple_New(2); 1539 if (t == NULL) { 1540 Py_DECREF(list); 1541 return NULL; 1542 } 1543 1544 PyObject* is_extension_object = PyBool_FromLong(is_extension ? 1 : 0); 1545 1546 PyObject* field_name; 1547 const string* s; 1548 if (is_extension) { 1549 s = &fields[i]->full_name(); 1550 } else { 1551 s = &fields[i]->name(); 1552 } 1553 field_name = PyString_FromStringAndSize(s->c_str(), s->length()); 1554 if (field_name == NULL) { 1555 Py_DECREF(list); 1556 Py_DECREF(t); 1557 return NULL; 1558 } 1559 1560 PyTuple_SET_ITEM(t, 0, is_extension_object); 1561 PyTuple_SET_ITEM(t, 1, field_name); 1562 PyList_SET_ITEM(list, i, t); 1563 } 1564 1565 return list; 1566 } 1567 1568 static PyObject* CMessage_FindInitializationErrors(CMessage* self) { 1569 google::protobuf::Message* message = self->message; 1570 vector<string> errors; 1571 message->FindInitializationErrors(&errors); 1572 1573 PyObject* error_list = PyList_New(errors.size()); 1574 if (error_list == NULL) { 1575 return NULL; 1576 } 1577 for (unsigned int i = 0; i < errors.size(); ++i) { 1578 const string& error = errors[i]; 1579 PyObject* error_string = PyString_FromStringAndSize( 1580 error.c_str(), error.length()); 1581 if (error_string == NULL) { 1582 Py_DECREF(error_list); 1583 return NULL; 1584 } 1585 PyList_SET_ITEM(error_list, i, error_string); 1586 } 1587 return error_list; 1588 } 1589 1590 // ------ Python Constructor: 1591 1592 PyObject* Python_NewCMessage(PyObject* ignored, PyObject* arg) { 1593 const char* message_type = PyString_AsString(arg); 1594 if (message_type == NULL) { 1595 return NULL; 1596 } 1597 1598 const google::protobuf::Message* message = CreateMessage(message_type); 1599 if (message == NULL) { 1600 PyErr_Format(PyExc_TypeError, "Couldn't create message of type %s!", 1601 message_type); 1602 return NULL; 1603 } 1604 1605 CMessage* py_cmsg = PyObject_New(CMessage, &CMessage_Type); 1606 if (py_cmsg == NULL) { 1607 return NULL; 1608 } 1609 py_cmsg->message = message->New(); 1610 py_cmsg->free_message = true; 1611 py_cmsg->full_name = message->GetDescriptor()->full_name().c_str(); 1612 py_cmsg->read_only = false; 1613 py_cmsg->parent = NULL; 1614 py_cmsg->parent_field = NULL; 1615 return reinterpret_cast<PyObject*>(py_cmsg); 1616 } 1617 1618 // --- Module Functions (exposed to Python): 1619 1620 PyMethodDef methods[] = { 1621 { C("NewCMessage"), (PyCFunction)Python_NewCMessage, 1622 METH_O, 1623 C("Creates a new C++ protocol message, given its full name.") }, 1624 { C("NewCDescriptorPool"), (PyCFunction)Python_NewCDescriptorPool, 1625 METH_NOARGS, 1626 C("Creates a new C++ descriptor pool.") }, 1627 { C("BuildFile"), (PyCFunction)Python_BuildFile, 1628 METH_O, 1629 C("Registers a new protocol buffer file in the global C++ descriptor " 1630 "pool.") }, 1631 {NULL} 1632 }; 1633 1634 // --- Exposing the C proto living inside Python proto to C code: 1635 1636 extern const Message* (*GetCProtoInsidePyProtoPtr)(PyObject* msg); 1637 extern Message* (*MutableCProtoInsidePyProtoPtr)(PyObject* msg); 1638 1639 static const google::protobuf::Message* GetCProtoInsidePyProtoImpl(PyObject* msg) { 1640 PyObject* c_msg_obj = PyObject_GetAttrString(msg, "_cmsg"); 1641 if (c_msg_obj == NULL) { 1642 PyErr_Clear(); 1643 return NULL; 1644 } 1645 Py_DECREF(c_msg_obj); 1646 if (!PyObject_TypeCheck(c_msg_obj, &CMessage_Type)) { 1647 return NULL; 1648 } 1649 CMessage* c_msg = reinterpret_cast<CMessage*>(c_msg_obj); 1650 return c_msg->message; 1651 } 1652 1653 static google::protobuf::Message* MutableCProtoInsidePyProtoImpl(PyObject* msg) { 1654 PyObject* c_msg_obj = PyObject_GetAttrString(msg, "_cmsg"); 1655 if (c_msg_obj == NULL) { 1656 PyErr_Clear(); 1657 return NULL; 1658 } 1659 Py_DECREF(c_msg_obj); 1660 if (!PyObject_TypeCheck(c_msg_obj, &CMessage_Type)) { 1661 return NULL; 1662 } 1663 CMessage* c_msg = reinterpret_cast<CMessage*>(c_msg_obj); 1664 AssureWritable(c_msg); 1665 return c_msg->message; 1666 } 1667 1668 // --- Module Init Function: 1669 1670 static const char module_docstring[] = 1671 "python-proto2 is a module that can be used to enhance proto2 Python API\n" 1672 "performance.\n" 1673 "\n" 1674 "It provides access to the protocol buffers C++ reflection API that\n" 1675 "implements the basic protocol buffer functions."; 1676 1677 extern "C" { 1678 void init_net_proto2___python() { 1679 // Initialize constants. 1680 kPythonZero = PyInt_FromLong(0); 1681 kint32min_py = PyInt_FromLong(kint32min); 1682 kint32max_py = PyInt_FromLong(kint32max); 1683 kuint32max_py = PyLong_FromLongLong(kuint32max); 1684 kint64min_py = PyLong_FromLongLong(kint64min); 1685 kint64max_py = PyLong_FromLongLong(kint64max); 1686 kuint64max_py = PyLong_FromUnsignedLongLong(kuint64max); 1687 1688 global_message_factory = new DynamicMessageFactory(GetDescriptorPool()); 1689 global_message_factory->SetDelegateToGeneratedFactory(true); 1690 1691 // Export our functions to Python. 1692 PyObject *m; 1693 m = Py_InitModule3(C("_net_proto2___python"), methods, C(module_docstring)); 1694 if (m == NULL) { 1695 return; 1696 } 1697 1698 AddConstants(m); 1699 1700 CMessage_Type.tp_new = PyType_GenericNew; 1701 if (PyType_Ready(&CMessage_Type) < 0) { 1702 return; 1703 } 1704 1705 if (!InitDescriptor()) { 1706 return; 1707 } 1708 1709 // Override {Get,Mutable}CProtoInsidePyProto. 1710 GetCProtoInsidePyProtoPtr = GetCProtoInsidePyProtoImpl; 1711 MutableCProtoInsidePyProtoPtr = MutableCProtoInsidePyProtoImpl; 1712 } 1713 } 1714 1715 } // namespace python 1716 } // namespace protobuf 1717 } // namespace google 1718