src/google/protobuf/message.cc

   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 #include <iostream>
  36 #include <stack>
  37 #include <google/protobuf/stubs/hash.h>
  38
  39 #include <google/protobuf/message.h>
  40
  41 #include <google/protobuf/stubs/common.h>
  42 #include <google/protobuf/stubs/once.h>
  43 #include <google/protobuf/io/coded_stream.h>
  44 #include <google/protobuf/io/zero_copy_stream_impl.h>
  45 #include <google/protobuf/descriptor.pb.h>
  46 #include <google/protobuf/descriptor.h>
  47 #include <google/protobuf/generated_message_util.h>
  48 #include <google/protobuf/reflection_ops.h>
  49 #include <google/protobuf/wire_format.h>
  50 #include <google/protobuf/stubs/strutil.h>
  51 #include <google/protobuf/stubs/map_util.h>
  52 #include <google/protobuf/stubs/stl_util.h>
  53
  54 namespace google {
  55 namespace protobuf {
  56
  57 using internal::WireFormat;
  58 using internal::ReflectionOps;
  59
  60 Message::~Message() {}
  61
  62 void Message::MergeFrom(const Message& from) {
  63   const Descriptor* descriptor = GetDescriptor();
  64   GOOGLE_CHECK_EQ(from.GetDescriptor(), descriptor)
  65     << ": Tried to merge from a message with a different type.  "
  66        "to: " << descriptor->full_name() << ", "
  67        "from:" << from.GetDescriptor()->full_name();
  68   ReflectionOps::Merge(from, this);
  69 }
  70
  71 void Message::CheckTypeAndMergeFrom(const MessageLite& other) {
  72   MergeFrom(*down_cast<const Message*>(&other));
  73 }
  74
  75 void Message::CopyFrom(const Message& from) {
  76   const Descriptor* descriptor = GetDescriptor();
  77   GOOGLE_CHECK_EQ(from.GetDescriptor(), descriptor)
  78     << ": Tried to copy from a message with a different type. "
  79        "to: " << descriptor->full_name() << ", "
  80        "from:" << from.GetDescriptor()->full_name();
  81   ReflectionOps::Copy(from, this);
  82 }
  83
  84 string Message::GetTypeName() const {
  85   return GetDescriptor()->full_name();
  86 }
  87
  88 void Message::Clear() {
  89   ReflectionOps::Clear(this);
  90 }
  91
  92 bool Message::IsInitialized() const {
  93   return ReflectionOps::IsInitialized(*this);
  94 }
  95
  96 void Message::FindInitializationErrors(vector<string>* errors) const {
  97   return ReflectionOps::FindInitializationErrors(*this, "", errors);
  98 }
  99
 100 string Message::InitializationErrorString() const {
 101   vector<string> errors;
 102   FindInitializationErrors(&errors);
 103   return Join(errors, ", ");
 104 }
 105
 106 void Message::CheckInitialized() const {
 107   GOOGLE_CHECK(IsInitialized())
 108     << "Message of type \"" << GetDescriptor()->full_name()
 109     << "\" is missing required fields: " << InitializationErrorString();
 110 }
 111
 112 void Message::DiscardUnknownFields() {
 113   return ReflectionOps::DiscardUnknownFields(this);
 114 }
 115
 116 bool Message::MergePartialFromCodedStream(io::CodedInputStream* input) {
 117   return WireFormat::ParseAndMergePartial(input, this);
 118 }
 119
 120 bool Message::ParseFromFileDescriptor(int file_descriptor) {
 121   io::FileInputStream input(file_descriptor);
 122   return ParseFromZeroCopyStream(&input) && input.GetErrno() == 0;
 123 }
 124
 125 bool Message::ParsePartialFromFileDescriptor(int file_descriptor) {
 126   io::FileInputStream input(file_descriptor);
 127   return ParsePartialFromZeroCopyStream(&input) && input.GetErrno() == 0;
 128 }
 129
 130 bool Message::ParseFromIstream(istream* input) {
 131   io::IstreamInputStream zero_copy_input(input);
 132   return ParseFromZeroCopyStream(&zero_copy_input) && input->eof();
 133 }
 134
 135 bool Message::ParsePartialFromIstream(istream* input) {
 136   io::IstreamInputStream zero_copy_input(input);
 137   return ParsePartialFromZeroCopyStream(&zero_copy_input) && input->eof();
 138 }
 139
 140
 141 void Message::SerializeWithCachedSizes(
 142     io::CodedOutputStream* output) const {
 143   WireFormat::SerializeWithCachedSizes(*this, GetCachedSize(), output);
 144 }
 145
 146 int Message::ByteSize() const {
 147   int size = WireFormat::ByteSize(*this);
 148   SetCachedSize(size);
 149   return size;
 150 }
 151
 152 void Message::SetCachedSize(int /* size */) const {
 153   GOOGLE_LOG(FATAL) << "Message class \"" << GetDescriptor()->full_name()
 154              << "\" implements neither SetCachedSize() nor ByteSize().  "
 155                 "Must implement one or the other.";
 156 }
 157
 158 int Message::SpaceUsed() const {
 159   return GetReflection()->SpaceUsed(*this);
 160 }
 161
 162 bool Message::SerializeToFileDescriptor(int file_descriptor) const {
 163   io::FileOutputStream output(file_descriptor);
 164   return SerializeToZeroCopyStream(&output);
 165 }
 166
 167 bool Message::SerializePartialToFileDescriptor(int file_descriptor) const {
 168   io::FileOutputStream output(file_descriptor);
 169   return SerializePartialToZeroCopyStream(&output);
 170 }
 171
 172 bool Message::SerializeToOstream(ostream* output) const {
 173   {
 174     io::OstreamOutputStream zero_copy_output(output);
 175     if (!SerializeToZeroCopyStream(&zero_copy_output)) return false;
 176   }
 177   return output->good();
 178 }
 179
 180 bool Message::SerializePartialToOstream(ostream* output) const {
 181   io::OstreamOutputStream zero_copy_output(output);
 182   return SerializePartialToZeroCopyStream(&zero_copy_output);
 183 }
 184
 185
 186 // =============================================================================
 187 // Reflection and associated Template Specializations
 188
 189 Reflection::~Reflection() {}
 190
 191 #define HANDLE_TYPE(TYPE, CPPTYPE, CTYPE)                             \
 192 template<>                                                            \
 193 const RepeatedField<TYPE>& Reflection::GetRepeatedField<TYPE>(        \
 194     const Message& message, const FieldDescriptor* field) const {     \
 195   return *static_cast<RepeatedField<TYPE>* >(                         \
 196       MutableRawRepeatedField(const_cast<Message*>(&message),         \
 197                           field, CPPTYPE, CTYPE, NULL));              \
 198 }                                                                     \
 199                                                                       \
 200 template<>                                                            \
 201 RepeatedField<TYPE>* Reflection::MutableRepeatedField<TYPE>(          \
 202     Message* message, const FieldDescriptor* field) const {           \
 203   return static_cast<RepeatedField<TYPE>* >(                          \
 204       MutableRawRepeatedField(message, field, CPPTYPE, CTYPE, NULL)); \
 205 }
 206
 207 HANDLE_TYPE(int32,  FieldDescriptor::CPPTYPE_INT32,  -1);
 208 HANDLE_TYPE(int64,  FieldDescriptor::CPPTYPE_INT64,  -1);
 209 HANDLE_TYPE(uint32, FieldDescriptor::CPPTYPE_UINT32, -1);
 210 HANDLE_TYPE(uint64, FieldDescriptor::CPPTYPE_UINT64, -1);
 211 HANDLE_TYPE(float,  FieldDescriptor::CPPTYPE_FLOAT,  -1);
 212 HANDLE_TYPE(double, FieldDescriptor::CPPTYPE_DOUBLE, -1);
 213 HANDLE_TYPE(bool,   FieldDescriptor::CPPTYPE_BOOL,   -1);
 214
 215
 216 #undef HANDLE_TYPE
 217
 218 void* Reflection::MutableRawRepeatedString(
 219     Message* message, const FieldDescriptor* field, bool is_string) const {
 220   return MutableRawRepeatedField(message, field,
 221       FieldDescriptor::CPPTYPE_STRING, FieldOptions::STRING, NULL);
 222 }
 223
 224
 225 // =============================================================================
 226 // MessageFactory
 227
 228 MessageFactory::~MessageFactory() {}
 229
 230 namespace {
 231
 232 class GeneratedMessageFactory : public MessageFactory {
 233  public:
 234   GeneratedMessageFactory();
 235   ~GeneratedMessageFactory();
 236
 237   static GeneratedMessageFactory* singleton();
 238
 239   typedef void RegistrationFunc(const string&);
 240   void RegisterFile(const char* file, RegistrationFunc* registration_func);
 241   void RegisterType(const Descriptor* descriptor, const Message* prototype);
 242
 243   // implements MessageFactory ---------------------------------------
 244   const Message* GetPrototype(const Descriptor* type);
 245
 246  private:
 247   // Only written at static init time, so does not require locking.
 248   hash_map<const char*, RegistrationFunc*,
 249            hash<const char*>, streq> file_map_;
 250
 251   // Initialized lazily, so requires locking.
 252   Mutex mutex_;
 253   hash_map<const Descriptor*, const Message*> type_map_;
 254 };
 255
 256 GeneratedMessageFactory* generated_message_factory_ = NULL;
 257 GOOGLE_PROTOBUF_DECLARE_ONCE(generated_message_factory_once_init_);
 258
 259 void ShutdownGeneratedMessageFactory() {
 260   delete generated_message_factory_;
 261 }
 262
 263 void InitGeneratedMessageFactory() {
 264   generated_message_factory_ = new GeneratedMessageFactory;
 265   internal::OnShutdown(&ShutdownGeneratedMessageFactory);
 266 }
 267
 268 GeneratedMessageFactory::GeneratedMessageFactory() {}
 269 GeneratedMessageFactory::~GeneratedMessageFactory() {}
 270
 271 GeneratedMessageFactory* GeneratedMessageFactory::singleton() {
 272   ::google::protobuf::GoogleOnceInit(&generated_message_factory_once_init_,
 273                  &InitGeneratedMessageFactory);
 274   return generated_message_factory_;
 275 }
 276
 277 void GeneratedMessageFactory::RegisterFile(
 278     const char* file, RegistrationFunc* registration_func) {
 279   if (!InsertIfNotPresent(&file_map_, file, registration_func)) {
 280     GOOGLE_LOG(FATAL) << "File is already registered: " << file;
 281   }
 282 }
 283
 284 void GeneratedMessageFactory::RegisterType(const Descriptor* descriptor,
 285                                            const Message* prototype) {
 286   GOOGLE_DCHECK_EQ(descriptor->file()->pool(), DescriptorPool::generated_pool())
 287     << "Tried to register a non-generated type with the generated "
 288        "type registry.";
 289
 290   // This should only be called as a result of calling a file registration
 291   // function during GetPrototype(), in which case we already have locked
 292   // the mutex.
 293   mutex_.AssertHeld();
 294   if (!InsertIfNotPresent(&type_map_, descriptor, prototype)) {
 295     GOOGLE_LOG(DFATAL) << "Type is already registered: " << descriptor->full_name();
 296   }
 297 }
 298
 299
 300 const Message* GeneratedMessageFactory::GetPrototype(const Descriptor* type) {
 301   {
 302     ReaderMutexLock lock(&mutex_);
 303     const Message* result = FindPtrOrNull(type_map_, type);
 304     if (result != NULL) return result;
 305   }
 306
 307   // If the type is not in the generated pool, then we can't possibly handle
 308   // it.
 309   if (type->file()->pool() != DescriptorPool::generated_pool()) return NULL;
 310
 311   // Apparently the file hasn't been registered yet.  Let's do that now.
 312   RegistrationFunc* registration_func =
 313       FindPtrOrNull(file_map_, type->file()->name().c_str());
 314   if (registration_func == NULL) {
 315     GOOGLE_LOG(DFATAL) << "File appears to be in generated pool but wasn't "
 316                    "registered: " << type->file()->name();
 317     return NULL;
 318   }
 319
 320   WriterMutexLock lock(&mutex_);
 321
 322   // Check if another thread preempted us.
 323   const Message* result = FindPtrOrNull(type_map_, type);
 324   if (result == NULL) {
 325     // Nope.  OK, register everything.
 326     registration_func(type->file()->name());
 327     // Should be here now.
 328     result = FindPtrOrNull(type_map_, type);
 329   }
 330
 331   if (result == NULL) {
 332     GOOGLE_LOG(DFATAL) << "Type appears to be in generated pool but wasn't "
 333                 << "registered: " << type->full_name();
 334   }
 335
 336   return result;
 337 }
 338
 339 }  // namespace
 340
 341 MessageFactory* MessageFactory::generated_factory() {
 342   return GeneratedMessageFactory::singleton();
 343 }
 344
 345 void MessageFactory::InternalRegisterGeneratedFile(
 346     const char* filename, void (*register_messages)(const string&)) {
 347   GeneratedMessageFactory::singleton()->RegisterFile(filename,
 348                                                      register_messages);
 349 }
 350
 351 void MessageFactory::InternalRegisterGeneratedMessage(
 352     const Descriptor* descriptor, const Message* prototype) {
 353   GeneratedMessageFactory::singleton()->RegisterType(descriptor, prototype);
 354 }
 355
 356
 357 }  // namespace protobuf
 358 }  // namespace google