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

source code of include/google/protobuf/map_field_lite.h