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 #ifndef GOOGLE_PROTOBUF_MAP_FIELD_LITE_H__
32 #define GOOGLE_PROTOBUF_MAP_FIELD_LITE_H__
33
34 #include <type_traits>
35 #include <google/protobuf/parse_context.h>
36 #include <google/protobuf/io/coded_stream.h>
37 #include <google/protobuf/map.h>
38 #include <google/protobuf/map_entry_lite.h>
39 #include <google/protobuf/port.h>
40 #include <google/protobuf/wire_format_lite.h>
41
42 #include <google/protobuf/port_def.inc>
43
44 #ifdef SWIG
45 #error "You cannot SWIG proto headers"
46 #endif
47
48 namespace google {
49 namespace protobuf {
50 namespace internal {
51
52 // This class provides access to map field using generated api. It is used for
53 // internal generated message implementation only. Users should never use this
54 // directly.
55 template <typename Derived, typename Key, typename T,
56 WireFormatLite::FieldType key_wire_type,
57 WireFormatLite::FieldType value_wire_type>
58 class MapFieldLite {
59 // Define message type for internal repeated field.
60 typedef Derived EntryType;
61
62 public:
63 typedef Map<Key, T> MapType;
64 typedef EntryType EntryTypeTrait;
65
MapFieldLite()66 constexpr MapFieldLite() {}
67
MapFieldLite(Arena * arena)68 explicit MapFieldLite(Arena* arena) : map_(arena) {}
69
70 // Accessors
GetMap()71 const Map<Key, T>& GetMap() const { return map_; }
MutableMap()72 Map<Key, T>* MutableMap() { return &map_; }
73
74 // Convenient methods for generated message implementation.
size()75 int size() const { return static_cast<int>(map_.size()); }
Clear()76 void Clear() { return map_.clear(); }
MergeFrom(const MapFieldLite & other)77 void MergeFrom(const MapFieldLite& other) {
78 for (typename Map<Key, T>::const_iterator it = other.map_.begin();
79 it != other.map_.end(); ++it) {
80 map_[it->first] = it->second;
81 }
82 }
Swap(MapFieldLite * other)83 void Swap(MapFieldLite* other) { map_.swap(other->map_); }
InternalSwap(MapFieldLite * other)84 void InternalSwap(MapFieldLite* other) { map_.InternalSwap(other->map_); }
85
86 // Used in the implementation of parsing. Caller should take the ownership iff
87 // arena_ is NULL.
NewEntry()88 EntryType* NewEntry() const {
89 return Arena::CreateMessage<EntryType>(map_.arena());
90 }
91 // Used in the implementation of serializing enum value type. Caller should
92 // take the ownership iff arena_ is NULL.
NewEnumEntryWrapper(const Key & key,const T t)93 EntryType* NewEnumEntryWrapper(const Key& key, const T t) const {
94 return EntryType::EnumWrap(key, t, map_.arena_);
95 }
96 // Used in the implementation of serializing other value types. Caller should
97 // take the ownership iff arena_ is NULL.
NewEntryWrapper(const Key & key,const T & t)98 EntryType* NewEntryWrapper(const Key& key, const T& t) const {
99 return EntryType::Wrap(key, t, map_.arena_);
100 }
101
_InternalParse(const char * ptr,ParseContext * ctx)102 const char* _InternalParse(const char* ptr, ParseContext* ctx) {
103 typename Derived::template Parser<MapFieldLite, Map<Key, T>> parser(this);
104 return parser._InternalParse(ptr, ctx);
105 }
106
107 template <typename UnknownType>
ParseWithEnumValidation(const char * ptr,ParseContext * ctx,bool (* is_valid)(int),uint32 field_num,InternalMetadata * metadata)108 const char* ParseWithEnumValidation(const char* ptr, ParseContext* ctx,
109 bool (*is_valid)(int), uint32 field_num,
110 InternalMetadata* metadata) {
111 typename Derived::template Parser<MapFieldLite, Map<Key, T>> parser(this);
112 return parser.template ParseWithEnumValidation<UnknownType>(
113 ptr, ctx, is_valid, field_num, metadata);
114 }
115
116 private:
117 typedef void DestructorSkippable_;
118
119 Map<Key, T> map_;
120
121 friend class ::PROTOBUF_NAMESPACE_ID::Arena;
122 };
123
124 template <typename UnknownType, typename T>
125 struct EnumParseWrapper {
_InternalParseEnumParseWrapper126 const char* _InternalParse(const char* ptr, ParseContext* ctx) {
127 return map_field->template ParseWithEnumValidation<UnknownType>(
128 ptr, ctx, is_valid, field_num, metadata);
129 }
130 T* map_field;
131 bool (*is_valid)(int);
132 uint32 field_num;
133 InternalMetadata* metadata;
134 };
135
136 // Helper function because the typenames of maps are horrendous to print. This
137 // leverages compiler type deduction, to keep all type data out of the
138 // generated code
139 template <typename UnknownType, typename T>
InitEnumParseWrapper(T * map_field,bool (* is_valid)(int),uint32 field_num,InternalMetadata * metadata)140 EnumParseWrapper<UnknownType, T> InitEnumParseWrapper(
141 T* map_field, bool (*is_valid)(int), uint32 field_num,
142 InternalMetadata* metadata) {
143 return EnumParseWrapper<UnknownType, T>{map_field, is_valid, field_num,
144 metadata};
145 }
146
147 // True if IsInitialized() is true for value field in all elements of t. T is
148 // expected to be message. It's useful to have this helper here to keep the
149 // protobuf compiler from ever having to emit loops in IsInitialized() methods.
150 // We want the C++ compiler to inline this or not as it sees fit.
151 template <typename Derived, typename Key, typename T,
152 WireFormatLite::FieldType key_wire_type,
153 WireFormatLite::FieldType value_wire_type>
AllAreInitialized(const MapFieldLite<Derived,Key,T,key_wire_type,value_wire_type> & field)154 bool AllAreInitialized(const MapFieldLite<Derived, Key, T, key_wire_type,
155 value_wire_type>& field) {
156 const auto& t = field.GetMap();
157 for (typename Map<Key, T>::const_iterator it = t.begin(); it != t.end();
158 ++it) {
159 if (!it->second.IsInitialized()) return false;
160 }
161 return true;
162 }
163
164 template <typename MEntry>
165 struct MapEntryToMapField : MapEntryToMapField<typename MEntry::SuperType> {};
166
167 template <typename T, typename Key, typename Value,
168 WireFormatLite::FieldType kKeyFieldType,
169 WireFormatLite::FieldType kValueFieldType>
170 struct MapEntryToMapField<
171 MapEntryLite<T, Key, Value, kKeyFieldType, kValueFieldType>> {
172 typedef MapFieldLite<
173 MapEntryLite<T, Key, Value, kKeyFieldType, kValueFieldType>, Key, Value,
174 kKeyFieldType, kValueFieldType>
175 MapFieldType;
176 };
177
178 } // namespace internal
179 } // namespace protobuf
180 } // namespace google
181
182 #include <google/protobuf/port_undef.inc>
183
184 #endif // GOOGLE_PROTOBUF_MAP_FIELD_LITE_H__
185