← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to protobuf/files/src/google/protobuf/dynamic_message.h

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

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