third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/python/google/protobuf/pyext/map_container.cc

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 21 matching lines @@
 
 #include <google/protobuf/pyext/map_container.h>
 
 #include <memory>
 #ifndef _SHARED_PTR_H
 #include <google/protobuf/stubs/shared_ptr.h>
 #endif
 
 #include <google/protobuf/stubs/logging.h>
 #include <google/protobuf/stubs/common.h>
-#include <google/protobuf/stubs/scoped_ptr.h>
 #include <google/protobuf/map_field.h>
 #include <google/protobuf/map.h>
 #include <google/protobuf/message.h>
+#include <google/protobuf/pyext/message_factory.h>
 #include <google/protobuf/pyext/message.h>
+#include <google/protobuf/pyext/repeated_composite_container.h>
 #include <google/protobuf/pyext/scoped_pyobject_ptr.h>
 
 #if PY_MAJOR_VERSION >= 3
   #define PyInt_FromLong PyLong_FromLong
   #define PyInt_FromSize_t PyLong_FromSize_t
 #endif
 
 namespace google {
 namespace protobuf {
 namespace python {
@@ skipping 265 matching lines @@
 PyObject* Clear(PyObject* _self) {
   MapContainer* self = GetMap(_self);
   Message* message = self->GetMutableMessage();
   const Reflection* reflection = message->GetReflection();
 
   reflection->ClearField(message, self->parent_field_descriptor);
 
   Py_RETURN_NONE;
 }
 
+PyObject* GetEntryClass(PyObject* _self) {
+  MapContainer* self = GetMap(_self);
+  CMessageClass* message_class = message_factory::GetMessageClass(
+      cmessage::GetFactoryForMessage(self->parent),
+      self->parent_field_descriptor->message_type());
+  Py_XINCREF(message_class);
+  return reinterpret_cast<PyObject*>(message_class);
+}
+
 PyObject* MapReflectionFriend::Contains(PyObject* _self, PyObject* key) {
   MapContainer* self = GetMap(_self);
 
   const Message* message = self->message;
   const Reflection* reflection = message->GetReflection();
   MapKey map_key;
 
   if (!PythonToMapKey(key, self->key_field_descriptor, &map_key)) {
     return NULL;
   }
 
   if (reflection->ContainsMapKey(*message, self->parent_field_descriptor,
                                  map_key)) {
     Py_RETURN_TRUE;
   } else {
     Py_RETURN_FALSE;
   }
 }
 
 // Initializes the underlying Message object of "to" so it becomes a new parent
-// repeated scalar, and copies all the values from "from" to it. A child scalar
+// map container, and copies all the values from "from" to it. A child map
 // container can be released by passing it as both from and to (e.g. making it
 // the recipient of the new parent message and copying the values from itself).
+// In fact, this is the only supported use at the moment.
 static int InitializeAndCopyToParentContainer(MapContainer* from,
                                               MapContainer* to) {
   // For now we require from == to, re-evaluate if we want to support deep copy
   // as in repeated_scalar_container.cc.
   GOOGLE_DCHECK(from == to);
   Message* new_message = from->message->New();
 
   if (MapReflectionFriend::Length(reinterpret_cast<PyObject*>(from)) > 0) {
     // A somewhat roundabout way of copying just one field from old_message to
     // new_message.  This is the best we can do with what Reflection gives us.
     Message* mutable_old = from->GetMutableMessage();
-    vector<const FieldDescriptor*> fields;
+    std::vector<const FieldDescriptor*> fields;
     fields.push_back(from->parent_field_descriptor);
 
     // Move the map field into the new message.
     mutable_old->GetReflection()->SwapFields(mutable_old, new_message, fields);
 
     // If/when we support from != to, this will be required also to copy the
     // map field back into the existing message:
     // mutable_old->MergeFrom(*new_message);
   }
 
@@ skipping 16 matching lines @@
 
 
 // ScalarMap ///////////////////////////////////////////////////////////////////
 
 PyObject *NewScalarMapContainer(
     CMessage* parent, const google::protobuf::FieldDescriptor* parent_field_descriptor) {
   if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
     return NULL;
   }
 
-#if PY_MAJOR_VERSION >= 3
-  ScopedPyObjectPtr obj(PyType_GenericAlloc(
-        reinterpret_cast<PyTypeObject *>(ScalarMapContainer_Type), 0));
-#else
-  ScopedPyObjectPtr obj(PyType_GenericAlloc(&ScalarMapContainer_Type, 0));
-#endif
+  ScopedPyObjectPtr obj(PyType_GenericAlloc(ScalarMapContainer_Type, 0));
   if (obj.get() == NULL) {
     return PyErr_Format(PyExc_RuntimeError,
                         "Could not allocate new container.");
   }
 
   MapContainer* self = GetMap(obj.get());
 
   self->message = parent->message;
   self->parent = parent;
   self->parent_field_descriptor = parent_field_descriptor;
@@ skipping 101 matching lines @@
   Py_TYPE(_self)->tp_free(_self);
 }
 
 static PyMethodDef ScalarMapMethods[] = {
   { "__contains__", MapReflectionFriend::Contains, METH_O,
     "Tests whether a key is a member of the map." },
   { "clear", (PyCFunction)Clear, METH_NOARGS,
     "Removes all elements from the map." },
   { "get", ScalarMapGet, METH_VARARGS,
     "Gets the value for the given key if present, or otherwise a default" },
+  { "GetEntryClass", (PyCFunction)GetEntryClass, METH_NOARGS,
+    "Return the class used to build Entries of (key, value) pairs." },
   /*
   { "__deepcopy__", (PyCFunction)DeepCopy, METH_VARARGS,
     "Makes a deep copy of the class." },
   { "__reduce__", (PyCFunction)Reduce, METH_NOARGS,
     "Outputs picklable representation of the repeated field." },
   */
   {NULL, NULL},
 };
 
+PyTypeObject *ScalarMapContainer_Type;
 #if PY_MAJOR_VERSION >= 3
   static PyType_Slot ScalarMapContainer_Type_slots[] = {
       {Py_tp_dealloc, (void *)ScalarMapDealloc},
       {Py_mp_length, (void *)MapReflectionFriend::Length},
       {Py_mp_subscript, (void *)MapReflectionFriend::ScalarMapGetItem},
       {Py_mp_ass_subscript, (void *)MapReflectionFriend::ScalarMapSetItem},
       {Py_tp_methods, (void *)ScalarMapMethods},
       {Py_tp_iter, (void *)MapReflectionFriend::GetIterator},
       {0, 0},
   };
 
   PyType_Spec ScalarMapContainer_Type_spec = {
       FULL_MODULE_NAME ".ScalarMapContainer",
       sizeof(MapContainer),
       0,
       Py_TPFLAGS_DEFAULT,
       ScalarMapContainer_Type_slots
   };
-  PyObject *ScalarMapContainer_Type;
 #else
   static PyMappingMethods ScalarMapMappingMethods = {
     MapReflectionFriend::Length,             // mp_length
     MapReflectionFriend::ScalarMapGetItem,   // mp_subscript
     MapReflectionFriend::ScalarMapSetItem,   // mp_ass_subscript
   };
 
-  PyTypeObject ScalarMapContainer_Type = {
+  PyTypeObject _ScalarMapContainer_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     FULL_MODULE_NAME ".ScalarMapContainer",  //  tp_name
     sizeof(MapContainer),                //  tp_basicsize
     0,                                   //  tp_itemsize
     ScalarMapDealloc,                    //  tp_dealloc
     0,                                   //  tp_print
     0,                                   //  tp_getattr
     0,                                   //  tp_setattr
     0,                                   //  tp_compare
     0,                                   //  tp_repr
@@ skipping 60 matching lines @@
   return ret;
 }
 
 PyObject* NewMessageMapContainer(
     CMessage* parent, const google::protobuf::FieldDescriptor* parent_field_descriptor,
     CMessageClass* message_class) {
   if (!CheckFieldBelongsToMessage(parent_field_descriptor, parent->message)) {
     return NULL;
   }
 
-#if PY_MAJOR_VERSION >= 3
-  PyObject* obj = PyType_GenericAlloc(
-        reinterpret_cast<PyTypeObject *>(MessageMapContainer_Type), 0);
-#else
-  PyObject* obj = PyType_GenericAlloc(&MessageMapContainer_Type, 0);
-#endif
+  PyObject* obj = PyType_GenericAlloc(MessageMapContainer_Type, 0);
   if (obj == NULL) {
     return PyErr_Format(PyExc_RuntimeError,
                         "Could not allocate new container.");
   }
 
   MessageMapContainer* self = GetMessageMap(obj);
 
   self->message = parent->message;
   self->parent = parent;
   self->parent_field_descriptor = parent_field_descriptor;
@@ skipping 111 matching lines @@
 
 static PyMethodDef MessageMapMethods[] = {
   { "__contains__", (PyCFunction)MapReflectionFriend::Contains, METH_O,
     "Tests whether the map contains this element."},
   { "clear", (PyCFunction)Clear, METH_NOARGS,
     "Removes all elements from the map."},
   { "get", MessageMapGet, METH_VARARGS,
     "Gets the value for the given key if present, or otherwise a default" },
   { "get_or_create", MapReflectionFriend::MessageMapGetItem, METH_O,
     "Alias for getitem, useful to make explicit that the map is mutated." },
+  { "GetEntryClass", (PyCFunction)GetEntryClass, METH_NOARGS,
+    "Return the class used to build Entries of (key, value) pairs." },
   /*
   { "__deepcopy__", (PyCFunction)DeepCopy, METH_VARARGS,
     "Makes a deep copy of the class." },
   { "__reduce__", (PyCFunction)Reduce, METH_NOARGS,
     "Outputs picklable representation of the repeated field." },
   */
   {NULL, NULL},
 };
 
+PyTypeObject *MessageMapContainer_Type;
 #if PY_MAJOR_VERSION >= 3
   static PyType_Slot MessageMapContainer_Type_slots[] = {
       {Py_tp_dealloc, (void *)MessageMapDealloc},
       {Py_mp_length, (void *)MapReflectionFriend::Length},
       {Py_mp_subscript, (void *)MapReflectionFriend::MessageMapGetItem},
       {Py_mp_ass_subscript, (void *)MapReflectionFriend::MessageMapSetItem},
       {Py_tp_methods, (void *)MessageMapMethods},
       {Py_tp_iter, (void *)MapReflectionFriend::GetIterator},
       {0, 0}
   };
 
   PyType_Spec MessageMapContainer_Type_spec = {
       FULL_MODULE_NAME ".MessageMapContainer",
       sizeof(MessageMapContainer),
       0,
       Py_TPFLAGS_DEFAULT,
       MessageMapContainer_Type_slots
   };
-
-  PyObject *MessageMapContainer_Type;
 #else
   static PyMappingMethods MessageMapMappingMethods = {
     MapReflectionFriend::Length,              // mp_length
     MapReflectionFriend::MessageMapGetItem,   // mp_subscript
     MapReflectionFriend::MessageMapSetItem,   // mp_ass_subscript
   };
 
-  PyTypeObject MessageMapContainer_Type = {
+  PyTypeObject _MessageMapContainer_Type = {
     PyVarObject_HEAD_INIT(&PyType_Type, 0)
     FULL_MODULE_NAME ".MessageMapContainer",  //  tp_name
     sizeof(MessageMapContainer),         //  tp_basicsize
     0,                                   //  tp_itemsize
     MessageMapDealloc,                   //  tp_dealloc
     0,                                   //  tp_print
     0,                                   //  tp_getattr
     0,                                   //  tp_setattr
     0,                                   //  tp_compare
     0,                                   //  tp_repr
@@ skipping 128 matching lines @@
   0,                                   //  tp_members
   0,                                   //  tp_getset
   0,                                   //  tp_base
   0,                                   //  tp_dict
   0,                                   //  tp_descr_get
   0,                                   //  tp_descr_set
   0,                                   //  tp_dictoffset
   0,                                   //  tp_init
 };
 
+bool InitMapContainers() {
+  // ScalarMapContainer_Type derives from our MutableMapping type.
+  ScopedPyObjectPtr containers(PyImport_ImportModule(
+      "google.protobuf.internal.containers"));
+  if (containers == NULL) {
+    return false;
+  }
+
+  ScopedPyObjectPtr mutable_mapping(
+      PyObject_GetAttrString(containers.get(), "MutableMapping"));
+  if (mutable_mapping == NULL) {
+    return false;
+  }
+
+  if (!PyObject_TypeCheck(mutable_mapping.get(), &PyType_Type)) {
+    return false;
+  }
+
+  Py_INCREF(mutable_mapping.get());
+#if PY_MAJOR_VERSION >= 3
+  PyObject* bases = PyTuple_New(1);
+  PyTuple_SET_ITEM(bases, 0, mutable_mapping.get());
+
+  ScalarMapContainer_Type = reinterpret_cast<PyTypeObject*>(
+      PyType_FromSpecWithBases(&ScalarMapContainer_Type_spec, bases));
+#else
+  _ScalarMapContainer_Type.tp_base =
+      reinterpret_cast<PyTypeObject*>(mutable_mapping.get());
+
+  if (PyType_Ready(&_ScalarMapContainer_Type) < 0) {
+    return false;
+  }
+
+  ScalarMapContainer_Type = &_ScalarMapContainer_Type;
+#endif
+
+  if (PyType_Ready(&MapIterator_Type) < 0) {
+    return false;
+  }
+
+#if PY_MAJOR_VERSION >= 3
+  MessageMapContainer_Type = reinterpret_cast<PyTypeObject*>(
+      PyType_FromSpecWithBases(&MessageMapContainer_Type_spec, bases));
+#else
+  Py_INCREF(mutable_mapping.get());
+  _MessageMapContainer_Type.tp_base =
+      reinterpret_cast<PyTypeObject*>(mutable_mapping.get());
+
+  if (PyType_Ready(&_MessageMapContainer_Type) < 0) {
+    return false;
+  }
+
+  MessageMapContainer_Type = &_MessageMapContainer_Type;
+#endif
+  return true;
+}
+
 }  // namespace python
 }  // namespace protobuf
 }  // namespace google