Rename the source files for the WTF persistent coders.
[WebKit.git] / Source / WTF / wtf / persistence / PersistentEncoder.h
1 /*
2  * Copyright (C) 2010 Apple Inc. 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
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #pragma once
27
28 #include <wtf/SHA1.h>
29 #include <wtf/Vector.h>
30 #include <wtf/persistence/PersistentCoder.h>
31
32 namespace WTF {
33 namespace Persistence {
34
35 class Encoder;
36 class DataReference;
37
38 class Encoder {
39     WTF_MAKE_FAST_ALLOCATED;
40 public:
41     WTF_EXPORT_PRIVATE Encoder();
42     WTF_EXPORT_PRIVATE ~Encoder();
43
44     WTF_EXPORT_PRIVATE void encodeChecksum();
45     WTF_EXPORT_PRIVATE void encodeFixedLengthData(const uint8_t*, size_t);
46
47     template<typename T> void encodeEnum(T t)
48     {
49         COMPILE_ASSERT(sizeof(T) <= sizeof(uint64_t), enum_type_must_not_be_larger_than_64_bits);
50
51         encode(static_cast<uint64_t>(t));
52     }
53
54     template<typename T> void encode(const T& t)
55     {
56         Coder<T>::encode(*this, t);
57     }
58
59     template<typename T> Encoder& operator<<(const T& t)
60     {
61         encode(t);
62         return *this;
63     }
64
65     const uint8_t* buffer() const { return m_buffer.data(); }
66     size_t bufferSize() const { return m_buffer.size(); }
67
68     WTF_EXPORT_PRIVATE static void updateChecksumForData(SHA1&, const uint8_t*, size_t);
69     template <typename Type> static void updateChecksumForNumber(SHA1&, Type);
70
71     static const bool isIPCEncoder = false;
72
73 private:
74     WTF_EXPORT_PRIVATE void encode(bool);
75     WTF_EXPORT_PRIVATE void encode(uint8_t);
76     WTF_EXPORT_PRIVATE void encode(uint16_t);
77     WTF_EXPORT_PRIVATE void encode(uint32_t);
78     WTF_EXPORT_PRIVATE void encode(uint64_t);
79     WTF_EXPORT_PRIVATE void encode(int32_t);
80     WTF_EXPORT_PRIVATE void encode(int64_t);
81     WTF_EXPORT_PRIVATE void encode(float);
82     WTF_EXPORT_PRIVATE void encode(double);
83
84     template<typename Type> void encodeNumber(Type);
85
86     uint8_t* grow(size_t);
87
88     template <typename Type> struct Salt;
89
90     Vector<uint8_t, 4096> m_buffer;
91     SHA1 m_sha1;
92 };
93
94 template <> struct Encoder::Salt<bool> { static const unsigned value = 3; };
95 template <> struct Encoder::Salt<uint8_t> { static const  unsigned value = 5; };
96 template <> struct Encoder::Salt<uint16_t> { static const unsigned value = 7; };
97 template <> struct Encoder::Salt<uint32_t> { static const unsigned value = 11; };
98 template <> struct Encoder::Salt<uint64_t> { static const unsigned value = 13; };
99 template <> struct Encoder::Salt<int32_t> { static const unsigned value = 17; };
100 template <> struct Encoder::Salt<int64_t> { static const unsigned value = 19; };
101 template <> struct Encoder::Salt<float> { static const unsigned value = 23; };
102 template <> struct Encoder::Salt<double> { static const unsigned value = 29; };
103 template <> struct Encoder::Salt<uint8_t*> { static const unsigned value = 101; };
104
105 template <typename Type>
106 void Encoder::updateChecksumForNumber(SHA1& sha1, Type value)
107 {
108     auto typeSalt = Salt<Type>::value;
109     sha1.addBytes(reinterpret_cast<uint8_t*>(&typeSalt), sizeof(typeSalt));
110     sha1.addBytes(reinterpret_cast<uint8_t*>(&value), sizeof(value));
111 }
112
113 }
114 }