1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef GOOGLE_PROTOBUF_UTIL_FIELD_MASK_UTIL_H__
#define GOOGLE_PROTOBUF_UTIL_FIELD_MASK_UTIL_H__
#include <string>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/field_mask.pb.h>
namespace google {
namespace protobuf {
namespace util {
class LIBPROTOBUF_EXPORT FieldMaskUtil {
typedef google::protobuf::FieldMask FieldMask;
public:
// Converts FieldMask to/from string, formatted according to proto3 JSON
// spec for FieldMask (e.g., "foo,bar,baz.quz").
static string ToString(const FieldMask& mask);
static void FromString(const string& str, FieldMask* out);
// Checks whether the given path is valid for type T.
template <typename T>
static bool IsValidPath(const string& path) {
return InternalIsValidPath(T::descriptor(), path);
}
// Checks whether the given FieldMask is valid for type T.
template <typename T>
static bool IsValidFieldMask(const FieldMask& mask) {
for (int i = 0; i < mask.paths_size(); ++i) {
if (!InternalIsValidPath(T::descriptor(), mask.paths(i))) return false;
}
return true;
}
// Adds a path to FieldMask after checking whether the given path is valid.
// This method check-fails if the path is not a valid path for type T.
template <typename T>
static void AddPathToFieldMask(const string& path, FieldMask* mask) {
GOOGLE_CHECK(IsValidPath<T>(path));
mask->add_paths(path);
}
// Creates a FieldMask with all fields of type T. This FieldMask only
// contains fields of T but not any sub-message fields.
template <typename T>
static void GetFieldMaskForAllFields(FieldMask* out) {
InternalGetFieldMaskForAllFields(T::descriptor(), out);
}
// Converts a FieldMask to the canonical form. It will:
// 1. Remove paths that are covered by another path. For example,
// "foo.bar" is covered by "foo" and will be removed if "foo"
// is also in the FieldMask.
// 2. Sort all paths in alphabetical order.
static void ToCanonicalForm(const FieldMask& mask, FieldMask* out);
// Creates an union of two FieldMasks.
static void Union(const FieldMask& mask1, const FieldMask& mask2,
FieldMask* out);
// Creates an intersection of two FieldMasks.
static void Intersect(const FieldMask& mask1, const FieldMask& mask2,
FieldMask* out);
// Returns true if path is covered by the given FieldMask. Note that path
// "foo.bar" covers all paths like "foo.bar.baz", "foo.bar.quz.x", etc.
static bool IsPathInFieldMask(const string& path, const FieldMask& mask);
class MergeOptions;
// Merges fields specified in a FieldMask into another message.
static void MergeMessageTo(const Message& source, const FieldMask& mask,
const MergeOptions& options, Message* destination);
private:
static bool InternalIsValidPath(const Descriptor* descriptor,
const string& path);
static void InternalGetFieldMaskForAllFields(const Descriptor* descriptor,
FieldMask* out);
};
class LIBPROTOBUF_EXPORT FieldMaskUtil::MergeOptions {
public:
MergeOptions()
: replace_message_fields_(false), replace_repeated_fields_(false) {}
// When merging message fields, the default behavior is to merge the
// content of two message fields together. If you instead want to use
// the field from the source message to replace the corresponding field
// in the destination message, set this flag to true. When this flag is set,
// specified submessage fields that are missing in source will be cleared in
// destination.
void set_replace_message_fields(bool value) {
replace_message_fields_ = value;
}
bool replace_message_fields() const { return replace_message_fields_; }
// The default merging behavior will append entries from the source
// repeated field to the destination repeated field. If you only want
// to keep the entries from the source repeated field, set this flag
// to true.
void set_replace_repeated_fields(bool value) {
replace_repeated_fields_ = value;
}
bool replace_repeated_fields() const { return replace_repeated_fields_; }
private:
bool replace_message_fields_;
bool replace_repeated_fields_;
};
} // namespace util
} // namespace protobuf
} // namespace google
#endif // GOOGLE_PROTOBUF_UTIL_FIELD_MASK_UTIL_H__
|
