Add static version of map wrappers and corresponding serializers.

git-svn-id: http://google-breakpad.googlecode.com/svn/trunk@714 4c0a9323-5329-0410-9bdc-e9ce6186880e

1 files changed, 252 insertions, 0 deletions

diff --git a/src/processor/simple_serializer-inl.h b/src/processor/simple_serializer-inl.h
new file mode 100644
index 00000000..a6f54961
--- /dev/null
+++ b/src/processor/simple_serializer-inl.h
@@ -0,0 +1,252 @@
+// Copyright (c) 2010, Google Inc.
+// All rights reserved.
+//
+// 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.
+//
+// simple_serializer-inl.h: template specializations for following types:
+// bool, const char *(C-string), string,
+// Line, Function, PublicSymbol, WindowsFrameInfo and their linked pointers.
+//
+// See simple_serializer.h for moredocumentation.
+//
+// Author: Siyang Xie (lambxsy@google.com)
+
+#ifndef PROCESSOR_SIMPLE_SERIALIZER_INL_H__
+#define PROCESSOR_SIMPLE_SERIALIZER_INL_H__
+
+#include <string>
+
+#include "processor/simple_serializer.h"
+#include "map_serializers-inl.h"
+
+#include "google_breakpad/processor/basic_source_line_resolver.h"
+#include "processor/basic_source_line_resolver_types.h"
+#include "processor/linked_ptr.h"
+#include "processor/windows_frame_info.h"
+
+namespace google_breakpad {
+
+// Specializations of SimpleSerializer: bool
+template<>
+class SimpleSerializer<bool> {
+ public:
+  static size_t SizeOf(bool boolean) { return 1; }
+
+  static char *Write(bool boolean, char *dest) {
+    *dest = static_cast<char>(boolean? 255 : 0);
+    return ++dest;
+  }
+};
+
+// Specializations of SimpleSerializer: string
+template<>
+class SimpleSerializer<string> {
+ public:
+  static size_t SizeOf(const string &str) { return str.size() + 1; }
+
+  static char *Write(const string &str, char *dest) {
+    strcpy(dest, str.c_str());
+    return dest + SizeOf(str);
+  }
+};
+
+// Specializations of SimpleSerializer: C-string
+template<>
+class SimpleSerializer<const char*> {
+ public:
+  static size_t SizeOf(const char *cstring) {
+    return strlen(cstring) + 1;
+  }
+
+  static char *Write(const char *cstring, char *dest) {
+    strcpy(dest, cstring);
+    return dest + SizeOf(cstring);
+  }
+};
+
+// Specializations of SimpleSerializer: Line
+template<>
+class SimpleSerializer<BasicSourceLineResolver::Line> {
+  typedef BasicSourceLineResolver::Line Line;
+ public:
+  static size_t SizeOf(const Line &line) {
+    return SimpleSerializer<MemAddr>::SizeOf(line.address)
+         + SimpleSerializer<MemAddr>::SizeOf(line.size)
+         + SimpleSerializer<int32_t>::SizeOf(line.source_file_id)
+         + SimpleSerializer<int32_t>::SizeOf(line.line);
+  }
+  static char *Write(const Line &line, char *dest) {
+    dest = SimpleSerializer<MemAddr>::Write(line.address, dest);
+    dest = SimpleSerializer<MemAddr>::Write(line.size, dest);
+    dest = SimpleSerializer<int32_t>::Write(line.source_file_id, dest);
+    dest = SimpleSerializer<int32_t>::Write(line.line, dest);
+    return dest;
+  }
+};
+
+// Specializations of SimpleSerializer: PublicSymbol
+template<>
+class SimpleSerializer<BasicSourceLineResolver::PublicSymbol> {
+  typedef BasicSourceLineResolver::PublicSymbol PublicSymbol;
+ public:
+  static size_t SizeOf(const PublicSymbol &pubsymbol) {
+    return SimpleSerializer<string>::SizeOf(pubsymbol.name)
+         + SimpleSerializer<MemAddr>::SizeOf(pubsymbol.address)
+         + SimpleSerializer<int32_t>::SizeOf(pubsymbol.parameter_size);
+  }
+  static char *Write(const PublicSymbol &pubsymbol, char *dest) {
+    dest = SimpleSerializer<string>::Write(pubsymbol.name, dest);
+    dest = SimpleSerializer<MemAddr>::Write(pubsymbol.address, dest);
+    dest = SimpleSerializer<int32_t>::Write(pubsymbol.parameter_size, dest);
+    return dest;
+  }
+};
+
+// Specializations of SimpleSerializer: WindowsFrameInfo
+template<>
+class SimpleSerializer<WindowsFrameInfo> {
+ public:
+  static size_t SizeOf(const WindowsFrameInfo &wfi) {
+    unsigned int size = 0;
+    size += SimpleSerializer<int32_t>::SizeOf(wfi.valid);
+    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.prolog_size);
+    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.epilog_size);
+    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.parameter_size);
+    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.saved_register_size);
+    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.local_size);
+    size += SimpleSerializer<u_int32_t>::SizeOf(wfi.max_stack_size);
+    size += SimpleSerializer<bool>::SizeOf(wfi.allocates_base_pointer);
+    size += SimpleSerializer<string>::SizeOf(wfi.program_string);
+    return size;
+  }
+  static char *Write(const WindowsFrameInfo &wfi, char *dest) {
+    dest = SimpleSerializer<int32_t>::Write(wfi.valid, dest);
+    dest = SimpleSerializer<u_int32_t>::Write(wfi.prolog_size, dest);
+    dest = SimpleSerializer<u_int32_t>::Write(wfi.epilog_size, dest);
+    dest = SimpleSerializer<u_int32_t>::Write(wfi.parameter_size, dest);
+    dest = SimpleSerializer<u_int32_t>::Write(wfi.saved_register_size, dest);
+    dest = SimpleSerializer<u_int32_t>::Write(wfi.local_size, dest);
+    dest = SimpleSerializer<u_int32_t>::Write(wfi.max_stack_size, dest);
+    dest = SimpleSerializer<bool>::Write(wfi.allocates_base_pointer, dest);
+    return SimpleSerializer<string>::Write(wfi.program_string, dest);
+  }
+};
+
+// Specializations of SimpleSerializer: Linked_ptr version of
+// Line, Function, PublicSymbol, WindowsFrameInfo.
+template<>
+class SimpleSerializer< linked_ptr<BasicSourceLineResolver::Line> > {
+  typedef BasicSourceLineResolver::Line Line;
+ public:
+  static size_t SizeOf(const linked_ptr<Line> &lineptr) {
+    if (lineptr.get() == NULL) return 0;
+    return SimpleSerializer<Line>::SizeOf(*(lineptr.get()));
+  }
+  static char *Write(const linked_ptr<Line> &lineptr, char *dest) {
+    if (lineptr.get())
+      dest = SimpleSerializer<Line>::Write(*(lineptr.get()), dest);
+    return dest;
+  }
+};
+
+template<>
+class SimpleSerializer<BasicSourceLineResolver::Function> {
+  // Convenient type names.
+  typedef BasicSourceLineResolver::Function Function;
+  typedef BasicSourceLineResolver::Line Line;
+ public:
+  static size_t SizeOf(const Function &func) {
+    unsigned int size = 0;
+    size += SimpleSerializer<string>::SizeOf(func.name);
+    size += SimpleSerializer<MemAddr>::SizeOf(func.address);
+    size += SimpleSerializer<MemAddr>::SizeOf(func.size);
+    size += SimpleSerializer<int32_t>::SizeOf(func.parameter_size);
+    size += range_map_serializer_.SizeOf(func.lines);
+    return size;
+  }
+
+  static char *Write(const Function &func, char *dest) {
+    dest = SimpleSerializer<string>::Write(func.name, dest);
+    dest = SimpleSerializer<MemAddr>::Write(func.address, dest);
+    dest = SimpleSerializer<MemAddr>::Write(func.size, dest);
+    dest = SimpleSerializer<int32_t>::Write(func.parameter_size, dest);
+    dest = range_map_serializer_.Write(func.lines, dest);
+    return dest;
+  }
+ private:
+  // This static member is defined in module_serializer.cc.
+  static RangeMapSerializer< MemAddr, linked_ptr<Line> > range_map_serializer_;
+};
+
+template<>
+class SimpleSerializer< linked_ptr<BasicSourceLineResolver::Function> > {
+  typedef BasicSourceLineResolver::Function Function;
+ public:
+  static size_t SizeOf(const linked_ptr<Function> &func) {
+    if (!func.get()) return 0;
+    return SimpleSerializer<Function>::SizeOf(*(func.get()));
+  }
+
+  static char *Write(const linked_ptr<Function> &func, char *dest) {
+    if (func.get())
+      dest = SimpleSerializer<Function>::Write(*(func.get()), dest);
+    return dest;
+  }
+};
+
+template<>
+class SimpleSerializer< linked_ptr<BasicSourceLineResolver::PublicSymbol> > {
+  typedef BasicSourceLineResolver::PublicSymbol PublicSymbol;
+ public:
+  static size_t SizeOf(const linked_ptr<PublicSymbol> &pubsymbol) {
+    if (pubsymbol.get() == NULL) return 0;
+    return SimpleSerializer<PublicSymbol>::SizeOf(*(pubsymbol.get()));
+  }
+  static char *Write(const linked_ptr<PublicSymbol> &pubsymbol, char *dest) {
+    if (pubsymbol.get())
+      dest = SimpleSerializer<PublicSymbol>::Write(*(pubsymbol.get()), dest);
+    return dest;
+  }
+};
+
+template<>
+class SimpleSerializer< linked_ptr<WindowsFrameInfo> > {
+ public:
+  static size_t SizeOf(const linked_ptr<WindowsFrameInfo> &wfi) {
+    if (wfi.get() == NULL) return 0;
+    return SimpleSerializer<WindowsFrameInfo>::SizeOf(*(wfi.get()));
+  }
+  static char *Write(const linked_ptr<WindowsFrameInfo> &wfi, char *dest) {
+    if (wfi.get())
+      dest = SimpleSerializer<WindowsFrameInfo>::Write(*(wfi.get()), dest);
+    return dest;
+  }
+};
+
+}  // namespace google_breakpad
+
+#endif  // PROCESSOR_SIMPLE_SERIALIZER_INL_H__