1 | // Copyright (c) 2010, Google Inc. |
2 | // All rights reserved. |
3 | // |
4 | // Redistribution and use in source and binary forms, with or without |
5 | // modification, are permitted provided that the following conditions are |
6 | // met: |
7 | // |
8 | // * Redistributions of source code must retain the above copyright |
9 | // notice, this list of conditions and the following disclaimer. |
10 | // * Redistributions in binary form must reproduce the above |
11 | // copyright notice, this list of conditions and the following disclaimer |
12 | // in the documentation and/or other materials provided with the |
13 | // distribution. |
14 | // * Neither the name of Google Inc. nor the names of its |
15 | // contributors may be used to endorse or promote products derived from |
16 | // this software without specific prior written permission. |
17 | // |
18 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
19 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
20 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
21 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
22 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
23 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
24 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
25 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
26 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
27 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
28 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
29 | // |
30 | // map_serializers.h: defines templates for serializing std::map and its |
31 | // wrappers: AddressMap, RangeMap, and ContainedRangeMap. |
32 | // |
33 | // Author: Siyang Xie (lambxsy@google.com) |
34 | |
35 | |
36 | #ifndef PROCESSOR_MAP_SERIALIZERS_H__ |
37 | #define PROCESSOR_MAP_SERIALIZERS_H__ |
38 | |
39 | #include <map> |
40 | #include <string> |
41 | |
42 | #include "processor/simple_serializer.h" |
43 | |
44 | #include "processor/address_map-inl.h" |
45 | #include "processor/range_map-inl.h" |
46 | #include "processor/contained_range_map-inl.h" |
47 | |
48 | namespace google_breakpad { |
49 | |
50 | // StdMapSerializer allocates memory and serializes an std::map instance into a |
51 | // chunk of memory data. |
52 | template<typename Key, typename Value> |
53 | class StdMapSerializer { |
54 | public: |
55 | // Calculate the memory size of serialized data. |
56 | size_t SizeOf(const std::map<Key, Value>& m) const; |
57 | |
58 | // Writes the serialized data to memory with start address = dest, |
59 | // and returns the "end" of data, i.e., return the address follow the final |
60 | // byte of data. |
61 | // NOTE: caller has to allocate enough memory before invoke Write() method. |
62 | char* Write(const std::map<Key, Value>& m, char* dest) const; |
63 | |
64 | // Serializes a std::map object into a chunk of memory data with format |
65 | // described in "StaticMap.h" comment. |
66 | // Returns a pointer to the serialized data. If size != NULL, *size is set |
67 | // to the size of serialized data, i.e., SizeOf(m). |
68 | // Caller has the ownership of memory allocated as "new char[]". |
69 | char* Serialize(const std::map<Key, Value>& m, unsigned int* size) const; |
70 | |
71 | private: |
72 | SimpleSerializer<Key> key_serializer_; |
73 | SimpleSerializer<Value> value_serializer_; |
74 | }; |
75 | |
76 | // AddressMapSerializer allocates memory and serializes an AddressMap into a |
77 | // chunk of memory data. |
78 | template<typename Addr, typename Entry> |
79 | class AddressMapSerializer { |
80 | public: |
81 | // Calculate the memory size of serialized data. |
82 | size_t SizeOf(const AddressMap<Addr, Entry>& m) const { |
83 | return std_map_serializer_.SizeOf(m.map_); |
84 | } |
85 | |
86 | // Write the serialized data to specified memory location. Return the "end" |
87 | // of data, i.e., return the address after the final byte of data. |
88 | // NOTE: caller has to allocate enough memory before invoke Write() method. |
89 | char* Write(const AddressMap<Addr, Entry>& m, char* dest) const { |
90 | return std_map_serializer_.Write(m.map_, dest); |
91 | } |
92 | |
93 | // Serializes an AddressMap object into a chunk of memory data. |
94 | // Returns a pointer to the serialized data. If size != NULL, *size is set |
95 | // to the size of serialized data, i.e., SizeOf(m). |
96 | // Caller has the ownership of memory allocated as "new char[]". |
97 | char* Serialize(const AddressMap<Addr, Entry>& m, unsigned int* size) const { |
98 | return std_map_serializer_.Serialize(m.map_, size); |
99 | } |
100 | |
101 | private: |
102 | // AddressMapSerializer is a simple wrapper of StdMapSerializer, just as |
103 | // AddressMap is a simple wrapper of std::map. |
104 | StdMapSerializer<Addr, Entry> std_map_serializer_; |
105 | }; |
106 | |
107 | // RangeMapSerializer allocates memory and serializes a RangeMap instance into a |
108 | // chunk of memory data. |
109 | template<typename Address, typename Entry> |
110 | class RangeMapSerializer { |
111 | public: |
112 | // Calculate the memory size of serialized data. |
113 | size_t SizeOf(const RangeMap<Address, Entry>& m) const; |
114 | |
115 | // Write the serialized data to specified memory location. Return the "end" |
116 | // of data, i.e., return the address after the final byte of data. |
117 | // NOTE: caller has to allocate enough memory before invoke Write() method. |
118 | char* Write(const RangeMap<Address, Entry>& m, char* dest) const; |
119 | |
120 | // Serializes a RangeMap object into a chunk of memory data. |
121 | // Returns a pointer to the serialized data. If size != NULL, *size is set |
122 | // to the size of serialized data, i.e., SizeOf(m). |
123 | // Caller has the ownership of memory allocated as "new char[]". |
124 | char* Serialize(const RangeMap<Address, Entry>& m, unsigned int* size) const; |
125 | |
126 | private: |
127 | // Convenient type name for Range. |
128 | typedef typename RangeMap<Address, Entry>::Range Range; |
129 | |
130 | // Serializer for RangeMap's key and Range::base_. |
131 | SimpleSerializer<Address> address_serializer_; |
132 | // Serializer for RangeMap::Range::entry_. |
133 | SimpleSerializer<Entry> entry_serializer_; |
134 | }; |
135 | |
136 | // ContainedRangeMapSerializer allocates memory and serializes a |
137 | // ContainedRangeMap instance into a chunk of memory data. |
138 | template<class AddrType, class EntryType> |
139 | class ContainedRangeMapSerializer { |
140 | public: |
141 | // Calculate the memory size of serialized data. |
142 | size_t SizeOf(const ContainedRangeMap<AddrType, EntryType>* m) const; |
143 | |
144 | // Write the serialized data to specified memory location. Return the "end" |
145 | // of data, i.e., return the address after the final byte of data. |
146 | // NOTE: caller has to allocate enough memory before invoke Write() method. |
147 | char* Write(const ContainedRangeMap<AddrType, EntryType>* m, |
148 | char* dest) const; |
149 | |
150 | // Serializes a ContainedRangeMap object into a chunk of memory data. |
151 | // Returns a pointer to the serialized data. If size != NULL, *size is set |
152 | // to the size of serialized data, i.e., SizeOf(m). |
153 | // Caller has the ownership of memory allocated as "new char[]". |
154 | char* Serialize(const ContainedRangeMap<AddrType, EntryType>* m, |
155 | unsigned int* size) const; |
156 | |
157 | private: |
158 | // Convenient type name for the underlying map type. |
159 | typedef std::map<AddrType, ContainedRangeMap<AddrType, EntryType>*> Map; |
160 | |
161 | // Serializer for addresses and entries stored in ContainedRangeMap. |
162 | SimpleSerializer<AddrType> addr_serializer_; |
163 | SimpleSerializer<EntryType> entry_serializer_; |
164 | }; |
165 | |
166 | } // namespace google_breakpad |
167 | |
168 | #endif // PROCESSOR_MAP_SERIALIZERS_H__ |
169 | |