text: // 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.
  
  #include <Python.h>
  
  #include "dynamic_message.h"
  #include "pyext/descriptor.h"
  #include "pyext/message.h"
  #include "pyext/message_factory.h"
  #include "pyext/scoped_pyobject_ptr.h"
  
  #if PY_MAJOR_VERSION >= 3
    #if PY_VERSION_HEX < 0x03030000
      #error "Python 3.0 - 3.2 are not supported."
    #endif
    #define PyString_AsStringAndSize(ob, charpp, sizep) \
      (PyUnicode_Check(ob)? \
         ((*(charpp) = PyUnicode_AsUTF8AndSize(ob, (sizep))) == NULL? -1: 0): \
         PyBytes_AsStringAndSize(ob, (charpp), (sizep)))
  #endif
  
  namespace google {
  namespace protobuf {
  namespace python {
  
  namespace message_factory {
  
  PyMessageFactory* NewMessageFactory(PyTypeObject* type, PyDescriptorPool* pool) {
    PyMessageFactory* factory = reinterpret_cast<PyMessageFactory*>(
        PyType_GenericAlloc(type, 0));
    if (factory == NULL) {
      return NULL;
    }
  
    DynamicMessageFactory* message_factory = new DynamicMessageFactory();
    // This option might be the default some day.
    message_factory->SetDelegateToGeneratedFactory(true);
    factory->message_factory = message_factory;
  
    factory->pool = pool;
    // TODO(amauryfa): When the MessageFactory is not created from the
    // DescriptorPool this reference should be owned, not borrowed.
    // Py_INCREF(pool);
  
    factory->classes_by_descriptor = new PyMessageFactory::ClassesByMessageMap();
  
    return factory;
  }
  
  PyObject* New(PyTypeObject* type, PyObject* args, PyObject* kwargs) {
    static char* kwlist[] = {"pool", 0};
    PyObject* pool = NULL;
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O", kwlist, &pool)) {
      return NULL;
    }
    ScopedPyObjectPtr owned_pool;
    if (pool == NULL || pool == Py_None) {
      owned_pool.reset(PyObject_CallFunction(
          reinterpret_cast<PyObject*>(&PyDescriptorPool_Type), NULL));
      if (owned_pool == NULL) {
        return NULL;
      }
      pool = owned_pool.get();
    } else {
      if (!PyObject_TypeCheck(pool, &PyDescriptorPool_Type)) {
        PyErr_Format(PyExc_TypeError, "Expected a DescriptorPool, got %s",
                     pool->ob_type->tp_name);
        return NULL;
      }
    }
  
    return reinterpret_cast<PyObject*>(
        NewMessageFactory(type, reinterpret_cast<PyDescriptorPool*>(pool)));
  }
  
  static void Dealloc(PyObject* object) {
    PyMessageFactory* self = reinterpret_cast<PyMessageFactory*>(object);
    // TODO(amauryfa): When the MessageFactory is not created from the
    // DescriptorPool this reference should be owned, not borrowed.
    // Py_CLEAR(self->pool);
    typedef PyMessageFactory::ClassesByMessageMap::iterator iterator;
    for (iterator it = self->classes_by_descriptor->begin();
         it != self->classes_by_descriptor->end(); ++it) {
      Py_DECREF(it->second);
    }
    delete self->classes_by_descriptor;
    delete self->message_factory;
    Py_TYPE(self)->tp_free(reinterpret_cast<PyObject*>(self));
  }
  
  // Add a message class to our database.
  int RegisterMessageClass(PyMessageFactory* self,
                           const Descriptor* message_descriptor,
                           CMessageClass* message_class) {
    Py_INCREF(message_class);
    typedef PyMessageFactory::ClassesByMessageMap::iterator iterator;
    std::pair<iterator, bool> ret = self->classes_by_descriptor->insert(
        std::make_pair(message_descriptor, message_class));
    if (!ret.second) {
      // Update case: DECREF the previous value.
      Py_DECREF(ret.first->second);
      ret.first->second = message_class;
    }
    return 0;
  }
  
  CMessageClass* GetOrCreateMessageClass(PyMessageFactory* self,
                                         const Descriptor* descriptor) {
    // This is the same implementation as MessageFactory.GetPrototype().
  
    // Do not create a MessageClass that already exists.
    hash_map<const Descriptor*, CMessageClass*>::iterator it =
        self->classes_by_descriptor->find(descriptor);
    if (it != self->classes_by_descriptor->end()) {
      Py_INCREF(it->second);
      return it->second;
    }
    ScopedPyObjectPtr py_descriptor(
        PyMessageDescriptor_FromDescriptor(descriptor));
    if (py_descriptor == NULL) {
      return NULL;
    }
    // Create a new message class.
    ScopedPyObjectPtr args(Py_BuildValue(
        "s(){sOsOsO}", descriptor->name().c_str(),
        "DESCRIPTOR", py_descriptor.get(),
        "__module__", Py_None,
        "message_factory", self));
    if (args == NULL) {
      return NULL;
    }
    ScopedPyObjectPtr message_class(PyObject_CallObject(
        reinterpret_cast<PyObject*>(&CMessageClass_Type), args.get()));
    if (message_class == NULL) {
      return NULL;
    }
    // Create messages class for the messages used by the fields, and registers
    // all extensions for these messages during the recursion.
    for (int field_idx = 0; field_idx < descriptor->field_count(); field_idx++) {
      const Descriptor* sub_descriptor =
          descriptor->field(field_idx)->message_type();
      // It is NULL if the field type is not a message.
      if (sub_descriptor != NULL) {
        CMessageClass* result = GetOrCreateMessageClass(self, sub_descriptor);
        if (result == NULL) {
          return NULL;
        }
        Py_DECREF(result);
      }
    }
  
    // Register extensions defined in this message.
    for (int ext_idx = 0 ; ext_idx < descriptor->extension_count() ; ext_idx++) {
      const FieldDescriptor* extension = descriptor->extension(ext_idx);
      ScopedPyObjectPtr py_extended_class(
          GetOrCreateMessageClass(self, extension->containing_type())
              ->AsPyObject());
      if (py_extended_class == NULL) {
        return NULL;
      }
      ScopedPyObjectPtr py_extension(PyFieldDescriptor_FromDescriptor(extension));
      if (py_extension == NULL) {
        return NULL;
      }
      ScopedPyObjectPtr result(cmessage::RegisterExtension(
          py_extended_class.get(), py_extension.get()));
      if (result == NULL) {
        return NULL;
      }
    }
    return reinterpret_cast<CMessageClass*>(message_class.release());
  }
  
  // Retrieve the message class added to our database.
  CMessageClass* GetMessageClass(PyMessageFactory* self,
                                 const Descriptor* message_descriptor) {
    typedef PyMessageFactory::ClassesByMessageMap::iterator iterator;
    iterator ret = self->classes_by_descriptor->find(message_descriptor);
    if (ret == self->classes_by_descriptor->end()) {
      PyErr_Format(PyExc_TypeError, "No message class registered for '%s'",
                   message_descriptor->full_name().c_str());
      return NULL;
    } else {
      return ret->second;
    }
  }
  
  static PyMethodDef Methods[] = {
      {NULL}};
  
  static PyObject* GetPool(PyMessageFactory* self, void* closure) {
    Py_INCREF(self->pool);
    return reinterpret_cast<PyObject*>(self->pool);
  }
  
  static PyGetSetDef Getters[] = {
      {"pool", (getter)GetPool, NULL, "DescriptorPool"},
      {NULL}
  };
  
  }  // namespace message_factory
  
  PyTypeObject PyMessageFactory_Type = {
      PyVarObject_HEAD_INIT(&PyType_Type, 0) FULL_MODULE_NAME
      ".MessageFactory",                        // tp_name
      sizeof(PyMessageFactory),                 // tp_basicsize
      0,                                        // tp_itemsize
      (destructor)message_factory::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
      0,                                        // tp_str
      0,                                        // tp_getattro
      0,                                        // tp_setattro
      0,                                        // tp_as_buffer
      Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,  // tp_flags
      "A static Message Factory",               // tp_doc
      0,                                        // tp_traverse
      0,                                        // tp_clear
      0,                                        // tp_richcompare
      0,                                        // tp_weaklistoffset
      0,                                        // tp_iter
      0,                                        // tp_iternext
      message_factory::Methods,                 // tp_methods
      0,                                        // tp_members
      message_factory::Getters,                 // tp_getset
      0,                                        // tp_base
      0,                                        // tp_dict
      0,                                        // tp_descr_get
      0,                                        // tp_descr_set
      0,                                        // tp_dictoffset
      0,                                        // tp_init
      0,                                        // tp_alloc
      message_factory::New,                     // tp_new
      PyObject_Del,                             // tp_free
  };
  
  bool InitMessageFactory() {
    if (PyType_Ready(&PyMessageFactory_Type) < 0) {
      return false;
    }
  
    return true;
  }
  
  }  // namespace python
  }  // namespace protobuf
  }  // namespace google
  