1# Protocol Buffers - Google's data interchange format
2# Copyright 2008 Google Inc.  All rights reserved.
3# https://developers.google.com/protocol-buffers/
4#
5# Redistribution and use in source and binary forms, with or without
6# modification, are permitted provided that the following conditions are
7# met:
8#
9#     * Redistributions of source code must retain the above copyright
10# notice, this list of conditions and the following disclaimer.
11#     * Redistributions in binary form must reproduce the above
12# copyright notice, this list of conditions and the following disclaimer
13# in the documentation and/or other materials provided with the
14# distribution.
15#     * Neither the name of Google Inc. nor the names of its
16# contributors may be used to endorse or promote products derived from
17# this software without specific prior written permission.
18#
19# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
31"""Provides a factory class for generating dynamic messages.
32
33The easiest way to use this class is if you have access to the FileDescriptor
34protos containing the messages you want to create you can just do the following:
35
36message_classes = message_factory.GetMessages(iterable_of_file_descriptors)
37my_proto_instance = message_classes['some.proto.package.MessageName']()
38"""
39
40__author__ = 'matthewtoia@google.com (Matt Toia)'
41
42from google.protobuf.internal import api_implementation
43from google.protobuf import descriptor_pool
44from google.protobuf import message
45
46if api_implementation.Type() == 'cpp':
47  from google.protobuf.pyext import cpp_message as message_impl
48else:
49  from google.protobuf.internal import python_message as message_impl
50
51
52# The type of all Message classes.
53_GENERATED_PROTOCOL_MESSAGE_TYPE = message_impl.GeneratedProtocolMessageType
54
55
56class MessageFactory(object):
57  """Factory for creating Proto2 messages from descriptors in a pool."""
58
59  def __init__(self, pool=None):
60    """Initializes a new factory."""
61    self.pool = pool or descriptor_pool.DescriptorPool()
62
63    # local cache of all classes built from protobuf descriptors
64    self._classes = {}
65
66  def GetPrototype(self, descriptor):
67    """Obtains a proto2 message class based on the passed in descriptor.
68
69    Passing a descriptor with a fully qualified name matching a previous
70    invocation will cause the same class to be returned.
71
72    Args:
73      descriptor: The descriptor to build from.
74
75    Returns:
76      A class describing the passed in descriptor.
77    """
78    if descriptor not in self._classes:
79      result_class = self.CreatePrototype(descriptor)
80      # The assignment to _classes is redundant for the base implementation, but
81      # might avoid confusion in cases where CreatePrototype gets overridden and
82      # does not call the base implementation.
83      self._classes[descriptor] = result_class
84      return result_class
85    return self._classes[descriptor]
86
87  def CreatePrototype(self, descriptor):
88    """Builds a proto2 message class based on the passed in descriptor.
89
90    Don't call this function directly, it always creates a new class. Call
91    GetPrototype() instead. This method is meant to be overridden in subblasses
92    to perform additional operations on the newly constructed class.
93
94    Args:
95      descriptor: The descriptor to build from.
96
97    Returns:
98      A class describing the passed in descriptor.
99    """
100    descriptor_name = descriptor.name
101    if str is bytes:  # PY2
102      descriptor_name = descriptor.name.encode('ascii', 'ignore')
103    result_class = _GENERATED_PROTOCOL_MESSAGE_TYPE(
104        descriptor_name,
105        (message.Message,),
106        {
107            'DESCRIPTOR': descriptor,
108            # If module not set, it wrongly points to message_factory module.
109            '__module__': None,
110        })
111    result_class._FACTORY = self  # pylint: disable=protected-access
112    # Assign in _classes before doing recursive calls to avoid infinite
113    # recursion.
114    self._classes[descriptor] = result_class
115    for field in descriptor.fields:
116      if field.message_type:
117        self.GetPrototype(field.message_type)
118    for extension in result_class.DESCRIPTOR.extensions:
119      if extension.containing_type not in self._classes:
120        self.GetPrototype(extension.containing_type)
121      extended_class = self._classes[extension.containing_type]
122      extended_class.RegisterExtension(extension)
123    return result_class
124
125  def GetMessages(self, files):
126    """Gets all the messages from a specified file.
127
128    This will find and resolve dependencies, failing if the descriptor
129    pool cannot satisfy them.
130
131    Args:
132      files: The file names to extract messages from.
133
134    Returns:
135      A dictionary mapping proto names to the message classes. This will include
136      any dependent messages as well as any messages defined in the same file as
137      a specified message.
138    """
139    result = {}
140    for file_name in files:
141      file_desc = self.pool.FindFileByName(file_name)
142      for desc in file_desc.message_types_by_name.values():
143        result[desc.full_name] = self.GetPrototype(desc)
144
145      # While the extension FieldDescriptors are created by the descriptor pool,
146      # the python classes created in the factory need them to be registered
147      # explicitly, which is done below.
148      #
149      # The call to RegisterExtension will specifically check if the
150      # extension was already registered on the object and either
151      # ignore the registration if the original was the same, or raise
152      # an error if they were different.
153
154      for extension in file_desc.extensions_by_name.values():
155        if extension.containing_type not in self._classes:
156          self.GetPrototype(extension.containing_type)
157        extended_class = self._classes[extension.containing_type]
158        extended_class.RegisterExtension(extension)
159    return result
160
161
162_FACTORY = MessageFactory()
163
164
165def GetMessages(file_protos):
166  """Builds a dictionary of all the messages available in a set of files.
167
168  Args:
169    file_protos: Iterable of FileDescriptorProto to build messages out of.
170
171  Returns:
172    A dictionary mapping proto names to the message classes. This will include
173    any dependent messages as well as any messages defined in the same file as
174    a specified message.
175  """
176  # The cpp implementation of the protocol buffer library requires to add the
177  # message in topological order of the dependency graph.
178  file_by_name = {file_proto.name: file_proto for file_proto in file_protos}
179  def _AddFile(file_proto):
180    for dependency in file_proto.dependency:
181      if dependency in file_by_name:
182        # Remove from elements to be visited, in order to cut cycles.
183        _AddFile(file_by_name.pop(dependency))
184    _FACTORY.pool.Add(file_proto)
185  while file_by_name:
186    _AddFile(file_by_name.popitem()[1])
187  return _FACTORY.GetMessages([file_proto.name for file_proto in file_protos])
188