1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifndef INCLUDED_BASEBMP_ACCESSORFUNCTORS_HXX
#define INCLUDED_BASEBMP_ACCESSORFUNCTORS_HXX
#include <osl/diagnose.h>
#include <basebmp/metafunctions.hxx>
#include <functional>
namespace basebmp
{
// Some common accessor functors
/// combine two values via XOR
template< typename T > struct XorFunctor : public std::binary_function<T,T,T>
{
T operator()( T v1, T v2 ) const { return v1 ^ v2; }
};
/// Base class, passing on the arg types
template< typename T, typename M > struct MaskFunctorBase :
public TernaryFunctorBase<T,M,T,T> {};
/** Let a mask flag decide between two values
@tpl polarity
Mask polarity. When true, a false in the mask denotes
transparency, i.e. the original value will display. And vice
versa.
*/
template< typename T,
typename M,
bool polarity > struct GenericOutputMaskFunctor : public MaskFunctorBase<T,M>
{
/// Ternary mask operation - selects v1 for !m == polarity, v2 otherwise
T operator()( T v1, M m, T v2 ) const
{
return !m == polarity ? v1 : v2;
}
};
/** Let a mask bit decide between two values (specialization for
integer mask types)
*/
template< typename T,
typename M,
bool polarity > struct IntegerOutputMaskFunctor;
template< typename T,
typename M > struct IntegerOutputMaskFunctor<T,M,true> : public MaskFunctorBase<T,M>
{
/** Mask v with state of m
@return v2, if m != 0, v1 otherwise.
*/
T operator()( T v1, M m, T v2 ) const
{
typedef typename make_unsigned<T>::type unsigned_T;
// mask will be 0, if m == 0, and 1 otherwise
const T mask( unsigned_cast<T>(m | -m) >> (sizeof(unsigned_T)*8 - 1) );
return v1*static_cast<M>(1-mask) + v2*mask;
}
};
template< typename T,
typename M > struct IntegerOutputMaskFunctor<T,M,false> : public MaskFunctorBase<T,M>
{
/** Mask v with state of m
@return v2, if m != 0, v1 otherwise.
*/
T operator()( T v1, M m, T v2 ) const
{
typedef typename make_unsigned<T>::type unsigned_T;
// mask will be 0, if m == 0, and 1 otherwise
const T mask( unsigned_cast<T>(m | -m) >> (sizeof(unsigned_T)*8 - 1) );
return v1*mask + v2*static_cast<M>(1-mask);
}
};
/** Let a mask bit decide between two values (specialization for
binary-valued mask types)
*/
template< typename T, typename M, bool polarity > struct FastIntegerOutputMaskFunctor;
template< typename T, typename M > struct FastIntegerOutputMaskFunctor<T,M,true> :
public MaskFunctorBase<T,M>
{
/// Specialization, only valid if mask can only attain 0 or 1
T operator()( T v1, M m, T v2 ) const
{
OSL_ASSERT(m<=1);
return v1*static_cast<M>(1-m) + v2*m;
}
};
template< typename T, typename M > struct FastIntegerOutputMaskFunctor<T,M,false> :
public MaskFunctorBase<T,M>
{
/// Specialization, only valid if mask can only attain 0 or 1
T operator()( T v1, M m, T v2 ) const
{
OSL_ASSERT(m<=1);
return v1*m + v2*static_cast<M>(1-m);
}
};
/** Split a pair value from a JoinImageAccessorAdapter into its
individual values, and pass it on to a ternary functor
This wrapper is an adaptable binary functor, and can thus be used
with a BinarySetterFunctionAccessorAdapter. Useful e.g. for
out-of-image alpha channel, or a masked image.
@tpl Functor
An adaptable ternary functor (as can e.g. be passed to the
TernarySetterFunctionAccessorAdapter)
*/
template< typename Functor > struct BinaryFunctorSplittingWrapper :
public std::binary_function<typename Functor::first_argument_type,
std::pair<typename Functor::third_argument_type,
typename Functor::second_argument_type>,
typename Functor::result_type>
{
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
// making all members public, if no member template friends
private:
template<class A> friend struct BinaryFunctorSplittingWrapper;
#endif
Functor maFunctor;
public:
BinaryFunctorSplittingWrapper() : maFunctor() {}
template< class A > explicit
BinaryFunctorSplittingWrapper(
BinaryFunctorSplittingWrapper<A> const& src ) : maFunctor(src.maFunctor) {}
template< class F > explicit
BinaryFunctorSplittingWrapper( F const& func ) : maFunctor(func) {}
typename Functor::result_type operator()(
typename Functor::first_argument_type v1,
std::pair< typename Functor::third_argument_type,
typename Functor::second_argument_type > const& v2 ) const
{
return maFunctor( v1, v2.second, v2.first );
}
};
} // namespace basebmp
#endif /* INCLUDED_BASEBMP_ACCESSORFUNCTORS_HXX */
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
