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 // Author: kenton@google.com (Kenton Varda) 32 // Based on original Protocol Buffers design by 33 // Sanjay Ghemawat, Jeff Dean, and others. 34 // 35 // Defines an implementation of Message which can emulate types which are not 36 // known at compile-time. 37 38 #ifndef GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__ 39 #define GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__ 40 41 #include <memory> 42 #ifndef _SHARED_PTR_H 43 #include <google/protobuf/stubs/shared_ptr.h> 44 #endif 45 46 #include <google/protobuf/message.h> 47 #include <google/protobuf/stubs/common.h> 48 #include <google/protobuf/stubs/mutex.h> 49 50 namespace google { 51 namespace protobuf { 52 53 // Defined in other files. 54 class Descriptor; // descriptor.h 55 class DescriptorPool; // descriptor.h 56 57 // Constructs implementations of Message which can emulate types which are not 58 // known at compile-time. 59 // 60 // Sometimes you want to be able to manipulate protocol types that you don't 61 // know about at compile time. It would be nice to be able to construct 62 // a Message object which implements the message type given by any arbitrary 63 // Descriptor. DynamicMessage provides this. 64 // 65 // As it turns out, a DynamicMessage needs to construct extra 66 // information about its type in order to operate. Most of this information 67 // can be shared between all DynamicMessages of the same type. But, caching 68 // this information in some sort of global map would be a bad idea, since 69 // the cached information for a particular descriptor could outlive the 70 // descriptor itself. To avoid this problem, DynamicMessageFactory 71 // encapsulates this "cache". All DynamicMessages of the same type created 72 // from the same factory will share the same support data. Any Descriptors 73 // used with a particular factory must outlive the factory. 74 class LIBPROTOBUF_EXPORT DynamicMessageFactory : public MessageFactory { 75 public: 76 // Construct a DynamicMessageFactory that will search for extensions in 77 // the DescriptorPool in which the extendee is defined. 78 DynamicMessageFactory(); 79 80 // Construct a DynamicMessageFactory that will search for extensions in 81 // the given DescriptorPool. 82 // 83 // DEPRECATED: Use CodedInputStream::SetExtensionRegistry() to tell the 84 // parser to look for extensions in an alternate pool. However, note that 85 // this is almost never what you want to do. Almost all users should use 86 // the zero-arg constructor. 87 DynamicMessageFactory(const DescriptorPool* pool); 88 89 ~DynamicMessageFactory(); 90 91 // Call this to tell the DynamicMessageFactory that if it is given a 92 // Descriptor d for which: 93 // d->file()->pool() == DescriptorPool::generated_pool(), 94 // then it should delegate to MessageFactory::generated_factory() instead 95 // of constructing a dynamic implementation of the message. In theory there 96 // is no down side to doing this, so it may become the default in the future. SetDelegateToGeneratedFactory(bool enable)97 void SetDelegateToGeneratedFactory(bool enable) { 98 delegate_to_generated_factory_ = enable; 99 } 100 101 // implements MessageFactory --------------------------------------- 102 103 // Given a Descriptor, constructs the default (prototype) Message of that 104 // type. You can then call that message's New() method to construct a 105 // mutable message of that type. 106 // 107 // Calling this method twice with the same Descriptor returns the same 108 // object. The returned object remains property of the factory and will 109 // be destroyed when the factory is destroyed. Also, any objects created 110 // by calling the prototype's New() method share some data with the 111 // prototype, so these must be destroyed before the DynamicMessageFactory 112 // is destroyed. 113 // 114 // The given descriptor must outlive the returned message, and hence must 115 // outlive the DynamicMessageFactory. 116 // 117 // The method is thread-safe. 118 const Message* GetPrototype(const Descriptor* type); 119 120 private: 121 const DescriptorPool* pool_; 122 bool delegate_to_generated_factory_; 123 124 // This struct just contains a hash_map. We can't #include <google/protobuf/stubs/hash.h> from 125 // this header due to hacks needed for hash_map portability in the open source 126 // release. Namely, stubs/hash.h, which defines hash_map portably, is not a 127 // public header (for good reason), but dynamic_message.h is, and public 128 // headers may only #include other public headers. 129 struct PrototypeMap; 130 google::protobuf::scoped_ptr<PrototypeMap> prototypes_; 131 mutable Mutex prototypes_mutex_; 132 133 friend class DynamicMessage; 134 const Message* GetPrototypeNoLock(const Descriptor* type); 135 136 // Construct default oneof instance for reflection usage if oneof 137 // is defined. 138 static void ConstructDefaultOneofInstance(const Descriptor* type, 139 const int offsets[], 140 void* default_oneof_instance); 141 // Delete default oneof instance. Called by ~DynamicMessageFactory. 142 static void DeleteDefaultOneofInstance(const Descriptor* type, 143 const int offsets[], 144 void* default_oneof_instance); 145 146 GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMessageFactory); 147 }; 148 149 } // namespace protobuf 150 151 } // namespace google 152 #endif // GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__ 153