/thirdparty/breakpad/third_party/protobuf/protobuf/python/google/protobuf/reflection.py

http://github.com/tomahawk-player/tomahawk · Python · 142 lines · 81 code · 13 blank · 48 comment · 3 complexity · d579482947fe4fe77e30668056366617 MD5 · raw file

  1. # Protocol Buffers - Google's data interchange format
  2. # Copyright 2008 Google Inc. All rights reserved.
  3. # http://code.google.com/p/protobuf/
  4. #
  5. # Redistribution and use in source and binary forms, with or without
  6. # modification, are permitted provided that the following conditions are
  7. # met:
  8. #
  9. # * Redistributions of source code must retain the above copyright
  10. # notice, this list of conditions and the following disclaimer.
  11. # * Redistributions in binary form must reproduce the above
  12. # copyright notice, this list of conditions and the following disclaimer
  13. # in the documentation and/or other materials provided with the
  14. # distribution.
  15. # * Neither the name of Google Inc. nor the names of its
  16. # contributors may be used to endorse or promote products derived from
  17. # this software without specific prior written permission.
  18. #
  19. # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20. # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21. # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22. # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23. # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24. # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25. # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26. # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27. # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28. # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29. # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30. # This code is meant to work on Python 2.4 and above only.
  31. """Contains a metaclass and helper functions used to create
  32. protocol message classes from Descriptor objects at runtime.
  33. Recall that a metaclass is the "type" of a class.
  34. (A class is to a metaclass what an instance is to a class.)
  35. In this case, we use the GeneratedProtocolMessageType metaclass
  36. to inject all the useful functionality into the classes
  37. output by the protocol compiler at compile-time.
  38. The upshot of all this is that the real implementation
  39. details for ALL pure-Python protocol buffers are *here in
  40. this file*.
  41. """
  42. __author__ = 'robinson@google.com (Will Robinson)'
  43. from google.protobuf.internal import api_implementation
  44. from google.protobuf import descriptor as descriptor_mod
  45. _FieldDescriptor = descriptor_mod.FieldDescriptor
  46. if api_implementation.Type() == 'cpp':
  47. from google.protobuf.internal import cpp_message
  48. _NewMessage = cpp_message.NewMessage
  49. _InitMessage = cpp_message.InitMessage
  50. else:
  51. from google.protobuf.internal import python_message
  52. _NewMessage = python_message.NewMessage
  53. _InitMessage = python_message.InitMessage
  54. class GeneratedProtocolMessageType(type):
  55. """Metaclass for protocol message classes created at runtime from Descriptors.
  56. We add implementations for all methods described in the Message class. We
  57. also create properties to allow getting/setting all fields in the protocol
  58. message. Finally, we create slots to prevent users from accidentally
  59. "setting" nonexistent fields in the protocol message, which then wouldn't get
  60. serialized / deserialized properly.
  61. The protocol compiler currently uses this metaclass to create protocol
  62. message classes at runtime. Clients can also manually create their own
  63. classes at runtime, as in this example:
  64. mydescriptor = Descriptor(.....)
  65. class MyProtoClass(Message):
  66. __metaclass__ = GeneratedProtocolMessageType
  67. DESCRIPTOR = mydescriptor
  68. myproto_instance = MyProtoClass()
  69. myproto.foo_field = 23
  70. ...
  71. """
  72. # Must be consistent with the protocol-compiler code in
  73. # proto2/compiler/internal/generator.*.
  74. _DESCRIPTOR_KEY = 'DESCRIPTOR'
  75. def __new__(cls, name, bases, dictionary):
  76. """Custom allocation for runtime-generated class types.
  77. We override __new__ because this is apparently the only place
  78. where we can meaningfully set __slots__ on the class we're creating(?).
  79. (The interplay between metaclasses and slots is not very well-documented).
  80. Args:
  81. name: Name of the class (ignored, but required by the
  82. metaclass protocol).
  83. bases: Base classes of the class we're constructing.
  84. (Should be message.Message). We ignore this field, but
  85. it's required by the metaclass protocol
  86. dictionary: The class dictionary of the class we're
  87. constructing. dictionary[_DESCRIPTOR_KEY] must contain
  88. a Descriptor object describing this protocol message
  89. type.
  90. Returns:
  91. Newly-allocated class.
  92. """
  93. descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY]
  94. _NewMessage(descriptor, dictionary)
  95. superclass = super(GeneratedProtocolMessageType, cls)
  96. new_class = superclass.__new__(cls, name, bases, dictionary)
  97. setattr(descriptor, '_concrete_class', new_class)
  98. return new_class
  99. def __init__(cls, name, bases, dictionary):
  100. """Here we perform the majority of our work on the class.
  101. We add enum getters, an __init__ method, implementations
  102. of all Message methods, and properties for all fields
  103. in the protocol type.
  104. Args:
  105. name: Name of the class (ignored, but required by the
  106. metaclass protocol).
  107. bases: Base classes of the class we're constructing.
  108. (Should be message.Message). We ignore this field, but
  109. it's required by the metaclass protocol
  110. dictionary: The class dictionary of the class we're
  111. constructing. dictionary[_DESCRIPTOR_KEY] must contain
  112. a Descriptor object describing this protocol message
  113. type.
  114. """
  115. descriptor = dictionary[GeneratedProtocolMessageType._DESCRIPTOR_KEY]
  116. _InitMessage(descriptor, cls)
  117. superclass = super(GeneratedProtocolMessageType, cls)
  118. superclass.__init__(name, bases, dictionary)