Unreviewed, rolling out r126169.
[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 public:
65     CalcExpressionNode()
66         : m_type(CalcExpressionNodeUndefined)
67     {
68     }
69     
70     virtual ~CalcExpressionNode()
71     {
72     }
73     
74     virtual float evaluate(float maxValue) const = 0;
75     virtual bool operator==(const CalcExpressionNode&) const = 0;
76
77     CalcExpressionNodeType type() const { return m_type; }
78     
79 protected:
80     CalcExpressionNodeType m_type;
81 };
82     
83 class CalculationValue : public RefCounted<CalculationValue> {
84 public:
85     static PassRefPtr<CalculationValue> create(PassOwnPtr<CalcExpressionNode> value, CalculationPermittedValueRange);
86     float evaluate(float maxValue) const;
87
88     bool operator==(const CalculationValue& o) const 
89     { 
90         return *(m_value.get()) == *(o.m_value.get());
91     }
92     
93 private:
94     CalculationValue(PassOwnPtr<CalcExpressionNode> value, CalculationPermittedValueRange range)
95         : m_value(value)
96         , m_isNonNegative(range == CalculationRangeNonNegative)
97     {
98     }
99     
100     OwnPtr<CalcExpressionNode> m_value;
101     bool m_isNonNegative;
102 };
103
104 class CalcExpressionNumber : public CalcExpressionNode {
105 public:
106     explicit CalcExpressionNumber(float value)
107         : m_value(value)
108     {
109         m_type = CalcExpressionNodeNumber;
110     }
111
112     bool operator==(const CalcExpressionNumber& o) const
113     {
114         return m_value == o.m_value;
115     }
116
117     virtual bool operator==(const CalcExpressionNode& o) const
118     {
119         return type() == o.type() && *this == static_cast<const CalcExpressionNumber&>(o);
120     }
121     
122     virtual float evaluate(float) const 
123     {
124         return m_value;
125     }
126     
127 private:
128     float m_value;
129 };
130
131 class CalcExpressionLength : public CalcExpressionNode {
132 public:
133     explicit CalcExpressionLength(Length length)
134         : m_length(length)
135     {
136         m_type = CalcExpressionNodeLength;
137     }
138
139     bool operator==(const CalcExpressionLength& o) const
140     {
141         return m_length == o.m_length;
142     }
143     
144     virtual bool operator==(const CalcExpressionNode& o) const
145     {
146         return type() == o.type() && *this == static_cast<const CalcExpressionLength&>(o);
147     }
148     
149     virtual float evaluate(float maxValue) const
150     {
151         return floatValueForLength(m_length, maxValue);
152     }
153     
154 private:
155     Length m_length;
156 };
157
158 class CalcExpressionBinaryOperation : public CalcExpressionNode {
159 public:
160     CalcExpressionBinaryOperation(PassOwnPtr<CalcExpressionNode> leftSide, PassOwnPtr<CalcExpressionNode> rightSide, CalcOperator op)
161         : m_leftSide(leftSide)
162         , m_rightSide(rightSide)
163         , m_operator(op)
164     {
165         m_type = CalcExpressionNodeBinaryOperation;
166     }
167
168     bool operator==(const CalcExpressionBinaryOperation& o) const
169     {
170         return m_operator == o.m_operator && *m_leftSide == *o.m_leftSide && *m_rightSide == *o.m_rightSide;
171     }
172
173     virtual bool operator==(const CalcExpressionNode& o) const
174     {
175         return type() == o.type() && *this == static_cast<const CalcExpressionBinaryOperation&>(o);
176     }
177     
178     
179     virtual float evaluate(float) const;
180
181 private:
182     OwnPtr<CalcExpressionNode> m_leftSide;
183     OwnPtr<CalcExpressionNode> m_rightSide;
184     CalcOperator m_operator;
185 };
186
187 class CalcExpressionBlendLength : public CalcExpressionNode {
188 public:
189     CalcExpressionBlendLength(Length from, Length to, float progress)
190         : m_from(from)
191         , m_to(to)
192         , m_progress(progress)
193     {
194         m_type = CalcExpressionNodeBlendLength;
195     }
196     
197     bool operator==(const CalcExpressionBlendLength& o) const
198     {
199         return m_progress == o.m_progress && m_from == o.m_from && m_to == o.m_to;
200     }
201     
202     virtual bool operator==(const CalcExpressionNode& o) const
203     {
204         return type() == o.type() && *this == static_cast<const CalcExpressionBlendLength&>(o);
205     }
206     
207     virtual float evaluate(float maxValue) const
208     {
209         return (1.0f - m_progress) * floatValueForLength(m_from, maxValue) + m_progress * floatValueForLength(m_to, maxValue);
210     }
211     
212 private:  
213     Length m_from;
214     Length m_to;
215     float m_progress;
216 };
217     
218 } // namespace WebCore
219
220 #endif // CalculationValue_h