Name all the GLib timeout sources
[WebKit-https.git] / Source / WebCore / platform / CalculationValue.h
1 /*
2  * Copyright (C) 2011 Google 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 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
31 #ifndef CalculationValue_h
32 #define CalculationValue_h
33
34 #include "Length.h"
35 #include "LengthFunctions.h"
36 #include <wtf/OwnPtr.h>
37 #include <wtf/PassOwnPtr.h>
38 #include <wtf/RefCounted.h>
39 #include <wtf/Vector.h>
40
41 namespace WebCore {
42
43 enum CalcOperator {
44     CalcAdd = '+',
45     CalcSubtract = '-',
46     CalcMultiply = '*',
47     CalcDivide = '/'
48 };
49
50 enum CalculationPermittedValueRange {
51     CalculationRangeAll,
52     CalculationRangeNonNegative
53 };
54
55 enum CalcExpressionNodeType {
56     CalcExpressionNodeUndefined,
57     CalcExpressionNodeNumber,
58     CalcExpressionNodeLength,
59     CalcExpressionNodeBinaryOperation,
60     CalcExpressionNodeBlendLength,
61 };
62
63 class CalcExpressionNode {
64     WTF_MAKE_FAST_ALLOCATED;
65 public:
66     CalcExpressionNode()
67         : m_type(CalcExpressionNodeUndefined)
68     {
69     }
70
71     virtual ~CalcExpressionNode()
72     {
73     }
74
75     virtual float evaluate(float maxValue) const = 0;
76     virtual bool operator==(const CalcExpressionNode&) const = 0;
77
78     CalcExpressionNodeType type() const { return m_type; }
79
80 protected:
81     CalcExpressionNodeType m_type;
82 };
83
84 class CalculationValue : public RefCounted<CalculationValue> {
85 public:
86     static PassRefPtr<CalculationValue> create(PassOwnPtr<CalcExpressionNode> value, CalculationPermittedValueRange);
87     float evaluate(float maxValue) const;
88
89     bool operator==(const CalculationValue& o) const
90     {
91         return *(m_value.get()) == *(o.m_value.get());
92     }
93
94     bool isNonNegative() const { return m_isNonNegative; }
95     const CalcExpressionNode* expression() const { return m_value.get(); }
96
97 private:
98     CalculationValue(PassOwnPtr<CalcExpressionNode> value, CalculationPermittedValueRange range)
99         : m_value(value)
100         , m_isNonNegative(range == CalculationRangeNonNegative)
101     {
102     }
103
104     OwnPtr<CalcExpressionNode> m_value;
105     bool m_isNonNegative;
106 };
107
108 class CalcExpressionNumber : public CalcExpressionNode {
109 public:
110     explicit CalcExpressionNumber(float value)
111         : m_value(value)
112     {
113         m_type = CalcExpressionNodeNumber;
114     }
115
116     bool operator==(const CalcExpressionNumber& o) const
117     {
118         return m_value == o.m_value;
119     }
120
121     virtual bool operator==(const CalcExpressionNode& o) const OVERRIDE
122     {
123         return type() == o.type() && *this == static_cast<const CalcExpressionNumber&>(o);
124     }
125
126     virtual float evaluate(float) const OVERRIDE
127     {
128         return m_value;
129     }
130
131     float value() const { return m_value; }
132
133 private:
134     float m_value;
135 };
136
137 inline const CalcExpressionNumber* toCalcExpressionNumber(const CalcExpressionNode* value)
138 {
139     ASSERT_WITH_SECURITY_IMPLICATION(!value || value->type() == CalcExpressionNodeNumber);
140     return static_cast<const CalcExpressionNumber*>(value);
141 }
142
143 class CalcExpressionLength : public CalcExpressionNode {
144 public:
145     explicit CalcExpressionLength(Length length)
146         : m_length(length)
147     {
148         m_type = CalcExpressionNodeLength;
149     }
150
151     bool operator==(const CalcExpressionLength& o) const
152     {
153         return m_length == o.m_length;
154     }
155
156     virtual bool operator==(const CalcExpressionNode& o) const OVERRIDE
157     {
158         return type() == o.type() && *this == static_cast<const CalcExpressionLength&>(o);
159     }
160
161     virtual float evaluate(float maxValue) const OVERRIDE
162     {
163         return floatValueForLength(m_length, maxValue);
164     }
165
166     const Length& length() const { return m_length; }
167
168 private:
169     Length m_length;
170 };
171
172 inline const CalcExpressionLength* toCalcExpressionLength(const CalcExpressionNode* value)
173 {
174     ASSERT_WITH_SECURITY_IMPLICATION(!value || value->type() == CalcExpressionNodeLength);
175     return static_cast<const CalcExpressionLength*>(value);
176 }
177
178 class CalcExpressionBinaryOperation : public CalcExpressionNode {
179 public:
180     CalcExpressionBinaryOperation(PassOwnPtr<CalcExpressionNode> leftSide, PassOwnPtr<CalcExpressionNode> rightSide, CalcOperator op)
181         : m_leftSide(leftSide)
182         , m_rightSide(rightSide)
183         , m_operator(op)
184     {
185         m_type = CalcExpressionNodeBinaryOperation;
186     }
187
188     bool operator==(const CalcExpressionBinaryOperation& o) const
189     {
190         return m_operator == o.m_operator && *m_leftSide == *o.m_leftSide && *m_rightSide == *o.m_rightSide;
191     }
192
193     virtual bool operator==(const CalcExpressionNode& o) const OVERRIDE
194     {
195         return type() == o.type() && *this == static_cast<const CalcExpressionBinaryOperation&>(o);
196     }
197
198     virtual float evaluate(float) const OVERRIDE;
199
200     const CalcExpressionNode* leftSide() const { return m_leftSide.get(); }
201     const CalcExpressionNode* rightSide() const { return m_rightSide.get(); }
202     CalcOperator getOperator() const { return m_operator; }
203
204 private:
205     OwnPtr<CalcExpressionNode> m_leftSide;
206     OwnPtr<CalcExpressionNode> m_rightSide;
207     CalcOperator m_operator;
208 };
209
210 inline const CalcExpressionBinaryOperation* toCalcExpressionBinaryOperation(const CalcExpressionNode* value)
211 {
212     ASSERT_WITH_SECURITY_IMPLICATION(!value || value->type() == CalcExpressionNodeBinaryOperation);
213     return static_cast<const CalcExpressionBinaryOperation*>(value);
214 }
215
216 class CalcExpressionBlendLength : public CalcExpressionNode {
217 public:
218     CalcExpressionBlendLength(Length from, Length to, float progress)
219         : m_from(from)
220         , m_to(to)
221         , m_progress(progress)
222     {
223         m_type = CalcExpressionNodeBlendLength;
224     }
225
226     bool operator==(const CalcExpressionBlendLength& o) const
227     {
228         return m_progress == o.m_progress && m_from == o.m_from && m_to == o.m_to;
229     }
230
231     virtual bool operator==(const CalcExpressionNode& o) const OVERRIDE
232     {
233         return type() == o.type() && *this == static_cast<const CalcExpressionBlendLength&>(o);
234     }
235
236     virtual float evaluate(float maxValue) const OVERRIDE
237     {
238         return (1.0f - m_progress) * floatValueForLength(m_from, maxValue) + m_progress * floatValueForLength(m_to, maxValue);
239     }
240
241     const Length& from() const { return m_from; }
242     const Length& to() const { return m_to; }
243     float progress() const { return m_progress; }
244
245 private:
246     Length m_from;
247     Length m_to;
248     float m_progress;
249 };
250
251 inline const CalcExpressionBlendLength* toCalcExpressionBlendLength(const CalcExpressionNode* value)
252 {
253     ASSERT_WITH_SECURITY_IMPLICATION(!value || value->type() == CalcExpressionNodeBlendLength);
254     return static_cast<const CalcExpressionBlendLength*>(value);
255 }
256
257 } // namespace WebCore
258
259 #endif // CalculationValue_h