// 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.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// Author: anuraag@google.com (Anuraag Agrawal)
// Author: tibell@google.com (Johan Tibell)
#include <google/protobuf/pyext/message.h>
#include <memory>
#ifndef _SHARED_PTR_H
#include <google/protobuf/stubs/shared_ptr.h>
#endif
#include <string>
#include <vector>
#include <structmember.h> // A Python header file.
#ifndef PyVarObject_HEAD_INIT
#define PyVarObject_HEAD_INIT(type, size) PyObject_HEAD_INIT(type) size,
#endif
#ifndef Py_TYPE
#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
#endif
#include <google/protobuf/descriptor.pb.h>
#include <google/protobuf/stubs/common.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/dynamic_message.h>
#include <google/protobuf/message.h>
#include <google/protobuf/text_format.h>
#include <google/protobuf/pyext/descriptor.h>
#include <google/protobuf/pyext/descriptor_pool.h>
#include <google/protobuf/pyext/extension_dict.h>
#include <google/protobuf/pyext/repeated_composite_container.h>
#include <google/protobuf/pyext/repeated_scalar_container.h>
#include <google/protobuf/pyext/scoped_pyobject_ptr.h>
#include <google/protobuf/stubs/strutil.h>
#if PY_MAJOR_VERSION >= 3
#define PyInt_Check PyLong_Check
#define PyInt_AsLong PyLong_AsLong
#define PyInt_FromLong PyLong_FromLong
#define PyInt_FromSize_t PyLong_FromSize_t
#define PyString_Check PyUnicode_Check
#define PyString_FromString PyUnicode_FromString
#define PyString_FromStringAndSize PyUnicode_FromStringAndSize
#if PY_VERSION_HEX < 0x03030000
#error "Python 3.0 - 3.2 are not supported."
#else
#define PyString_AsString(ob) \
(PyUnicode_Check(ob)? PyUnicode_AsUTF8(ob): PyBytes_AsString(ob))
#define PyString_AsStringAndSize(ob, charpp, sizep) \
(PyUnicode_Check(ob)? \
((*(charpp) = PyUnicode_AsUTF8AndSize(ob, (sizep))) == NULL? -1: 0): \
PyBytes_AsStringAndSize(ob, (charpp), (sizep)))
#endif
#endif
namespace google {
namespace protobuf {
namespace python {
// Forward declarations
namespace cmessage {
static const FieldDescriptor* GetFieldDescriptor(
CMessage* self, PyObject* name);
static const Descriptor* GetMessageDescriptor(PyTypeObject* cls);
static string GetMessageName(CMessage* self);
int InternalReleaseFieldByDescriptor(
const FieldDescriptor* field_descriptor,
PyObject* composite_field,
Message* parent_message);
} // namespace cmessage
// ---------------------------------------------------------------------
// Visiting the composite children of a CMessage
struct ChildVisitor {
// Returns 0 on success, -1 on failure.
int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
return 0;
}
// Returns 0 on success, -1 on failure.
int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
return 0;
}
// Returns 0 on success, -1 on failure.
int VisitCMessage(CMessage* cmessage,
const FieldDescriptor* field_descriptor) {
return 0;
}
};
// Apply a function to a composite field. Does nothing if child is of
// non-composite type.
template<class Visitor>
static int VisitCompositeField(const FieldDescriptor* descriptor,
PyObject* child,
Visitor visitor) {
if (descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
RepeatedCompositeContainer* container =
reinterpret_cast<RepeatedCompositeContainer*>(child);
if (visitor.VisitRepeatedCompositeContainer(container) == -1)
return -1;
} else {
RepeatedScalarContainer* container =
reinterpret_cast<RepeatedScalarContainer*>(child);
if (visitor.VisitRepeatedScalarContainer(container) == -1)
return -1;
}
} else if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
CMessage* cmsg = reinterpret_cast<CMessage*>(child);
if (visitor.VisitCMessage(cmsg, descriptor) == -1)
return -1;
}
// The ExtensionDict might contain non-composite fields, which we
// skip here.
return 0;
}
// Visit each composite field and extension field of this CMessage.
// Returns -1 on error and 0 on success.
template<class Visitor>
int ForEachCompositeField(CMessage* self, Visitor visitor) {
Py_ssize_t pos = 0;
PyObject* key;
PyObject* field;
// Visit normal fields.
if (self->composite_fields) {
// Never use self->message in this function, it may be already freed.
const Descriptor* message_descriptor =
cmessage::GetMessageDescriptor(Py_TYPE(self));
while (PyDict_Next(self->composite_fields, &pos, &key, &field)) {
Py_ssize_t key_str_size;
char *key_str_data;
if (PyString_AsStringAndSize(key, &key_str_data, &key_str_size) != 0)
return -1;
const string key_str(key_str_data, key_str_size);
const FieldDescriptor* descriptor =
message_descriptor->FindFieldByName(key_str);
if (descriptor != NULL) {
if (VisitCompositeField(descriptor, field, visitor) == -1)
return -1;
}
}
}
// Visit extension fields.
if (self->extensions != NULL) {
pos = 0;
while (PyDict_Next(self->extensions->values, &pos, &key, &field)) {
const FieldDescriptor* descriptor = cmessage::GetExtensionDescriptor(key);
if (descriptor == NULL)
return -1;
if (VisitCompositeField(descriptor, field, visitor) == -1)
return -1;
}
}
return 0;
}
// ---------------------------------------------------------------------
static DynamicMessageFactory* message_factory;
// Constants used for integer type range checking.
PyObject* kPythonZero;
PyObject* kint32min_py;
PyObject* kint32max_py;
PyObject* kuint32max_py;
PyObject* kint64min_py;
PyObject* kint64max_py;
PyObject* kuint64max_py;
PyObject* EnumTypeWrapper_class;
PyObject* EncodeError_class;
PyObject* DecodeError_class;
PyObject* PickleError_class;
// Constant PyString values used for GetAttr/GetItem.
static PyObject* kDESCRIPTOR;
static PyObject* k_cdescriptor;
static PyObject* kfull_name;
static PyObject* k_extensions_by_name;
static PyObject* k_extensions_by_number;
/* Is 64bit */
void FormatTypeError(PyObject* arg, char* expected_types) {
PyObject* repr = PyObject_Repr(arg);
if (repr) {
PyErr_Format(PyExc_TypeError,
"%.100s has type %.100s, but expected one of: %s",
PyString_AsString(repr),
Py_TYPE(arg)->tp_name,
expected_types);
Py_DECREF(repr);
}
}
template<class T>
bool CheckAndGetInteger(
PyObject* arg, T* value, PyObject* min, PyObject* max) {
bool is_long = PyLong_Check(arg);
#if PY_MAJOR_VERSION < 3
if (!PyInt_Check(arg) && !is_long) {
FormatTypeError(arg, "int, long");
return false;
}
if (PyObject_Compare(min, arg) > 0 || PyObject_Compare(max, arg) < 0) {
#else
if (!is_long) {
FormatTypeError(arg, "int");
return false;
}
if (PyObject_RichCompareBool(min, arg, Py_LE) != 1 ||
PyObject_RichCompareBool(max, arg, Py_GE) != 1) {
#endif
PyObject *s = PyObject_Str(arg);
if (s) {
PyErr_Format(PyExc_ValueError,
"Value out of range: %s",
PyString_AsString(s));
Py_DECREF(s);
}
return false;
}
#if PY_MAJOR_VERSION < 3
if (!is_long) {
*value = static_cast<T>(PyInt_AsLong(arg));
} else // NOLINT
#endif
{
if (min == kPythonZero) {
*value = static_cast<T>(PyLong_AsUnsignedLongLong(arg));
} else {
*value = static_cast<T>(PyLong_AsLongLong(arg));
}
}
return true;
}
// These are referenced by repeated_scalar_container, and must
// be explicitly instantiated.
template bool CheckAndGetInteger<int32>(
PyObject*, int32*, PyObject*, PyObject*);
template bool CheckAndGetInteger<int64>(
PyObject*, int64*, PyObject*, PyObject*);
template bool CheckAndGetInteger<uint32>(
PyObject*, uint32*, PyObject*, PyObject*);
template bool CheckAndGetInteger<uint64>(
PyObject*, uint64*, PyObject*, PyObject*);
bool CheckAndGetDouble(PyObject* arg, double* value) {
if (!PyInt_Check(arg) && !PyLong_Check(arg) &&
!PyFloat_Check(arg)) {
FormatTypeError(arg, "int, long, float");
return false;
}
*value = PyFloat_AsDouble(arg);
return true;
}
bool CheckAndGetFloat(PyObject* arg, float* value) {
double double_value;
if (!CheckAndGetDouble(arg, &double_value)) {
return false;
}
*value = static_cast<float>(double_value);
return true;
}
bool CheckAndGetBool(PyObject* arg, bool* value) {
if (!PyInt_Check(arg) && !PyBool_Check(arg) && !PyLong_Check(arg)) {
FormatTypeError(arg, "int, long, bool");
return false;
}
*value = static_cast<bool>(PyInt_AsLong(arg));
return true;
}
bool CheckAndSetString(
PyObject* arg, Message* message,
const FieldDescriptor* descriptor,
const Reflection* reflection,
bool append,
int index) {
GOOGLE_DCHECK(descriptor->type() == FieldDescriptor::TYPE_STRING ||
descriptor->type() == FieldDescriptor::TYPE_BYTES);
if (descriptor->type() == FieldDescriptor::TYPE_STRING) {
if (!PyBytes_Check(arg) && !PyUnicode_Check(arg)) {
FormatTypeError(arg, "bytes, unicode");
return false;
}
if (PyBytes_Check(arg)) {
PyObject* unicode = PyUnicode_FromEncodedObject(arg, "utf-8", NULL);
if (unicode == NULL) {
PyObject* repr = PyObject_Repr(arg);
PyErr_Format(PyExc_ValueError,
"%s has type str, but isn't valid UTF-8 "
"encoding. Non-UTF-8 strings must be converted to "
"unicode objects before being added.",
PyString_AsString(repr));
Py_DECREF(repr);
return false;
} else {
Py_DECREF(unicode);
}
}
} else if (!PyBytes_Check(arg)) {
FormatTypeError(arg, "bytes");
return false;
}
PyObject* encoded_string = NULL;
if (descriptor->type() == FieldDescriptor::TYPE_STRING) {
if (PyBytes_Check(arg)) {
// The bytes were already validated as correctly encoded UTF-8 above.
encoded_string = arg; // Already encoded.
Py_INCREF(encoded_string);
} else {
encoded_string = PyUnicode_AsEncodedObject(arg, "utf-8", NULL);
}
} else {
// In this case field type is "bytes".
encoded_string = arg;
Py_INCREF(encoded_string);
}
if (encoded_string == NULL) {
return false;
}
char* value;
Py_ssize_t value_len;
if (PyBytes_AsStringAndSize(encoded_string, &value, &value_len) < 0) {
Py_DECREF(encoded_string);
return false;
}
string value_string(value, value_len);
if (append) {
reflection->AddString(message, descriptor, value_string);
} else if (index < 0) {
reflection->SetString(message, descriptor, value_string);
} else {
reflection->SetRepeatedString(message, descriptor, index, value_string);
}
Py_DECREF(encoded_string);
return true;
}
PyObject* ToStringObject(const FieldDescriptor* descriptor, string value) {
if (descriptor->type() != FieldDescriptor::TYPE_STRING) {
return PyBytes_FromStringAndSize(value.c_str(), value.length());
}
PyObject* result = PyUnicode_DecodeUTF8(value.c_str(), value.length(), NULL);
// If the string can't be decoded in UTF-8, just return a string object that
// contains the raw bytes. This can't happen if the value was assigned using
// the members of the Python message object, but can happen if the values were
// parsed from the wire (binary).
if (result == NULL) {
PyErr_Clear();
result = PyBytes_FromStringAndSize(value.c_str(), value.length());
}
return result;
}
bool CheckFieldBelongsToMessage(const FieldDescriptor* field_descriptor,
const Message* message) {
if (message->GetDescriptor() == field_descriptor->containing_type()) {
return true;
}
PyErr_Format(PyExc_KeyError, "Field '%s' does not belong to message '%s'",
field_descriptor->full_name().c_str(),
message->GetDescriptor()->full_name().c_str());
return false;
}
namespace cmessage {
DynamicMessageFactory* GetMessageFactory() {
return message_factory;
}
static int MaybeReleaseOverlappingOneofField(
CMessage* cmessage,
const FieldDescriptor* field) {
#ifdef GOOGLE_PROTOBUF_HAS_ONEOF
Message* message = cmessage->message;
const Reflection* reflection = message->GetReflection();
if (!field->containing_oneof() ||
!reflection->HasOneof(*message, field->containing_oneof()) ||
reflection->HasField(*message, field)) {
// No other field in this oneof, no need to release.
return 0;
}
const OneofDescriptor* oneof = field->containing_oneof();
const FieldDescriptor* existing_field =
reflection->GetOneofFieldDescriptor(*message, oneof);
if (existing_field->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
// Non-message fields don't need to be released.
return 0;
}
const char* field_name = existing_field->name().c_str();
PyObject* child_message = cmessage->composite_fields ?
PyDict_GetItemString(cmessage->composite_fields, field_name) : NULL;
if (child_message == NULL) {
// No python reference to this field so no need to release.
return 0;
}
if (InternalReleaseFieldByDescriptor(
existing_field, child_message, message) < 0) {
return -1;
}
return PyDict_DelItemString(cmessage->composite_fields, field_name);
#else
return 0;
#endif
}
// ---------------------------------------------------------------------
// Making a message writable
static Message* GetMutableMessage(
CMessage* parent,
const FieldDescriptor* parent_field) {
Message* parent_message = parent->message;
const Reflection* reflection = parent_message->GetReflection();
if (MaybeReleaseOverlappingOneofField(parent, parent_field) < 0) {
return NULL;
}
return reflection->MutableMessage(
parent_message, parent_field, message_factory);
}
struct FixupMessageReference : public ChildVisitor {
// message must outlive this object.
explicit FixupMessageReference(Message* message) :
message_(message) {}
int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
container->message = message_;
return 0;
}
int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
container->message = message_;
return 0;
}
private:
Message* message_;
};
int AssureWritable(CMessage* self) {
if (self == NULL || !self->read_only) {
return 0;
}
if (self->parent == NULL) {
// If parent is NULL but we are trying to modify a read-only message, this
// is a reference to a constant default instance that needs to be replaced
// with a mutable top-level message.
const Message* prototype = message_factory->GetPrototype(
self->message->GetDescriptor());
self->message = prototype->New();
self->owner.reset(self->message);
} else {
// Otherwise, we need a mutable child message.
if (AssureWritable(self->parent) == -1)
return -1;
// Make self->message writable.
Message* parent_message = self->parent->message;
Message* mutable_message = GetMutableMessage(
self->parent,
self->parent_field_descriptor);
if (mutable_message == NULL) {
return -1;
}
self->message = mutable_message;
}
self->read_only = false;
// When a CMessage is made writable its Message pointer is updated
// to point to a new mutable Message. When that happens we need to
// update any references to the old, read-only CMessage. There are
// three places such references occur: RepeatedScalarContainer,
// RepeatedCompositeContainer, and ExtensionDict.
if (self->extensions != NULL)
self->extensions->message = self->message;
if (ForEachCompositeField(self, FixupMessageReference(self->message)) == -1)
return -1;
return 0;
}
// --- Globals:
// Retrieve the C++ Descriptor of a message class.
// On error, returns NULL with an exception set.
static const Descriptor* GetMessageDescriptor(PyTypeObject* cls) {
ScopedPyObjectPtr descriptor(PyObject_GetAttr(
reinterpret_cast<PyObject*>(cls), kDESCRIPTOR));
if (descriptor == NULL) {
PyErr_SetString(PyExc_TypeError, "Message class has no DESCRIPTOR");
return NULL;
}
if (!PyObject_TypeCheck(descriptor, &PyMessageDescriptor_Type)) {
PyErr_Format(PyExc_TypeError, "Expected a message Descriptor, got %s",
descriptor->ob_type->tp_name);
return NULL;
}
return PyMessageDescriptor_AsDescriptor(descriptor);
}
// Retrieve a C++ FieldDescriptor for a message attribute.
// The C++ message must be valid.
// TODO(amauryfa): This function should stay internal, because exception
// handling is not consistent.
static const FieldDescriptor* GetFieldDescriptor(
CMessage* self, PyObject* name) {
const Descriptor *message_descriptor = self->message->GetDescriptor();
char* field_name;
Py_ssize_t size;
if (PyString_AsStringAndSize(name, &field_name, &size) < 0) {
return NULL;
}
const FieldDescriptor *field_descriptor =
message_descriptor->FindFieldByName(string(field_name, size));
if (field_descriptor == NULL) {
// Note: No exception is set!
return NULL;
}
return field_descriptor;
}
// Retrieve a C++ FieldDescriptor for an extension handle.
const FieldDescriptor* GetExtensionDescriptor(PyObject* extension) {
ScopedPyObjectPtr cdescriptor;
if (!PyObject_TypeCheck(extension, &PyFieldDescriptor_Type)) {
// Most callers consider extensions as a plain dictionary. We should
// allow input which is not a field descriptor, and simply pretend it does
// not exist.
PyErr_SetObject(PyExc_KeyError, extension);
return NULL;
}
return PyFieldDescriptor_AsDescriptor(extension);
}
// If cmessage_list is not NULL, this function releases values into the
// container CMessages instead of just removing. Repeated composite container
// needs to do this to make sure CMessages stay alive if they're still
// referenced after deletion. Repeated scalar container doesn't need to worry.
int InternalDeleteRepeatedField(
Message* message,
const FieldDescriptor* field_descriptor,
PyObject* slice,
PyObject* cmessage_list) {
Py_ssize_t length, from, to, step, slice_length;
const Reflection* reflection = message->GetReflection();
int min, max;
length = reflection->FieldSize(*message, field_descriptor);
if (PyInt_Check(slice) || PyLong_Check(slice)) {
from = to = PyLong_AsLong(slice);
if (from < 0) {
from = to = length + from;
}
step = 1;
min = max = from;
// Range check.
if (from < 0 || from >= length) {
PyErr_Format(PyExc_IndexError, "list assignment index out of range");
return -1;
}
} else if (PySlice_Check(slice)) {
from = to = step = slice_length = 0;
PySlice_GetIndicesEx(
#if PY_MAJOR_VERSION < 3
reinterpret_cast<PySliceObject*>(slice),
#else
slice,
#endif
length, &from, &to, &step, &slice_length);
if (from < to) {
min = from;
max = to - 1;
} else {
min = to + 1;
max = from;
}
} else {
PyErr_SetString(PyExc_TypeError, "list indices must be integers");
return -1;
}
Py_ssize_t i = from;
std::vector<bool> to_delete(length, false);
while (i >= min && i <= max) {
to_delete[i] = true;
i += step;
}
to = 0;
for (i = 0; i < length; ++i) {
if (!to_delete[i]) {
if (i != to) {
reflection->SwapElements(message, field_descriptor, i, to);
if (cmessage_list != NULL) {
// If a list of cmessages is passed in (i.e. from a repeated
// composite container), swap those as well to correspond to the
// swaps in the underlying message so they're in the right order
// when we start releasing.
PyObject* tmp = PyList_GET_ITEM(cmessage_list, i);
PyList_SET_ITEM(cmessage_list, i,
PyList_GET_ITEM(cmessage_list, to));
PyList_SET_ITEM(cmessage_list, to, tmp);
}
}
++to;
}
}
while (i > to) {
if (cmessage_list == NULL) {
reflection->RemoveLast(message, field_descriptor);
} else {
CMessage* last_cmessage = reinterpret_cast<CMessage*>(
PyList_GET_ITEM(cmessage_list, PyList_GET_SIZE(cmessage_list) - 1));
repeated_composite_container::ReleaseLastTo(
field_descriptor, message, last_cmessage);
if (PySequence_DelItem(cmessage_list, -1) < 0) {
return -1;
}
}
--i;
}
return 0;
}
// Initializes fields of a message. Used in constructors.
int InitAttributes(CMessage* self, PyObject* kwargs) {
if (kwargs == NULL) {
return 0;
}
Py_ssize_t pos = 0;
PyObject* name;
PyObject* value;
while (PyDict_Next(kwargs, &pos, &name, &value)) {
if (!PyString_Check(name)) {
PyErr_SetString(PyExc_ValueError, "Field name must be a string");
return -1;
}
const FieldDescriptor* descriptor = GetFieldDescriptor(self, name);
if (descriptor == NULL) {
PyErr_Format(PyExc_ValueError, "Protocol message has no \"%s\" field.",
PyString_AsString(name));
return -1;
}
if (descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
ScopedPyObjectPtr container(GetAttr(self, name));
if (container == NULL) {
return -1;
}
if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
if (repeated_composite_container::Extend(
reinterpret_cast<RepeatedCompositeContainer*>(container.get()),
value)
== NULL) {
return -1;
}
} else {
if (repeated_scalar_container::Extend(
reinterpret_cast<RepeatedScalarContainer*>(container.get()),
value) ==
NULL) {
return -1;
}
}
} else if (descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
ScopedPyObjectPtr message(GetAttr(self, name));
if (message == NULL) {
return -1;
}
if (MergeFrom(reinterpret_cast<CMessage*>(message.get()),
value) == NULL) {
return -1;
}
} else {
if (SetAttr(self, name, value) < 0) {
return -1;
}
}
}
return 0;
}
// Allocates an incomplete Python Message: the caller must fill self->message,
// self->owner and eventually self->parent.
CMessage* NewEmptyMessage(PyObject* type, const Descriptor *descriptor) {
CMessage* self = reinterpret_cast<CMessage*>(
PyType_GenericAlloc(reinterpret_cast<PyTypeObject*>(type), 0));
if (self == NULL) {
return NULL;
}
self->message = NULL;
self->parent = NULL;
self->parent_field_descriptor = NULL;
self->read_only = false;
self->extensions = NULL;
self->composite_fields = NULL;
// If there are extension_ranges, the message is "extendable". Allocate a
// dictionary to store the extension fields.
if (descriptor->extension_range_count() > 0) {
// TODO(amauryfa): Delay the construction of this dict until extensions are
// really used on the object.
ExtensionDict* extension_dict = extension_dict::NewExtensionDict(self);
if (extension_dict == NULL) {
return NULL;
}
self->extensions = extension_dict;
}
return self;
}
// The __new__ method of Message classes.
// Creates a new C++ message and takes ownership.
static PyObject* New(PyTypeObject* type,
PyObject* unused_args, PyObject* unused_kwargs) {
// Retrieve the message descriptor and the default instance (=prototype).
const Descriptor* message_descriptor = GetMessageDescriptor(type);
if (message_descriptor == NULL) {
return NULL;
}
const Message* default_message =
message_factory->GetPrototype(message_descriptor);
if (default_message == NULL) {
PyErr_SetString(PyExc_TypeError, message_descriptor->full_name().c_str());
return NULL;
}
CMessage* self = NewEmptyMessage(reinterpret_cast<PyObject*>(type),
message_descriptor);
if (self == NULL) {
return NULL;
}
self->message = default_message->New();
self->owner.reset(self->message);
return reinterpret_cast<PyObject*>(self);
}
// The __init__ method of Message classes.
// It initializes fields from keywords passed to the constructor.
static int Init(CMessage* self, PyObject* args, PyObject* kwargs) {
if (PyTuple_Size(args) != 0) {
PyErr_SetString(PyExc_TypeError, "No positional arguments allowed");
return -1;
}
return InitAttributes(self, kwargs);
}
// ---------------------------------------------------------------------
// Deallocating a CMessage
//
// Deallocating a CMessage requires that we clear any weak references
// from children to the message being deallocated.
// Clear the weak reference from the child to the parent.
struct ClearWeakReferences : public ChildVisitor {
int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
container->parent = NULL;
// The elements in the container have the same parent as the
// container itself, so NULL out that pointer as well.
const Py_ssize_t n = PyList_GET_SIZE(container->child_messages);
for (Py_ssize_t i = 0; i < n; ++i) {
CMessage* child_cmessage = reinterpret_cast<CMessage*>(
PyList_GET_ITEM(container->child_messages, i));
child_cmessage->parent = NULL;
}
return 0;
}
int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
container->parent = NULL;
return 0;
}
int VisitCMessage(CMessage* cmessage,
const FieldDescriptor* field_descriptor) {
cmessage->parent = NULL;
return 0;
}
};
static void Dealloc(CMessage* self) {
// Null out all weak references from children to this message.
GOOGLE_CHECK_EQ(0, ForEachCompositeField(self, ClearWeakReferences()));
Py_CLEAR(self->extensions);
Py_CLEAR(self->composite_fields);
self->owner.reset();
Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
}
// ---------------------------------------------------------------------
PyObject* IsInitialized(CMessage* self, PyObject* args) {
PyObject* errors = NULL;
if (PyArg_ParseTuple(args, "|O", &errors) < 0) {
return NULL;
}
if (self->message->IsInitialized()) {
Py_RETURN_TRUE;
}
if (errors != NULL) {
ScopedPyObjectPtr initialization_errors(
FindInitializationErrors(self));
if (initialization_errors == NULL) {
return NULL;
}
ScopedPyObjectPtr extend_name(PyString_FromString("extend"));
if (extend_name == NULL) {
return NULL;
}
ScopedPyObjectPtr result(PyObject_CallMethodObjArgs(
errors,
extend_name.get(),
initialization_errors.get(),
NULL));
if (result == NULL) {
return NULL;
}
}
Py_RETURN_FALSE;
}
PyObject* HasFieldByDescriptor(
CMessage* self, const FieldDescriptor* field_descriptor) {
Message* message = self->message;
if (!CheckFieldBelongsToMessage(field_descriptor, message)) {
return NULL;
}
if (field_descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
PyErr_SetString(PyExc_KeyError,
"Field is repeated. A singular method is required.");
return NULL;
}
bool has_field =
message->GetReflection()->HasField(*message, field_descriptor);
return PyBool_FromLong(has_field ? 1 : 0);
}
const FieldDescriptor* FindFieldWithOneofs(
const Message* message, const string& field_name, bool* in_oneof) {
*in_oneof = false;
const Descriptor* descriptor = message->GetDescriptor();
const FieldDescriptor* field_descriptor =
descriptor->FindFieldByName(field_name);
if (field_descriptor != NULL) {
return field_descriptor;
}
const OneofDescriptor* oneof_desc =
descriptor->FindOneofByName(field_name);
if (oneof_desc != NULL) {
*in_oneof = true;
return message->GetReflection()->GetOneofFieldDescriptor(*message,
oneof_desc);
}
return NULL;
}
bool CheckHasPresence(const FieldDescriptor* field_descriptor, bool in_oneof) {
if (field_descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
PyErr_Format(PyExc_ValueError,
"Protocol message has no singular \"%s\" field.",
field_descriptor->name().c_str());
return false;
}
if (field_descriptor->file()->syntax() == FileDescriptor::SYNTAX_PROTO3) {
// HasField() for a oneof *itself* isn't supported.
if (in_oneof) {
PyErr_Format(PyExc_ValueError,
"Can't test oneof field \"%s\" for presence in proto3, use "
"WhichOneof instead.",
field_descriptor->containing_oneof()->name().c_str());
return false;
}
// ...but HasField() for fields *in* a oneof is supported.
if (field_descriptor->containing_oneof() != NULL) {
return true;
}
if (field_descriptor->cpp_type() != FieldDescriptor::CPPTYPE_MESSAGE) {
PyErr_Format(
PyExc_ValueError,
"Can't test non-submessage field \"%s\" for presence in proto3.",
field_descriptor->name().c_str());
return false;
}
}
return true;
}
PyObject* HasField(CMessage* self, PyObject* arg) {
char* field_name;
Py_ssize_t size;
#if PY_MAJOR_VERSION < 3
if (PyString_AsStringAndSize(arg, &field_name, &size) < 0) {
return NULL;
}
#else
field_name = PyUnicode_AsUTF8AndSize(arg, &size);
if (!field_name) {
return NULL;
}
#endif
Message* message = self->message;
bool is_in_oneof;
const FieldDescriptor* field_descriptor =
FindFieldWithOneofs(message, string(field_name, size), &is_in_oneof);
if (field_descriptor == NULL) {
if (!is_in_oneof) {
PyErr_Format(PyExc_ValueError, "Unknown field %s.", field_name);
return NULL;
} else {
Py_RETURN_FALSE;
}
}
if (!CheckHasPresence(field_descriptor, is_in_oneof)) {
return NULL;
}
if (message->GetReflection()->HasField(*message, field_descriptor)) {
Py_RETURN_TRUE;
}
if (!message->GetReflection()->SupportsUnknownEnumValues() &&
field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_ENUM) {
// Special case: Python HasField() differs in semantics from C++
// slightly: we return HasField('enum_field') == true if there is
// an unknown enum value present. To implement this we have to
// look in the UnknownFieldSet.
const UnknownFieldSet& unknown_field_set =
message->GetReflection()->GetUnknownFields(*message);
for (int i = 0; i < unknown_field_set.field_count(); ++i) {
if (unknown_field_set.field(i).number() == field_descriptor->number()) {
Py_RETURN_TRUE;
}
}
}
Py_RETURN_FALSE;
}
PyObject* ClearExtension(CMessage* self, PyObject* arg) {
if (self->extensions != NULL) {
return extension_dict::ClearExtension(self->extensions, arg);
}
PyErr_SetString(PyExc_TypeError, "Message is not extendable");
return NULL;
}
PyObject* HasExtension(CMessage* self, PyObject* arg) {
if (self->extensions != NULL) {
return extension_dict::HasExtension(self->extensions, arg);
}
PyErr_SetString(PyExc_TypeError, "Message is not extendable");
return NULL;
}
// ---------------------------------------------------------------------
// Releasing messages
//
// The Python API's ClearField() and Clear() methods behave
// differently than their C++ counterparts. While the C++ versions
// clears the children the Python versions detaches the children,
// without touching their content. This impedance mismatch causes
// some complexity in the implementation, which is captured in this
// section.
//
// When a CMessage field is cleared we need to:
//
// * Release the Message used as the backing store for the CMessage
// from its parent.
//
// * Change the owner field of the released CMessage and all of its
// children to point to the newly released Message.
//
// * Clear the weak references from the released CMessage to the
// parent.
//
// When a RepeatedCompositeContainer field is cleared we need to:
//
// * Release all the Message used as the backing store for the
// CMessages stored in the container.
//
// * Change the owner field of all the released CMessage and all of
// their children to point to the newly released Messages.
//
// * Clear the weak references from the released container to the
// parent.
struct SetOwnerVisitor : public ChildVisitor {
// new_owner must outlive this object.
explicit SetOwnerVisitor(const shared_ptr<Message>& new_owner)
: new_owner_(new_owner) {}
int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
repeated_composite_container::SetOwner(container, new_owner_);
return 0;
}
int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
repeated_scalar_container::SetOwner(container, new_owner_);
return 0;
}
int VisitCMessage(CMessage* cmessage,
const FieldDescriptor* field_descriptor) {
return SetOwner(cmessage, new_owner_);
}
private:
const shared_ptr<Message>& new_owner_;
};
// Change the owner of this CMessage and all its children, recursively.
int SetOwner(CMessage* self, const shared_ptr<Message>& new_owner) {
self->owner = new_owner;
if (ForEachCompositeField(self, SetOwnerVisitor(new_owner)) == -1)
return -1;
return 0;
}
// Releases the message specified by 'field' and returns the
// pointer. If the field does not exist a new message is created using
// 'descriptor'. The caller takes ownership of the returned pointer.
Message* ReleaseMessage(Message* message,
const Descriptor* descriptor,
const FieldDescriptor* field_descriptor) {
Message* released_message = message->GetReflection()->ReleaseMessage(
message, field_descriptor, message_factory);
// ReleaseMessage will return NULL which differs from
// child_cmessage->message, if the field does not exist. In this case,
// the latter points to the default instance via a const_cast<>, so we
// have to reset it to a new mutable object since we are taking ownership.
if (released_message == NULL) {
const Message* prototype = message_factory->GetPrototype(descriptor);
GOOGLE_DCHECK(prototype != NULL);
released_message = prototype->New();
}
return released_message;
}
int ReleaseSubMessage(Message* message,
const FieldDescriptor* field_descriptor,
CMessage* child_cmessage) {
// Release the Message
shared_ptr<Message> released_message(ReleaseMessage(
message, child_cmessage->message->GetDescriptor(), field_descriptor));
child_cmessage->message = released_message.get();
child_cmessage->owner.swap(released_message);
child_cmessage->parent = NULL;
child_cmessage->parent_field_descriptor = NULL;
child_cmessage->read_only = false;
return ForEachCompositeField(child_cmessage,
SetOwnerVisitor(child_cmessage->owner));
}
struct ReleaseChild : public ChildVisitor {
// message must outlive this object.
explicit ReleaseChild(Message* parent_message) :
parent_message_(parent_message) {}
int VisitRepeatedCompositeContainer(RepeatedCompositeContainer* container) {
return repeated_composite_container::Release(
reinterpret_cast<RepeatedCompositeContainer*>(container));
}
int VisitRepeatedScalarContainer(RepeatedScalarContainer* container) {
return repeated_scalar_container::Release(
reinterpret_cast<RepeatedScalarContainer*>(container));
}
int VisitCMessage(CMessage* cmessage,
const FieldDescriptor* field_descriptor) {
return ReleaseSubMessage(parent_message_, field_descriptor,
reinterpret_cast<CMessage*>(cmessage));
}
Message* parent_message_;
};
int InternalReleaseFieldByDescriptor(
const FieldDescriptor* field_descriptor,
PyObject* composite_field,
Message* parent_message) {
return VisitCompositeField(
field_descriptor,
composite_field,
ReleaseChild(parent_message));
}
PyObject* ClearFieldByDescriptor(
CMessage* self,
const FieldDescriptor* descriptor) {
if (!CheckFieldBelongsToMessage(descriptor, self->message)) {
return NULL;
}
AssureWritable(self);
self->message->GetReflection()->ClearField(self->message, descriptor);
Py_RETURN_NONE;
}
PyObject* ClearField(CMessage* self, PyObject* arg) {
if (!PyString_Check(arg)) {
PyErr_SetString(PyExc_TypeError, "field name must be a string");
return NULL;
}
#if PY_MAJOR_VERSION < 3
const char* field_name = PyString_AS_STRING(arg);
Py_ssize_t size = PyString_GET_SIZE(arg);
#else
Py_ssize_t size;
const char* field_name = PyUnicode_AsUTF8AndSize(arg, &size);
#endif
AssureWritable(self);
Message* message = self->message;
ScopedPyObjectPtr arg_in_oneof;
bool is_in_oneof;
const FieldDescriptor* field_descriptor =
FindFieldWithOneofs(message, string(field_name, size), &is_in_oneof);
if (field_descriptor == NULL) {
if (!is_in_oneof) {
PyErr_Format(PyExc_ValueError,
"Protocol message has no \"%s\" field.", field_name);
return NULL;
} else {
Py_RETURN_NONE;
}
} else if (is_in_oneof) {
const string& name = field_descriptor->name();
arg_in_oneof.reset(PyString_FromStringAndSize(name.c_str(), name.size()));
arg = arg_in_oneof.get();
}
PyObject* composite_field = self->composite_fields ?
PyDict_GetItem(self->composite_fields, arg) : NULL;
// Only release the field if there's a possibility that there are
// references to it.
if (composite_field != NULL) {
if (InternalReleaseFieldByDescriptor(field_descriptor,
composite_field, message) < 0) {
return NULL;
}
PyDict_DelItem(self->composite_fields, arg);
}
message->GetReflection()->ClearField(message, field_descriptor);
if (field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_ENUM &&
!message->GetReflection()->SupportsUnknownEnumValues()) {
UnknownFieldSet* unknown_field_set =
message->GetReflection()->MutableUnknownFields(message);
unknown_field_set->DeleteByNumber(field_descriptor->number());
}
Py_RETURN_NONE;
}
PyObject* Clear(CMessage* self) {
AssureWritable(self);
if (ForEachCompositeField(self, ReleaseChild(self->message)) == -1)
return NULL;
// The old ExtensionDict still aliases this CMessage, but all its
// fields have been released.
if (self->extensions != NULL) {
Py_CLEAR(self->extensions);
ExtensionDict* extension_dict = extension_dict::NewExtensionDict(self);
if (extension_dict == NULL) {
return NULL;
}
self->extensions = extension_dict;
}
if (self->composite_fields) {
PyDict_Clear(self->composite_fields);
}
self->message->Clear();
Py_RETURN_NONE;
}
// ---------------------------------------------------------------------
static string GetMessageName(CMessage* self) {
if (self->parent_field_descriptor != NULL) {
return self->parent_field_descriptor->full_name();
} else {
return self->message->GetDescriptor()->full_name();
}
}
static PyObject* SerializeToString(CMessage* self, PyObject* args) {
if (!self->message->IsInitialized()) {
ScopedPyObjectPtr errors(FindInitializationErrors(self));
if (errors == NULL) {
return NULL;
}
ScopedPyObjectPtr comma(PyString_FromString(","));
if (comma == NULL) {
return NULL;
}
ScopedPyObjectPtr joined(
PyObject_CallMethod(comma.get(), "join", "O", errors.get()));
if (joined == NULL) {
return NULL;
}
PyErr_Format(EncodeError_class, "Message %s is missing required fields: %s",
GetMessageName(self).c_str(), PyString_AsString(joined));
return NULL;
}
int size = self->message->ByteSize();
if (size <= 0) {
return PyBytes_FromString("");
}
PyObject* result = PyBytes_FromStringAndSize(NULL, size);
if (result == NULL) {
return NULL;
}
char* buffer = PyBytes_AS_STRING(result);
self->message->SerializeWithCachedSizesToArray(
reinterpret_cast<uint8*>(buffer));
return result;
}
static PyObject* SerializePartialToString(CMessage* self) {
string contents;
self->message->SerializePartialToString(&contents);
return PyBytes_FromStringAndSize(contents.c_str(), contents.size());
}
// Formats proto fields for ascii dumps using python formatting functions where
// appropriate.
class PythonFieldValuePrinter : public TextFormat::FieldValuePrinter {
public:
PythonFieldValuePrinter() : float_holder_(PyFloat_FromDouble(0)) {}
// Python has some differences from C++ when printing floating point numbers.
//
// 1) Trailing .0 is always printed.
// 2) Outputted is rounded to 12 digits.
//
// We override floating point printing with the C-API function for printing
// Python floats to ensure consistency.
string PrintFloat(float value) const { return PrintDouble(value); }
string PrintDouble(double value) const {
reinterpret_cast<PyFloatObject*>(float_holder_.get())->ob_fval = value;
ScopedPyObjectPtr s(PyObject_Str(float_holder_.get()));
if (s == NULL) return string();
#if PY_MAJOR_VERSION < 3
char *cstr = PyBytes_AS_STRING(static_cast<PyObject*>(s));
#else
char *cstr = PyUnicode_AsUTF8(s);
#endif
return string(cstr);
}
private:
// Holder for a python float object which we use to allow us to use
// the Python API for printing doubles. We initialize once and then
// directly modify it for every float printed to save on allocations
// and refcounting.
ScopedPyObjectPtr float_holder_;
};
static PyObject* ToStr(CMessage* self) {
TextFormat::Printer printer;
// Passes ownership
printer.SetDefaultFieldValuePrinter(new PythonFieldValuePrinter());
printer.SetHideUnknownFields(true);
string output;
if (!printer.PrintToString(*self->message, &output)) {
PyErr_SetString(PyExc_ValueError, "Unable to convert message to str");
return NULL;
}
return PyString_FromString(output.c_str());
}
PyObject* MergeFrom(CMessage* self, PyObject* arg) {
CMessage* other_message;
if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), &CMessage_Type)) {
PyErr_SetString(PyExc_TypeError, "Must be a message");
return NULL;
}
other_message = reinterpret_cast<CMessage*>(arg);
if (other_message->message->GetDescriptor() !=
self->message->GetDescriptor()) {
PyErr_Format(PyExc_TypeError,
"Tried to merge from a message with a different type. "
"to: %s, from: %s",
self->message->GetDescriptor()->full_name().c_str(),
other_message->message->GetDescriptor()->full_name().c_str());
return NULL;
}
AssureWritable(self);
// TODO(tibell): Message::MergeFrom might turn some child Messages
// into mutable messages, invalidating the message field in the
// corresponding CMessages. We should run a FixupMessageReferences
// pass here.
self->message->MergeFrom(*other_message->message);
Py_RETURN_NONE;
}
static PyObject* CopyFrom(CMessage* self, PyObject* arg) {
CMessage* other_message;
if (!PyObject_TypeCheck(reinterpret_cast<PyObject *>(arg), &CMessage_Type)) {
PyErr_SetString(PyExc_TypeError, "Must be a message");
return NULL;
}
other_message = reinterpret_cast<CMessage*>(arg);
if (self == other_message) {
Py_RETURN_NONE;
}
if (other_message->message->GetDescriptor() !=
self->message->GetDescriptor()) {
PyErr_Format(PyExc_TypeError,
"Tried to copy from a message with a different type. "
"to: %s, from: %s",
self->message->GetDescriptor()->full_name().c_str(),
other_message->message->GetDescriptor()->full_name().c_str());
return NULL;
}
AssureWritable(self);
// CopyFrom on the message will not clean up self->composite_fields,
// which can leave us in an inconsistent state, so clear it out here.
Clear(self);
self->message->CopyFrom(*other_message->message);
Py_RETURN_NONE;
}
static PyObject* MergeFromString(CMessage* self, PyObject* arg) {
const void* data;
Py_ssize_t data_length;
if (PyObject_AsReadBuffer(arg, &data, &data_length) < 0) {
return NULL;
}
AssureWritable(self);
io::CodedInputStream input(
reinterpret_cast<const uint8*>(data), data_length);
input.SetExtensionRegistry(GetDescriptorPool()->pool, message_factory);
bool success = self->message->MergePartialFromCodedStream(&input);
if (success) {
return PyInt_FromLong(input.CurrentPosition());
} else {
PyErr_Format(DecodeError_class, "Error parsing message");
return NULL;
}
}
static PyObject* ParseFromString(CMessage* self, PyObject* arg) {
if (Clear(self) == NULL) {
return NULL;
}
return MergeFromString(self, arg);
}
static PyObject* ByteSize(CMessage* self, PyObject* args) {
return PyLong_FromLong(self->message->ByteSize());
}
static PyObject* RegisterExtension(PyObject* cls,
PyObject* extension_handle) {
ScopedPyObjectPtr message_descriptor(PyObject_GetAttr(cls, kDESCRIPTOR));
if (message_descriptor == NULL) {
return NULL;
}
const FieldDescriptor* descriptor =
GetExtensionDescriptor(extension_handle);
if (descriptor == NULL) {
return NULL;
}
const Descriptor* cmessage_descriptor = GetMessageDescriptor(
reinterpret_cast<PyTypeObject*>(cls));
if (cmessage_descriptor != descriptor->containing_type()) {
if (PyObject_SetAttrString(extension_handle, "containing_type",
message_descriptor) < 0) {
return NULL;
}
}
ScopedPyObjectPtr extensions_by_name(
PyObject_GetAttr(cls, k_extensions_by_name));
if (extensions_by_name == NULL) {
PyErr_SetString(PyExc_TypeError, "no extensions_by_name on class");
return NULL;
}
ScopedPyObjectPtr full_name(PyObject_GetAttr(extension_handle, kfull_name));
if (full_name == NULL) {
return NULL;
}
// If the extension was already registered, check that it is the same.
PyObject* existing_extension = PyDict_GetItem(extensions_by_name, full_name);
if (existing_extension != NULL) {
const FieldDescriptor* existing_extension_descriptor =
GetExtensionDescriptor(existing_extension);
if (existing_extension_descriptor != descriptor) {
PyErr_SetString(PyExc_ValueError, "Double registration of Extensions");
return NULL;
}
// Nothing else to do.
Py_RETURN_NONE;
}
if (PyDict_SetItem(extensions_by_name, full_name, extension_handle) < 0) {
return NULL;
}
// Also store a mapping from extension number to implementing class.
ScopedPyObjectPtr extensions_by_number(
PyObject_GetAttr(cls, k_extensions_by_number));
if (extensions_by_number == NULL) {
PyErr_SetString(PyExc_TypeError, "no extensions_by_number on class");
return NULL;
}
ScopedPyObjectPtr number(PyObject_GetAttrString(extension_handle, "number"));
if (number == NULL) {
return NULL;
}
if (PyDict_SetItem(extensions_by_number, number, extension_handle) < 0) {
return NULL;
}
// Check if it's a message set
if (descriptor->is_extension() &&
descriptor->containing_type()->options().message_set_wire_format() &&
descriptor->type() == FieldDescriptor::TYPE_MESSAGE &&
descriptor->message_type() == descriptor->extension_scope() &&
descriptor->label() == FieldDescriptor::LABEL_OPTIONAL) {
ScopedPyObjectPtr message_name(PyString_FromStringAndSize(
descriptor->message_type()->full_name().c_str(),
descriptor->message_type()->full_name().size()));
if (message_name == NULL) {
return NULL;
}
PyDict_SetItem(extensions_by_name, message_name, extension_handle);
}
Py_RETURN_NONE;
}
static PyObject* SetInParent(CMessage* self, PyObject* args) {
AssureWritable(self);
Py_RETURN_NONE;
}
static PyObject* WhichOneof(CMessage* self, PyObject* arg) {
Py_ssize_t name_size;
char *name_data;
if (PyString_AsStringAndSize(arg, &name_data, &name_size) < 0)
return NULL;
string oneof_name = string(name_data, name_size);
const OneofDescriptor* oneof_desc =
self->message->GetDescriptor()->FindOneofByName(oneof_name);
if (oneof_desc == NULL) {
PyErr_Format(PyExc_ValueError,
"Protocol message has no oneof \"%s\" field.",
oneof_name.c_str());
return NULL;
}
const FieldDescriptor* field_in_oneof =
self->message->GetReflection()->GetOneofFieldDescriptor(
*self->message, oneof_desc);
if (field_in_oneof == NULL) {
Py_RETURN_NONE;
} else {
const string& name = field_in_oneof->name();
return PyString_FromStringAndSize(name.c_str(), name.size());
}
}
static PyObject* ListFields(CMessage* self) {
vector<const FieldDescriptor*> fields;
self->message->GetReflection()->ListFields(*self->message, &fields);
// Normally, the list will be exactly the size of the fields.
ScopedPyObjectPtr all_fields(PyList_New(fields.size()));
if (all_fields == NULL) {
return NULL;
}
// When there are unknown extensions, the py list will *not* contain
// the field information. Thus the actual size of the py list will be
// smaller than the size of fields. Set the actual size at the end.
Py_ssize_t actual_size = 0;
for (Py_ssize_t i = 0; i < fields.size(); ++i) {
ScopedPyObjectPtr t(PyTuple_New(2));
if (t == NULL) {
return NULL;
}
if (fields[i]->is_extension()) {
ScopedPyObjectPtr extension_field(PyFieldDescriptor_New(fields[i]));
if (extension_field == NULL) {
return NULL;
}
// With C++ descriptors, the field can always be retrieved, but for
// unknown extensions which have not been imported in Python code, there
// is no message class and we cannot retrieve the value.
// TODO(amauryfa): consider building the class on the fly!
if (fields[i]->message_type() != NULL &&
cdescriptor_pool::GetMessageClass(
GetDescriptorPool(), fields[i]->message_type()) == NULL) {
PyErr_Clear();
continue;
}
PyObject* extensions = reinterpret_cast<PyObject*>(self->extensions);
if (extensions == NULL) {
return NULL;
}
// 'extension' reference later stolen by PyTuple_SET_ITEM.
PyObject* extension = PyObject_GetItem(extensions, extension_field);
if (extension == NULL) {
return NULL;
}
PyTuple_SET_ITEM(t.get(), 0, extension_field.release());
// Steals reference to 'extension'
PyTuple_SET_ITEM(t.get(), 1, extension);
} else {
const string& field_name = fields[i]->name();
ScopedPyObjectPtr py_field_name(PyString_FromStringAndSize(
field_name.c_str(), field_name.length()));
if (py_field_name == NULL) {
PyErr_SetString(PyExc_ValueError, "bad string");
return NULL;
}
ScopedPyObjectPtr field_descriptor(PyFieldDescriptor_New(fields[i]));
if (field_descriptor == NULL) {
return NULL;
}
PyObject* field_value = GetAttr(self, py_field_name);
if (field_value == NULL) {
PyErr_SetObject(PyExc_ValueError, py_field_name);
return NULL;
}
PyTuple_SET_ITEM(t.get(), 0, field_descriptor.release());
PyTuple_SET_ITEM(t.get(), 1, field_value);
}
PyList_SET_ITEM(all_fields.get(), actual_size, t.release());
++actual_size;
}
Py_SIZE(all_fields.get()) = actual_size;
return all_fields.release();
}
PyObject* FindInitializationErrors(CMessage* self) {
Message* message = self->message;
vector<string> errors;
message->FindInitializationErrors(&errors);
PyObject* error_list = PyList_New(errors.size());
if (error_list == NULL) {
return NULL;
}
for (Py_ssize_t i = 0; i < errors.size(); ++i) {
const string& error = errors[i];
PyObject* error_string = PyString_FromStringAndSize(
error.c_str(), error.length());
if (error_string == NULL) {
Py_DECREF(error_list);
return NULL;
}
PyList_SET_ITEM(error_list, i, error_string);
}
return error_list;
}
static PyObject* RichCompare(CMessage* self, PyObject* other, int opid) {
if (!PyObject_TypeCheck(other, &CMessage_Type)) {
if (opid == Py_EQ) {
Py_RETURN_FALSE;
} else if (opid == Py_NE) {
Py_RETURN_TRUE;
}
}
if (opid == Py_EQ || opid == Py_NE) {
ScopedPyObjectPtr self_fields(ListFields(self));
if (!self_fields) {
return NULL;
}
ScopedPyObjectPtr other_fields(ListFields(
reinterpret_cast<CMessage*>(other)));
if (!other_fields) {
return NULL;
}
return PyObject_RichCompare(self_fields, other_fields, opid);
} else {
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
}
PyObject* InternalGetScalar(
CMessage* self,
const FieldDescriptor* field_descriptor) {
Message* message = self->message;
const Reflection* reflection = message->GetReflection();
if (!CheckFieldBelongsToMessage(field_descriptor, message)) {
return NULL;
}
PyObject* result = NULL;
switch (field_descriptor->cpp_type()) {
case FieldDescriptor::CPPTYPE_INT32: {
int32 value = reflection->GetInt32(*message, field_descriptor);
result = PyInt_FromLong(value);
break;
}
case FieldDescriptor::CPPTYPE_INT64: {
int64 value = reflection->GetInt64(*message, field_descriptor);
result = PyLong_FromLongLong(value);
break;
}
case FieldDescriptor::CPPTYPE_UINT32: {
uint32 value = reflection->GetUInt32(*message, field_descriptor);
result = PyInt_FromSize_t(value);
break;
}
case FieldDescriptor::CPPTYPE_UINT64: {
uint64 value = reflection->GetUInt64(*message, field_descriptor);
result = PyLong_FromUnsignedLongLong(value);
break;
}
case FieldDescriptor::CPPTYPE_FLOAT: {
float value = reflection->GetFloat(*message, field_descriptor);
result = PyFloat_FromDouble(value);
break;
}
case FieldDescriptor::CPPTYPE_DOUBLE: {
double value = reflection->GetDouble(*message, field_descriptor);
result = PyFloat_FromDouble(value);
break;
}
case FieldDescriptor::CPPTYPE_BOOL: {
bool value = reflection->GetBool(*message, field_descriptor);
result = PyBool_FromLong(value);
break;
}
case FieldDescriptor::CPPTYPE_STRING: {
string value = reflection->GetString(*message, field_descriptor);
result = ToStringObject(field_descriptor, value);
break;
}
case FieldDescriptor::CPPTYPE_ENUM: {
if (!message->GetReflection()->SupportsUnknownEnumValues() &&
!message->GetReflection()->HasField(*message, field_descriptor)) {
// Look for the value in the unknown fields.
UnknownFieldSet* unknown_field_set =
message->GetReflection()->MutableUnknownFields(message);
for (int i = 0; i < unknown_field_set->field_count(); ++i) {
if (unknown_field_set->field(i).number() ==
field_descriptor->number()) {
result = PyInt_FromLong(unknown_field_set->field(i).varint());
break;
}
}
}
if (result == NULL) {
const EnumValueDescriptor* enum_value =
message->GetReflection()->GetEnum(*message, field_descriptor);
result = PyInt_FromLong(enum_value->number());
}
break;
}
default:
PyErr_Format(
PyExc_SystemError, "Getting a value from a field of unknown type %d",
field_descriptor->cpp_type());
}
return result;
}
PyObject* InternalGetSubMessage(
CMessage* self, const FieldDescriptor* field_descriptor) {
const Reflection* reflection = self->message->GetReflection();
const Message& sub_message = reflection->GetMessage(
*self->message, field_descriptor, message_factory);
PyObject *message_class = cdescriptor_pool::GetMessageClass(
GetDescriptorPool(), field_descriptor->message_type());
if (message_class == NULL) {
return NULL;
}
CMessage* cmsg = cmessage::NewEmptyMessage(message_class,
sub_message.GetDescriptor());
if (cmsg == NULL) {
return NULL;
}
cmsg->owner = self->owner;
cmsg->parent = self;
cmsg->parent_field_descriptor = field_descriptor;
cmsg->read_only = !reflection->HasField(*self->message, field_descriptor);
cmsg->message = const_cast<Message*>(&sub_message);
return reinterpret_cast<PyObject*>(cmsg);
}
int InternalSetScalar(
CMessage* self,
const FieldDescriptor* field_descriptor,
PyObject* arg) {
Message* message = self->message;
const Reflection* reflection = message->GetReflection();
if (!CheckFieldBelongsToMessage(field_descriptor, message)) {
return -1;
}
if (MaybeReleaseOverlappingOneofField(self, field_descriptor) < 0) {
return -1;
}
switch (field_descriptor->cpp_type()) {
case FieldDescriptor::CPPTYPE_INT32: {
GOOGLE_CHECK_GET_INT32(arg, value, -1);
reflection->SetInt32(message, field_descriptor, value);
break;
}
case FieldDescriptor::CPPTYPE_INT64: {
GOOGLE_CHECK_GET_INT64(arg, value, -1);
reflection->SetInt64(message, field_descriptor, value);
break;
}
case FieldDescriptor::CPPTYPE_UINT32: {
GOOGLE_CHECK_GET_UINT32(arg, value, -1);
reflection->SetUInt32(message, field_descriptor, value);
break;
}
case FieldDescriptor::CPPTYPE_UINT64: {
GOOGLE_CHECK_GET_UINT64(arg, value, -1);
reflection->SetUInt64(message, field_descriptor, value);
break;
}
case FieldDescriptor::CPPTYPE_FLOAT: {
GOOGLE_CHECK_GET_FLOAT(arg, value, -1);
reflection->SetFloat(message, field_descriptor, value);
break;
}
case FieldDescriptor::CPPTYPE_DOUBLE: {
GOOGLE_CHECK_GET_DOUBLE(arg, value, -1);
reflection->SetDouble(message, field_descriptor, value);
break;
}
case FieldDescriptor::CPPTYPE_BOOL: {
GOOGLE_CHECK_GET_BOOL(arg, value, -1);
reflection->SetBool(message, field_descriptor, value);
break;
}
case FieldDescriptor::CPPTYPE_STRING: {
if (!CheckAndSetString(
arg, message, field_descriptor, reflection, false, -1)) {
return -1;
}
break;
}
case FieldDescriptor::CPPTYPE_ENUM: {
GOOGLE_CHECK_GET_INT32(arg, value, -1);
if (reflection->SupportsUnknownEnumValues()) {
reflection->SetEnumValue(message, field_descriptor, value);
} else {
const EnumDescriptor* enum_descriptor = field_descriptor->enum_type();
const EnumValueDescriptor* enum_value =
enum_descriptor->FindValueByNumber(value);
if (enum_value != NULL) {
reflection->SetEnum(message, field_descriptor, enum_value);
} else {
PyErr_Format(PyExc_ValueError, "Unknown enum value: %d", value);
return -1;
}
}
break;
}
default:
PyErr_Format(
PyExc_SystemError, "Setting value to a field of unknown type %d",
field_descriptor->cpp_type());
return -1;
}
return 0;
}
PyObject* FromString(PyTypeObject* cls, PyObject* serialized) {
PyObject* py_cmsg = PyObject_CallObject(
reinterpret_cast<PyObject*>(cls), NULL);
if (py_cmsg == NULL) {
return NULL;
}
CMessage* cmsg = reinterpret_cast<CMessage*>(py_cmsg);
ScopedPyObjectPtr py_length(MergeFromString(cmsg, serialized));
if (py_length == NULL) {
Py_DECREF(py_cmsg);
return NULL;
}
return py_cmsg;
}
// Add the number of a field descriptor to the containing message class.
// Equivalent to:
// _cls.<field>_FIELD_NUMBER = <number>
static bool AddFieldNumberToClass(
PyObject* cls, const FieldDescriptor* field_descriptor) {
string constant_name = field_descriptor->name() + "_FIELD_NUMBER";
UpperString(&constant_name);
ScopedPyObjectPtr attr_name(PyString_FromStringAndSize(
constant_name.c_str(), constant_name.size()));
if (attr_name == NULL) {
return false;
}
ScopedPyObjectPtr number(PyInt_FromLong(field_descriptor->number()));
if (number == NULL) {
return false;
}
if (PyObject_SetAttr(cls, attr_name, number) == -1) {
return false;
}
return true;
}
// Finalize the creation of the Message class.
// Called from its metaclass: GeneratedProtocolMessageType.__init__().
static PyObject* AddDescriptors(PyObject* cls, PyObject* descriptor) {
const Descriptor* message_descriptor =
cdescriptor_pool::RegisterMessageClass(
GetDescriptorPool(), cls, descriptor);
if (message_descriptor == NULL) {
return NULL;
}
// If there are extension_ranges, the message is "extendable", and extension
// classes will register themselves in this class.
if (message_descriptor->extension_range_count() > 0) {
ScopedPyObjectPtr by_name(PyDict_New());
if (PyObject_SetAttr(cls, k_extensions_by_name, by_name) < 0) {
return NULL;
}
ScopedPyObjectPtr by_number(PyDict_New());
if (PyObject_SetAttr(cls, k_extensions_by_number, by_number) < 0) {
return NULL;
}
}
// For each field set: cls.<field>_FIELD_NUMBER = <number>
for (int i = 0; i < message_descriptor->field_count(); ++i) {
if (!AddFieldNumberToClass(cls, message_descriptor->field(i))) {
return NULL;
}
}
// For each enum set cls.<enum name> = EnumTypeWrapper(<enum descriptor>).
//
// The enum descriptor we get from
// <messagedescriptor>.enum_types_by_name[name]
// which was built previously.
for (int i = 0; i < message_descriptor->enum_type_count(); ++i) {
const EnumDescriptor* enum_descriptor = message_descriptor->enum_type(i);
ScopedPyObjectPtr enum_type(PyEnumDescriptor_New(enum_descriptor));
if (enum_type == NULL) {
return NULL;
}
// Add wrapped enum type to message class.
ScopedPyObjectPtr wrapped(PyObject_CallFunctionObjArgs(
EnumTypeWrapper_class, enum_type.get(), NULL));
if (wrapped == NULL) {
return NULL;
}
if (PyObject_SetAttrString(
cls, enum_descriptor->name().c_str(), wrapped) == -1) {
return NULL;
}
// For each enum value add cls.<name> = <number>
for (int j = 0; j < enum_descriptor->value_count(); ++j) {
const EnumValueDescriptor* enum_value_descriptor =
enum_descriptor->value(j);
ScopedPyObjectPtr value_number(PyInt_FromLong(
enum_value_descriptor->number()));
if (value_number == NULL) {
return NULL;
}
if (PyObject_SetAttrString(
cls, enum_value_descriptor->name().c_str(), value_number) == -1) {
return NULL;
}
}
}
// For each extension set cls.<extension name> = <extension descriptor>.
//
// Extension descriptors come from
// <message descriptor>.extensions_by_name[name]
// which was defined previously.
for (int i = 0; i < message_descriptor->extension_count(); ++i) {
const google::protobuf::FieldDescriptor* field = message_descriptor->extension(i);
ScopedPyObjectPtr extension_field(PyFieldDescriptor_New(field));
if (extension_field == NULL) {
return NULL;
}
// Add the extension field to the message class.
if (PyObject_SetAttrString(
cls, field->name().c_str(), extension_field) == -1) {
return NULL;
}
// For each extension set cls.<extension name>_FIELD_NUMBER = <number>.
if (!AddFieldNumberToClass(cls, field)) {
return NULL;
}
}
Py_RETURN_NONE;
}
PyObject* DeepCopy(CMessage* self, PyObject* arg) {
PyObject* clone = PyObject_CallObject(
reinterpret_cast<PyObject*>(Py_TYPE(self)), NULL);
if (clone == NULL) {
return NULL;
}
if (!PyObject_TypeCheck(clone, &CMessage_Type)) {
Py_DECREF(clone);
return NULL;
}
if (MergeFrom(reinterpret_cast<CMessage*>(clone),
reinterpret_cast<PyObject*>(self)) == NULL) {
Py_DECREF(clone);
return NULL;
}
return clone;
}
PyObject* ToUnicode(CMessage* self) {
// Lazy import to prevent circular dependencies
ScopedPyObjectPtr text_format(
PyImport_ImportModule("google.protobuf.text_format"));
if (text_format == NULL) {
return NULL;
}
ScopedPyObjectPtr method_name(PyString_FromString("MessageToString"));
if (method_name == NULL) {
return NULL;
}
Py_INCREF(Py_True);
ScopedPyObjectPtr encoded(PyObject_CallMethodObjArgs(text_format, method_name,
self, Py_True, NULL));
Py_DECREF(Py_True);
if (encoded == NULL) {
return NULL;
}
#if PY_MAJOR_VERSION < 3
PyObject* decoded = PyString_AsDecodedObject(encoded, "utf-8", NULL);
#else
PyObject* decoded = PyUnicode_FromEncodedObject(encoded, "utf-8", NULL);
#endif
if (decoded == NULL) {
return NULL;
}
return decoded;
}
PyObject* Reduce(CMessage* self) {
ScopedPyObjectPtr constructor(reinterpret_cast<PyObject*>(Py_TYPE(self)));
constructor.inc();
ScopedPyObjectPtr args(PyTuple_New(0));
if (args == NULL) {
return NULL;
}
ScopedPyObjectPtr state(PyDict_New());
if (state == NULL) {
return NULL;
}
ScopedPyObjectPtr serialized(SerializePartialToString(self));
if (serialized == NULL) {
return NULL;
}
if (PyDict_SetItemString(state, "serialized", serialized) < 0) {
return NULL;
}
return Py_BuildValue("OOO", constructor.get(), args.get(), state.get());
}
PyObject* SetState(CMessage* self, PyObject* state) {
if (!PyDict_Check(state)) {
PyErr_SetString(PyExc_TypeError, "state not a dict");
return NULL;
}
PyObject* serialized = PyDict_GetItemString(state, "serialized");
if (serialized == NULL) {
return NULL;
}
if (ParseFromString(self, serialized) == NULL) {
return NULL;
}
Py_RETURN_NONE;
}
// CMessage static methods:
PyObject* _GetMessageDescriptor(PyObject* unused, PyObject* arg) {
return cdescriptor_pool::FindMessageByName(GetDescriptorPool(), arg);
}
PyObject* _GetFieldDescriptor(PyObject* unused, PyObject* arg) {
return cdescriptor_pool::FindFieldByName(GetDescriptorPool(), arg);
}
PyObject* _GetExtensionDescriptor(PyObject* unused, PyObject* arg) {
return cdescriptor_pool::FindExtensionByName(GetDescriptorPool(), arg);
}
PyObject* _GetEnumDescriptor(PyObject* unused, PyObject* arg) {
return cdescriptor_pool::FindEnumTypeByName(GetDescriptorPool(), arg);
}
PyObject* _GetOneofDescriptor(PyObject* unused, PyObject* arg) {
return cdescriptor_pool::FindOneofByName(GetDescriptorPool(), arg);
}
PyObject* _CheckCalledFromGeneratedFile(PyObject* unused,
PyObject* unused_arg) {
if (!_CalledFromGeneratedFile(1)) {
PyErr_SetString(PyExc_TypeError,
"Descriptors should not be created directly, "
"but only retrieved from their parent.");
return NULL;
}
Py_RETURN_NONE;
}
static PyMemberDef Members[] = {
{"Extensions", T_OBJECT_EX, offsetof(CMessage, extensions), 0,
"Extension dict"},
{NULL}
};
static PyMethodDef Methods[] = {
{ "__deepcopy__", (PyCFunction)DeepCopy, METH_VARARGS,
"Makes a deep copy of the class." },
{ "__reduce__", (PyCFunction)Reduce, METH_NOARGS,
"Outputs picklable representation of the message." },
{ "__setstate__", (PyCFunction)SetState, METH_O,
"Inputs picklable representation of the message." },
{ "__unicode__", (PyCFunction)ToUnicode, METH_NOARGS,
"Outputs a unicode representation of the message." },
{ "AddDescriptors", (PyCFunction)AddDescriptors, METH_O | METH_CLASS,
"Adds field descriptors to the class" },
{ "ByteSize", (PyCFunction)ByteSize, METH_NOARGS,
"Returns the size of the message in bytes." },
{ "Clear", (PyCFunction)Clear, METH_NOARGS,
"Clears the message." },
{ "ClearExtension", (PyCFunction)ClearExtension, METH_O,
"Clears a message field." },
{ "ClearField", (PyCFunction)ClearField, METH_O,
"Clears a message field." },
{ "CopyFrom", (PyCFunction)CopyFrom, METH_O,
"Copies a protocol message into the current message." },
{ "FindInitializationErrors", (PyCFunction)FindInitializationErrors,
METH_NOARGS,
"Finds unset required fields." },
{ "FromString", (PyCFunction)FromString, METH_O | METH_CLASS,
"Creates new method instance from given serialized data." },
{ "HasExtension", (PyCFunction)HasExtension, METH_O,
"Checks if a message field is set." },
{ "HasField", (PyCFunction)HasField, METH_O,
"Checks if a message field is set." },
{ "IsInitialized", (PyCFunction)IsInitialized, METH_VARARGS,
"Checks if all required fields of a protocol message are set." },
{ "ListFields", (PyCFunction)ListFields, METH_NOARGS,
"Lists all set fields of a message." },
{ "MergeFrom", (PyCFunction)MergeFrom, METH_O,
"Merges a protocol message into the current message." },
{ "MergeFromString", (PyCFunction)MergeFromString, METH_O,
"Merges a serialized message into the current message." },
{ "ParseFromString", (PyCFunction)ParseFromString, METH_O,
"Parses a serialized message into the current message." },
{ "RegisterExtension", (PyCFunction)RegisterExtension, METH_O | METH_CLASS,
"Registers an extension with the current message." },
{ "SerializePartialToString", (PyCFunction)SerializePartialToString,
METH_NOARGS,
"Serializes the message to a string, even if it isn't initialized." },
{ "SerializeToString", (PyCFunction)SerializeToString, METH_NOARGS,
"Serializes the message to a string, only for initialized messages." },
{ "SetInParent", (PyCFunction)SetInParent, METH_NOARGS,
"Sets the has bit of the given field in its parent message." },
{ "WhichOneof", (PyCFunction)WhichOneof, METH_O,
"Returns the name of the field set inside a oneof, "
"or None if no field is set." },
// Static Methods.
{ "_BuildFile", (PyCFunction)Python_BuildFile, METH_O | METH_STATIC,
"Registers a new protocol buffer file in the global C++ descriptor pool." },
{ "_GetMessageDescriptor", (PyCFunction)_GetMessageDescriptor,
METH_O | METH_STATIC, "Finds a message descriptor in the message pool." },
{ "_GetFieldDescriptor", (PyCFunction)_GetFieldDescriptor,
METH_O | METH_STATIC, "Finds a field descriptor in the message pool." },
{ "_GetExtensionDescriptor", (PyCFunction)_GetExtensionDescriptor,
METH_O | METH_STATIC,
"Finds a extension descriptor in the message pool." },
{ "_GetEnumDescriptor", (PyCFunction)_GetEnumDescriptor,
METH_O | METH_STATIC,
"Finds an enum descriptor in the message pool." },
{ "_GetOneofDescriptor", (PyCFunction)_GetOneofDescriptor,
METH_O | METH_STATIC,
"Finds an oneof descriptor in the message pool." },
{ "_CheckCalledFromGeneratedFile", (PyCFunction)_CheckCalledFromGeneratedFile,
METH_NOARGS | METH_STATIC,
"Raises TypeError if the caller is not in a _pb2.py file."},
{ NULL, NULL}
};
static bool SetCompositeField(
CMessage* self, PyObject* name, PyObject* value) {
if (self->composite_fields == NULL) {
self->composite_fields = PyDict_New();
if (self->composite_fields == NULL) {
return false;
}
}
return PyDict_SetItem(self->composite_fields, name, value) == 0;
}
PyObject* GetAttr(CMessage* self, PyObject* name) {
PyObject* value = self->composite_fields ?
PyDict_GetItem(self->composite_fields, name) : NULL;
if (value != NULL) {
Py_INCREF(value);
return value;
}
const FieldDescriptor* field_descriptor = GetFieldDescriptor(self, name);
if (field_descriptor == NULL) {
return CMessage_Type.tp_base->tp_getattro(
reinterpret_cast<PyObject*>(self), name);
}
if (field_descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
PyObject* py_container = NULL;
if (field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
PyObject *message_class = cdescriptor_pool::GetMessageClass(
GetDescriptorPool(), field_descriptor->message_type());
if (message_class == NULL) {
return NULL;
}
py_container = repeated_composite_container::NewContainer(
self, field_descriptor, message_class);
} else {
py_container = repeated_scalar_container::NewContainer(
self, field_descriptor);
}
if (py_container == NULL) {
return NULL;
}
if (!SetCompositeField(self, name, py_container)) {
Py_DECREF(py_container);
return NULL;
}
return py_container;
}
if (field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
PyObject* sub_message = InternalGetSubMessage(self, field_descriptor);
if (!SetCompositeField(self, name, sub_message)) {
Py_DECREF(sub_message);
return NULL;
}
return sub_message;
}
return InternalGetScalar(self, field_descriptor);
}
int SetAttr(CMessage* self, PyObject* name, PyObject* value) {
if (self->composite_fields && PyDict_Contains(self->composite_fields, name)) {
PyErr_SetString(PyExc_TypeError, "Can't set composite field");
return -1;
}
const FieldDescriptor* field_descriptor = GetFieldDescriptor(self, name);
if (field_descriptor != NULL) {
AssureWritable(self);
if (field_descriptor->label() == FieldDescriptor::LABEL_REPEATED) {
PyErr_Format(PyExc_AttributeError, "Assignment not allowed to repeated "
"field \"%s\" in protocol message object.",
field_descriptor->name().c_str());
return -1;
} else {
if (field_descriptor->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE) {
PyErr_Format(PyExc_AttributeError, "Assignment not allowed to "
"field \"%s\" in protocol message object.",
field_descriptor->name().c_str());
return -1;
} else {
return InternalSetScalar(self, field_descriptor, value);
}
}
}
PyErr_Format(PyExc_AttributeError, "Assignment not allowed");
return -1;
}
} // namespace cmessage
PyTypeObject CMessage_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
"google.protobuf.internal."
"cpp._message.CMessage", // tp_name
sizeof(CMessage), // tp_basicsize
0, // tp_itemsize
(destructor)cmessage::Dealloc, // tp_dealloc
0, // tp_print
0, // tp_getattr
0, // tp_setattr
0, // tp_compare
0, // tp_repr
0, // tp_as_number
0, // tp_as_sequence
0, // tp_as_mapping
0, // tp_hash
0, // tp_call
(reprfunc)cmessage::ToStr, // tp_str
(getattrofunc)cmessage::GetAttr, // tp_getattro
(setattrofunc)cmessage::SetAttr, // tp_setattro
0, // tp_as_buffer
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, // tp_flags
"A ProtocolMessage", // tp_doc
0, // tp_traverse
0, // tp_clear
(richcmpfunc)cmessage::RichCompare, // tp_richcompare
0, // tp_weaklistoffset
0, // tp_iter
0, // tp_iternext
cmessage::Methods, // tp_methods
cmessage::Members, // tp_members
0, // tp_getset
0, // tp_base
0, // tp_dict
0, // tp_descr_get
0, // tp_descr_set
0, // tp_dictoffset
(initproc)cmessage::Init, // tp_init
0, // tp_alloc
cmessage::New, // tp_new
};
// --- Exposing the C proto living inside Python proto to C code:
const Message* (*GetCProtoInsidePyProtoPtr)(PyObject* msg);
Message* (*MutableCProtoInsidePyProtoPtr)(PyObject* msg);
static const Message* GetCProtoInsidePyProtoImpl(PyObject* msg) {
if (!PyObject_TypeCheck(msg, &CMessage_Type)) {
return NULL;
}
CMessage* cmsg = reinterpret_cast<CMessage*>(msg);
return cmsg->message;
}
static Message* MutableCProtoInsidePyProtoImpl(PyObject* msg) {
if (!PyObject_TypeCheck(msg, &CMessage_Type)) {
return NULL;
}
CMessage* cmsg = reinterpret_cast<CMessage*>(msg);
if ((cmsg->composite_fields && PyDict_Size(cmsg->composite_fields) != 0) ||
(cmsg->extensions != NULL &&
PyDict_Size(cmsg->extensions->values) != 0)) {
// There is currently no way of accurately syncing arbitrary changes to
// the underlying C++ message back to the CMessage (e.g. removed repeated
// composite containers). We only allow direct mutation of the underlying
// C++ message if there is no child data in the CMessage.
return NULL;
}
cmessage::AssureWritable(cmsg);
return cmsg->message;
}
static const char module_docstring[] =
"python-proto2 is a module that can be used to enhance proto2 Python API\n"
"performance.\n"
"\n"
"It provides access to the protocol buffers C++ reflection API that\n"
"implements the basic protocol buffer functions.";
void InitGlobals() {
// TODO(gps): Check all return values in this function for NULL and propagate
// the error (MemoryError) on up to result in an import failure. These should
// also be freed and reset to NULL during finalization.
kPythonZero = PyInt_FromLong(0);
kint32min_py = PyInt_FromLong(kint32min);
kint32max_py = PyInt_FromLong(kint32max);
kuint32max_py = PyLong_FromLongLong(kuint32max);
kint64min_py = PyLong_FromLongLong(kint64min);
kint64max_py = PyLong_FromLongLong(kint64max);
kuint64max_py = PyLong_FromUnsignedLongLong(kuint64max);
kDESCRIPTOR = PyString_FromString("DESCRIPTOR");
k_cdescriptor = PyString_FromString("_cdescriptor");
kfull_name = PyString_FromString("full_name");
k_extensions_by_name = PyString_FromString("_extensions_by_name");
k_extensions_by_number = PyString_FromString("_extensions_by_number");
message_factory = new DynamicMessageFactory(GetDescriptorPool()->pool);
message_factory->SetDelegateToGeneratedFactory(true);
}
bool InitProto2MessageModule(PyObject *m) {
// Initialize types and globals in descriptor.cc
if (!InitDescriptor()) {
return false;
}
// Initialize types and globals in descriptor_pool.cc
if (!InitDescriptorPool()) {
return false;
}
// Initialize constants defined in this file.
InitGlobals();
CMessage_Type.tp_hash = PyObject_HashNotImplemented;
if (PyType_Ready(&CMessage_Type) < 0) {
return false;
}
// DESCRIPTOR is set on each protocol buffer message class elsewhere, but set
// it here as well to document that subclasses need to set it.
PyDict_SetItem(CMessage_Type.tp_dict, kDESCRIPTOR, Py_None);
// Subclasses with message extensions will override _extensions_by_name and
// _extensions_by_number with fresh mutable dictionaries in AddDescriptors.
// All other classes can share this same immutable mapping.
ScopedPyObjectPtr empty_dict(PyDict_New());
if (empty_dict == NULL) {
return false;
}
ScopedPyObjectPtr immutable_dict(PyDictProxy_New(empty_dict));
if (immutable_dict == NULL) {
return false;
}
if (PyDict_SetItem(CMessage_Type.tp_dict,
k_extensions_by_name, immutable_dict) < 0) {
return false;
}
if (PyDict_SetItem(CMessage_Type.tp_dict,
k_extensions_by_number, immutable_dict) < 0) {
return false;
}
PyModule_AddObject(m, "Message", reinterpret_cast<PyObject*>(&CMessage_Type));
RepeatedScalarContainer_Type.tp_hash =
PyObject_HashNotImplemented;
if (PyType_Ready(&RepeatedScalarContainer_Type) < 0) {
return false;
}
PyModule_AddObject(m, "RepeatedScalarContainer",
reinterpret_cast<PyObject*>(
&RepeatedScalarContainer_Type));
RepeatedCompositeContainer_Type.tp_hash = PyObject_HashNotImplemented;
if (PyType_Ready(&RepeatedCompositeContainer_Type) < 0) {
return false;
}
PyModule_AddObject(
m, "RepeatedCompositeContainer",
reinterpret_cast<PyObject*>(
&RepeatedCompositeContainer_Type));
ExtensionDict_Type.tp_hash = PyObject_HashNotImplemented;
if (PyType_Ready(&ExtensionDict_Type) < 0) {
return false;
}
PyModule_AddObject(
m, "ExtensionDict",
reinterpret_cast<PyObject*>(&ExtensionDict_Type));
// This implementation provides full Descriptor types, we advertise it so that
// descriptor.py can use them in replacement of the Python classes.
PyModule_AddIntConstant(m, "_USE_C_DESCRIPTORS", 1);
PyModule_AddObject(m, "Descriptor", reinterpret_cast<PyObject*>(
&PyMessageDescriptor_Type));
PyModule_AddObject(m, "FieldDescriptor", reinterpret_cast<PyObject*>(
&PyFieldDescriptor_Type));
PyModule_AddObject(m, "EnumDescriptor", reinterpret_cast<PyObject*>(
&PyEnumDescriptor_Type));
PyModule_AddObject(m, "EnumValueDescriptor", reinterpret_cast<PyObject*>(
&PyEnumValueDescriptor_Type));
PyModule_AddObject(m, "FileDescriptor", reinterpret_cast<PyObject*>(
&PyFileDescriptor_Type));
PyModule_AddObject(m, "OneofDescriptor", reinterpret_cast<PyObject*>(
&PyOneofDescriptor_Type));
PyObject* enum_type_wrapper = PyImport_ImportModule(
"google.protobuf.internal.enum_type_wrapper");
if (enum_type_wrapper == NULL) {
return false;
}
EnumTypeWrapper_class =
PyObject_GetAttrString(enum_type_wrapper, "EnumTypeWrapper");
Py_DECREF(enum_type_wrapper);
PyObject* message_module = PyImport_ImportModule(
"google.protobuf.message");
if (message_module == NULL) {
return false;
}
EncodeError_class = PyObject_GetAttrString(message_module, "EncodeError");
DecodeError_class = PyObject_GetAttrString(message_module, "DecodeError");
Py_DECREF(message_module);
PyObject* pickle_module = PyImport_ImportModule("pickle");
if (pickle_module == NULL) {
return false;
}
PickleError_class = PyObject_GetAttrString(pickle_module, "PickleError");
Py_DECREF(pickle_module);
// Override {Get,Mutable}CProtoInsidePyProto.
GetCProtoInsidePyProtoPtr = GetCProtoInsidePyProtoImpl;
MutableCProtoInsidePyProtoPtr = MutableCProtoInsidePyProtoImpl;
return true;
}
} // namespace python
} // namespace protobuf
#if PY_MAJOR_VERSION >= 3
static struct PyModuleDef _module = {
PyModuleDef_HEAD_INIT,
"_message",
google::protobuf::python::module_docstring,
-1,
NULL,
NULL,
NULL,
NULL,
NULL
};
#define INITFUNC PyInit__message
#define INITFUNC_ERRORVAL NULL
#else // Python 2
#define INITFUNC init_message
#define INITFUNC_ERRORVAL
#endif
extern "C" {
PyMODINIT_FUNC INITFUNC(void) {
PyObject* m;
#if PY_MAJOR_VERSION >= 3
m = PyModule_Create(&_module);
#else
m = Py_InitModule3("_message", NULL, google::protobuf::python::module_docstring);
#endif
if (m == NULL) {
return INITFUNC_ERRORVAL;
}
if (!google::protobuf::python::InitProto2MessageModule(m)) {
Py_DECREF(m);
return INITFUNC_ERRORVAL;
}
#if PY_MAJOR_VERSION >= 3
return m;
#endif
}
}
} // namespace google
