← Back to branch summary

~ubuntu-branches/debian/squeeze/protobuf/squeeze

« back to all changes in this revision

Viewing changes to src/google/protobuf/message.cc

  • Committer: Bazaar Package Importer
  • Author(s): Julien Cristau
  • Date: 2009-06-02 16:19:00 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090602161900-vm176i3ryt35yk91
Tags: 2.0.3-2.2
* Non-maintainer upload.
* Fix FTBFS from -2.1: don't fail when we can't clean up the java build,
  such as when openjdk isn't installed.
* Disable parallel builds, because libtool is made of fail (if binary-arch
  and build-indep run concurrently, we relink a library while it's being
  used; that doesn't work so well).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/google/protobuf/message.cc
1
1
// Protocol Buffers - Google's data interchange format
2
 
// Copyright 2008 Google Inc.
 
2
// Copyright 2008 Google Inc.  All rights reserved.
3
3
// http://code.google.com/p/protobuf/
4
4
//
5
 
// Licensed under the Apache License, Version 2.0 (the "License");
6
 
// you may not use this file except in compliance with the License.
7
 
// You may obtain a copy of the License at
8
 
//
9
 
//      http://www.apache.org/licenses/LICENSE-2.0
10
 
//
11
 
// Unless required by applicable law or agreed to in writing, software
12
 
// distributed under the License is distributed on an "AS IS" BASIS,
13
 
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
 
// See the License for the specific language governing permissions and
15
 
// limitations under the License.
 
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.
16
30
 
17
31
// Author: kenton@google.com (Kenton Varda)
18
32
//  Based on original Protocol Buffers design by
50
64
}
51
65
 
52
66
Message::~Message() {}
53
 
Message::Reflection::~Reflection() {}
54
67
 
55
68
void Message::MergeFrom(const Message& from) {
56
69
  const Descriptor* descriptor = GetDescriptor();
58
71
    << ": Tried to merge from a message with a different type.  "
59
72
       "to: " << descriptor->full_name() << ", "
60
73
       "from:" << from.GetDescriptor()->full_name();
61
 
  ReflectionOps::Merge(descriptor, *from.GetReflection(), GetReflection());
 
74
  ReflectionOps::Merge(from, this);
62
75
}
63
76
 
64
77
void Message::CopyFrom(const Message& from) {
67
80
    << ": Tried to copy from a message with a different type."
68
81
       "to: " << descriptor->full_name() << ", "
69
82
       "from:" << from.GetDescriptor()->full_name();
70
 
  ReflectionOps::Copy(descriptor, *from.GetReflection(), GetReflection());
 
83
  ReflectionOps::Copy(from, this);
71
84
}
72
85
 
73
86
void Message::Clear() {
74
 
  ReflectionOps::Clear(GetDescriptor(), GetReflection());
 
87
  ReflectionOps::Clear(this);
75
88
}
76
89
 
77
90
bool Message::IsInitialized() const {
78
 
  return ReflectionOps::IsInitialized(GetDescriptor(), *GetReflection());
 
91
  return ReflectionOps::IsInitialized(*this);
79
92
}
80
93
 
81
94
void Message::FindInitializationErrors(vector<string>* errors) const {
82
 
  return ReflectionOps::FindInitializationErrors(
83
 
    GetDescriptor(), *GetReflection(), "", errors);
 
95
  return ReflectionOps::FindInitializationErrors(*this, "", errors);
84
96
}
85
97
 
86
98
string Message::InitializationErrorString() const {
96
108
}
97
109
 
98
110
void Message::DiscardUnknownFields() {
99
 
  return ReflectionOps::DiscardUnknownFields(GetDescriptor(), GetReflection());
 
111
  return ReflectionOps::DiscardUnknownFields(this);
100
112
}
101
113
 
102
114
bool Message::MergePartialFromCodedStream(io::CodedInputStream* input) {
103
 
  return WireFormat::ParseAndMergePartial(
104
 
    GetDescriptor(), input, GetReflection());
 
115
  return WireFormat::ParseAndMergePartial(input, this);
105
116
}
106
117
 
107
118
bool Message::MergeFromCodedStream(io::CodedInputStream* input) {
178
189
 
179
190
bool Message::SerializeWithCachedSizes(
180
191
    io::CodedOutputStream* output) const {
181
 
  return WireFormat::SerializeWithCachedSizes(
182
 
    GetDescriptor(), GetReflection(), GetCachedSize(), output);
 
192
  return WireFormat::SerializeWithCachedSizes(*this, GetCachedSize(), output);
183
193
}
184
194
 
185
195
int Message::ByteSize() const {
186
 
  int size = WireFormat::ByteSize(GetDescriptor(), GetReflection());
 
196
  int size = WireFormat::ByteSize(*this);
187
197
  SetCachedSize(size);
188
198
  return size;
189
199
}
194
204
                "Must implement one or the other.";
195
205
}
196
206
 
 
207
int Message::SpaceUsed() const {
 
208
  return GetReflection()->SpaceUsed(*this);
 
209
}
 
210
 
197
211
bool Message::SerializeToCodedStream(io::CodedOutputStream* output) const {
198
212
  GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
199
213
  return SerializePartialToCodedStream(output);
281
295
}
282
296
 
283
297
 
 
298
string Message::SerializeAsString() const {
 
299
  // If the compiler implements the (Named) Return Value Optimization,
 
300
  // the local variable 'result' will not actually reside on the stack
 
301
  // of this function, but will be overlaid with the object that the
 
302
  // caller supplied for the return value to be constructed in.
 
303
  string output;
 
304
  if (!AppendToString(&output))
 
305
    output.clear();
 
306
  return output;
 
307
}
 
308
 
 
309
string Message::SerializePartialAsString() const {
 
310
  string output;
 
311
  if (!AppendPartialToString(&output))
 
312
    output.clear();
 
313
  return output;
 
314
}
 
315
 
 
316
Reflection::~Reflection() {}
 
317
 
284
318
// ===================================================================
285
319
// MessageFactory
286
320