Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*
3 : : * This file is part of the LibreOffice project.
4 : : *
5 : : * This Source Code Form is subject to the terms of the Mozilla Public
6 : : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : : *
9 : : * This file incorporates work covered by the following license notice:
10 : : *
11 : : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : : * contributor license agreements. See the NOTICE file distributed
13 : : * with this work for additional information regarding copyright
14 : : * ownership. The ASF licenses this file to you under the Apache
15 : : * License, Version 2.0 (the "License"); you may not use this file
16 : : * except in compliance with the License. You may obtain a copy of
17 : : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : : */
19 : :
20 : : #ifndef INCLUDED_BASEBMP_ACCESSORADAPTERS_HXX
21 : : #define INCLUDED_BASEBMP_ACCESSORADAPTERS_HXX
22 : :
23 : : #include <vigra/numerictraits.hxx>
24 : :
25 : : namespace basebmp
26 : : {
27 : :
28 : : /** Interpose given accessor's set and get methods with two unary
29 : : functors.
30 : :
31 : : @tpl WrappedAccessor
32 : : Wrapped type must provide the usual get and set accessor methods,
33 : : with the usual signatures (see StandardAccessor for a conforming
34 : : example).
35 : :
36 : : @tpl GetterFunctor
37 : : An Adaptable Unary Function (i.e. providing result_type and
38 : : argument_type typedefs)
39 : :
40 : : @tpl SetterFunctor
41 : : An Adaptable Unary Function (i.e. providing result_type and
42 : : argument_type typedefs)
43 : : */
44 : : template< class WrappedAccessor,
45 : : typename GetterFunctor,
46 : : typename SetterFunctor > class UnaryFunctionAccessorAdapter
47 : : {
48 : : public:
49 : : typedef typename GetterFunctor::result_type value_type;
50 : : typedef typename SetterFunctor::argument_type argument_type;
51 : :
52 : : #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
53 : : // making all members public, if no member template friends
54 : : private:
55 : : template<class A, typename G, typename S> friend class UnaryFunctionAccessorAdapter;
56 : : #endif
57 : :
58 : : // we don't derive from wrapped type, to avoid ambiguities
59 : : // regarding templatized getter/setter methods.
60 : : WrappedAccessor maAccessor;
61 : : GetterFunctor maGetterFunctor;
62 : : SetterFunctor maSetterFunctor;
63 : :
64 : : public:
65 : 2867362 : UnaryFunctionAccessorAdapter() :
66 : : maAccessor(),
67 : : maGetterFunctor(),
68 : : maSetterFunctor()
69 : 2867362 : {}
70 : :
71 : : template< class A > explicit
72 : 8602086 : UnaryFunctionAccessorAdapter( UnaryFunctionAccessorAdapter< A,
73 : : GetterFunctor,
74 : : SetterFunctor > const& rSrc ) :
75 : : maAccessor( rSrc.maAccessor ),
76 : : maGetterFunctor( rSrc.maGetterFunctor ),
77 : 8602086 : maSetterFunctor( rSrc.maSetterFunctor )
78 : 8602086 : {}
79 : :
80 : : template< class T > explicit UnaryFunctionAccessorAdapter( T const& accessor ) :
81 : : maAccessor( accessor ),
82 : : maGetterFunctor(),
83 : : maSetterFunctor()
84 : : {}
85 : :
86 : : template< class T > UnaryFunctionAccessorAdapter( T accessor,
87 : : GetterFunctor getterFunctor,
88 : : SetterFunctor setterFunctor) :
89 : : maAccessor( accessor ),
90 : : maGetterFunctor( getterFunctor ),
91 : : maSetterFunctor( setterFunctor )
92 : : {}
93 : :
94 : : // -------------------------------------------------------
95 : :
96 : : WrappedAccessor const& getWrappedAccessor() const { return maAccessor; }
97 : : WrappedAccessor& getWrappedAccessor() { return maAccessor; }
98 : :
99 : : // -------------------------------------------------------
100 : :
101 : : value_type getter(typename GetterFunctor::argument_type v) const
102 : : {
103 : : return maGetterFunctor(v);
104 : : }
105 : 5027814 : typename SetterFunctor::result_type setter(argument_type v) const
106 : : {
107 : 5027814 : return maSetterFunctor(v);
108 : : }
109 : :
110 : : // -------------------------------------------------------
111 : :
112 : : template< class Iterator >
113 : 193829113 : value_type operator()(Iterator const& i) const
114 : : {
115 [ + - ][ # # ]: 193829113 : return maGetterFunctor( maAccessor(i) );
[ # # ][ # # ]
[ + - ][ + - ]
116 : : }
117 : :
118 : : template< class Iterator, class Difference >
119 : : value_type operator()(Iterator const& i, Difference const& diff) const
120 : : {
121 : : return maGetterFunctor( maAccessor(i,diff) );
122 : : }
123 : :
124 : : // -------------------------------------------------------
125 : :
126 : : template< typename V, class Iterator >
127 : 169911969 : void set(V const& value, Iterator const& i) const
128 : : {
129 [ # # ][ # # ]: 169911969 : maAccessor.set(
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ + - ]
[ # # ][ + - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ + - ]
[ # # ][ # # ]
[ # # ][ + - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ + - ]
[ # # ][ + - ]
[ # # ][ + - ]
[ # # ][ + - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
130 : : maSetterFunctor(
131 : : vigra::detail::RequiresExplicitCast<argument_type>::cast(value) ),
132 : : i );
133 : 169911969 : }
134 : :
135 : : template< typename V, class Iterator, class Difference >
136 : : void set(V const& value, Iterator const& i, Difference const& diff) const
137 : : {
138 : : maAccessor.set(
139 : : maSetterFunctor(
140 : : vigra::detail::RequiresExplicitCast<argument_type>::cast(value) ),
141 : : i,
142 : : diff );
143 : : }
144 : :
145 : : };
146 : :
147 : : //-----------------------------------------------------------------------------
148 : :
149 : : /** Interpose given accessor's set methods with a binary function,
150 : : taking both old and new value.
151 : :
152 : : The wrappee's getter methods kept as-is.
153 : :
154 : : @tpl WrappedAccessor
155 : : Wrapped type must provide the usual get and set accessor methods,
156 : : with the usual signatures (see StandardAccessor for a conforming
157 : : example). Furthermore, must provide a nested typedef value_type.
158 : :
159 : : @tpl SetterFunctor
160 : : An adaptable binary function (i.e. providing nested typedefs for
161 : : result_type and first and second argument type)
162 : : */
163 : : template< class WrappedAccessor,
164 : : typename SetterFunctor > class BinarySetterFunctionAccessorAdapter
165 : : {
166 : : public:
167 : : typedef typename WrappedAccessor::value_type value_type;
168 : : typedef typename SetterFunctor::second_argument_type argument_type;
169 : :
170 : : #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
171 : : // making all members public, if no member template friends
172 : : private:
173 : : template<class A, typename S> friend class BinarySetterFunctionAccessorAdapter;
174 : : #endif
175 : :
176 : : WrappedAccessor maAccessor;
177 : : SetterFunctor maFunctor;
178 : :
179 : : public:
180 : : BinarySetterFunctionAccessorAdapter() :
181 : : maAccessor(),
182 : : maFunctor()
183 : : {}
184 : :
185 : : template< class A > explicit
186 : : BinarySetterFunctionAccessorAdapter(
187 : : BinarySetterFunctionAccessorAdapter< A,
188 : : SetterFunctor > const& rSrc ) :
189 : : maAccessor( rSrc.maAccessor ),
190 : : maFunctor( rSrc.maFunctor )
191 : : {}
192 : :
193 : 12653067 : template< class T > explicit BinarySetterFunctionAccessorAdapter( T const& accessor ) :
194 : : maAccessor( accessor ),
195 : 6328087 : maFunctor()
196 : 12653067 : {}
197 : :
198 : : template< class T > BinarySetterFunctionAccessorAdapter( T accessor,
199 : : SetterFunctor functor ) :
200 : : maAccessor( accessor ),
201 : : maFunctor( functor )
202 : : {}
203 : :
204 : : // -------------------------------------------------------
205 : :
206 : : WrappedAccessor const& getWrappedAccessor() const { return maAccessor; }
207 : : WrappedAccessor& getWrappedAccessor() { return maAccessor; }
208 : :
209 : : // -------------------------------------------------------
210 : :
211 : : typename SetterFunctor::result_type setter(
212 : : typename SetterFunctor::first_argument_type v1,
213 : : argument_type v2 ) const
214 : : {
215 : : return maSetterFunctor(v1,v2);
216 : : }
217 : :
218 : : // -------------------------------------------------------
219 : :
220 : : template< class Iterator >
221 : 0 : value_type operator()(Iterator const& i) const
222 : : {
223 : 0 : return maAccessor(i);
224 : : }
225 : :
226 : : template< class Iterator, class Difference >
227 : : value_type operator()(Iterator const& i, Difference const& diff) const
228 : : {
229 : : return maAccessor(i,diff);
230 : : }
231 : :
232 : : // -------------------------------------------------------
233 : :
234 : : template< typename V, class Iterator >
235 : 57296590 : void set(V const& value, Iterator const& i) const
236 : : {
237 [ # # ][ # # ]: 57296590 : maAccessor.set(
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ # # ]
[ # # ][ # # ]
[ + - ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + - ][ + - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
238 : : maFunctor(maAccessor(i),
239 : : vigra::detail::RequiresExplicitCast<argument_type>::cast(value)),
240 : : i );
241 : 57296590 : }
242 : :
243 : : template< typename V, class Iterator, class Difference >
244 : : void set(V const& value, Iterator const& i, Difference const& diff) const
245 : : {
246 : : maAccessor.set(
247 : : maFunctor(maAccessor(i,diff),
248 : : vigra::detail::RequiresExplicitCast<argument_type>::cast(value)),
249 : : i,
250 : : diff );
251 : : }
252 : :
253 : : };
254 : :
255 : : //-----------------------------------------------------------------------------
256 : :
257 : : /** Write through a CompositeIterator's first wrapped iterator, by
258 : : piping the first wrapped iterator value, the second iterator
259 : : value, and the specified new value through a ternary function.
260 : :
261 : : Passed iterator must fulfill the CompositeIterator concept. Note
262 : : that the getter/setter methods are not templatized regarding the
263 : : iterator type, to make the mask calculation optimization below
264 : : safe (see the maskedAccessor template metafunction below)
265 : :
266 : : @tpl WrappedAccessor1
267 : : Wrapped type must provide the usual get and set accessor methods,
268 : : with the usual signatures (see StandardAccessor for a conforming
269 : : example). Furthermore, the type must provide a nested typedef
270 : : value_type (the selection of WrappedAccessor1 as the provider for
271 : : that typedef is rather arbitrary. Could have been
272 : : WrappedAccessor2, too. So sue me)
273 : :
274 : : @tpl Functor
275 : : An adaptable ternary function (i.e. providing nested typedefs for
276 : : result_type and first, second and third argument type)
277 : : */
278 : : template< class WrappedAccessor1,
279 : : class WrappedAccessor2,
280 : : typename Functor > class TernarySetterFunctionAccessorAdapter
281 : : {
282 : : public:
283 : : typedef typename WrappedAccessor1::value_type value_type;
284 : : typedef typename Functor::third_argument_type argument_type;
285 : :
286 : : #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
287 : : // making all members public, if no member template friends
288 : : private:
289 : : template<class A1, class A2, typename F> friend class TernarySetterFunctionAccessorAdapter;
290 : : #endif
291 : :
292 : : WrappedAccessor1 ma1stAccessor;
293 : : WrappedAccessor2 ma2ndAccessor;
294 : : Functor maFunctor;
295 : :
296 : : public:
297 : : TernarySetterFunctionAccessorAdapter() :
298 : : ma1stAccessor(),
299 : : ma2ndAccessor(),
300 : : maFunctor()
301 : : {}
302 : :
303 : 25299920 : template< class T > explicit TernarySetterFunctionAccessorAdapter( T const& accessor ) :
304 : : ma1stAccessor( accessor ),
305 : : ma2ndAccessor(),
306 : 3162490 : maFunctor()
307 : 25299920 : {}
308 : :
309 : : template< class A1, class A2 > explicit
310 : : TernarySetterFunctionAccessorAdapter(
311 : : TernarySetterFunctionAccessorAdapter< A1,
312 : : A2,
313 : : Functor > const& rSrc ) :
314 : : ma1stAccessor( rSrc.ma1stAccessor ),
315 : : ma2ndAccessor( rSrc.ma2ndAccessor ),
316 : : maFunctor( rSrc.maFunctor )
317 : : {}
318 : :
319 : : template< class T1, class T2 >
320 : : TernarySetterFunctionAccessorAdapter( T1 accessor1,
321 : : T2 accessor2 ) :
322 : : ma1stAccessor( accessor1 ),
323 : : ma2ndAccessor( accessor2 ),
324 : : maFunctor()
325 : : {}
326 : :
327 : : template< class T1, class T2 >
328 : : TernarySetterFunctionAccessorAdapter( T1 accessor1,
329 : : T2 accessor2,
330 : : Functor func ) :
331 : : ma1stAccessor( accessor1 ),
332 : : ma2ndAccessor( accessor2 ),
333 : : maFunctor( func )
334 : : {}
335 : :
336 : : // -------------------------------------------------------
337 : :
338 : : WrappedAccessor1 const& get1stWrappedAccessor() const { return ma1stAccessor; }
339 : 217 : WrappedAccessor1& get1stWrappedAccessor() { return ma1stAccessor; }
340 : :
341 : : WrappedAccessor2 const& get2ndWrappedAccessor() const { return ma2ndAccessor; }
342 : : WrappedAccessor2& get2ndWrappedAccessor() { return ma2ndAccessor; }
343 : :
344 : : // -------------------------------------------------------
345 : :
346 : : typename Functor::result_type setter(
347 : : typename Functor::first_argument_type v1,
348 : : typename Functor::second_argument_type v2,
349 : : argument_type v3 ) const
350 : : {
351 : : return maSetterFunctor(v1,v2,v3);
352 : : }
353 : :
354 : : // -------------------------------------------------------
355 : :
356 : : template< class Iterator >
357 : 265044 : value_type operator()(Iterator const& i) const
358 : : {
359 : 265044 : return ma1stAccessor(i.first());
360 : : }
361 : :
362 : : template< class Iterator, class Difference >
363 : : value_type operator()(Iterator const& i, Difference const& diff) const
364 : : {
365 : : return ma1stAccessor(i.second(),diff);
366 : : }
367 : :
368 : : // -------------------------------------------------------
369 : :
370 : : template< typename V, class Iterator >
371 : 201017342 : void set(V const& value, Iterator const& i) const
372 : : {
373 [ # # ][ # # ]: 201017342 : ma1stAccessor.set(
[ # # ][ + - ]
[ + - ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ # # ][ + - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ # # ]
[ + - ][ + - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ # # ]
[ + - ]
374 : : maFunctor(ma1stAccessor(i.first()),
375 : : ma2ndAccessor(i.second()),
376 : : vigra::detail::RequiresExplicitCast<argument_type>::cast(value)),
377 : : i.first() );
378 : 201017342 : }
379 : :
380 : : template< typename V, class Iterator, class Difference >
381 : : void set(V const& value, Iterator const& i, Difference const& diff) const
382 : : {
383 : : ma1stAccessor.set(
384 : : maFunctor(ma1stAccessor(i.first(), diff),
385 : : ma2ndAccessor(i.second(),diff),
386 : : vigra::detail::RequiresExplicitCast<argument_type>::cast(value)),
387 : : i.first(),
388 : : diff );
389 : : }
390 : :
391 : : };
392 : :
393 : : //-----------------------------------------------------------------------------
394 : :
395 : : /** Access two distinct images simultaneously
396 : :
397 : : Passed iterator must fulfill the CompositeIterator concept
398 : : (i.e. wrap the two image's iterators into one
399 : : CompositeIterator). The getter and setter methods expect and
400 : : return a pair of values, with types equal to the two accessors
401 : : value types
402 : :
403 : : @tpl WrappedAccessor1
404 : : Wrapped type must provide the usual get and set accessor methods,
405 : : with the usual signatures (see StandardAccessor for a conforming
406 : : example). Furthermore, the type must provide a nested typedef
407 : : value_type.
408 : :
409 : : @tpl WrappedAccessor2
410 : : Wrapped type must provide the usual get and set accessor methods,
411 : : with the usual signatures (see StandardAccessor for a conforming
412 : : example). Furthermore, the type must provide a nested typedef
413 : : value_type.
414 : : */
415 : : template< class WrappedAccessor1,
416 [ + - ][ + - ]: 347229 : class WrappedAccessor2 > class JoinImageAccessorAdapter
417 : : {
418 : : public:
419 : : // TODO(F3): Need numeric traits and a few free functions to
420 : : // actually calculate with a pair (semantic: apply every operation
421 : : // individually to the contained types)
422 : : typedef std::pair<typename WrappedAccessor1::value_type,
423 : : typename WrappedAccessor2::value_type> value_type;
424 : :
425 : : #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
426 : : // making all members public, if no member template friends
427 : : private:
428 : : template<class A1, class A2> friend class JoinImageAccessorAdapter;
429 : : #endif
430 : :
431 : : WrappedAccessor1 ma1stAccessor;
432 : : WrappedAccessor2 ma2ndAccessor;
433 : :
434 : : public:
435 : : JoinImageAccessorAdapter() :
436 : : ma1stAccessor(),
437 : : ma2ndAccessor()
438 : : {}
439 : :
440 : : template< class T > explicit JoinImageAccessorAdapter( T const& accessor ) :
441 : : ma1stAccessor( accessor ),
442 : : ma2ndAccessor()
443 : : {}
444 : :
445 : : template< class A1, class A2 > explicit
446 : : JoinImageAccessorAdapter(
447 : : JoinImageAccessorAdapter< A1,
448 : : A2 > const& rSrc ) :
449 : : ma1stAccessor( rSrc.ma1stAccessor ),
450 : : ma2ndAccessor( rSrc.ma2ndAccessor )
451 : : {}
452 : :
453 : : template< class T1, class T2 >
454 : 3107 : JoinImageAccessorAdapter( T1 accessor1,
455 : : T2 accessor2 ) :
456 : : ma1stAccessor( accessor1 ),
457 [ + - ]: 3087 : ma2ndAccessor( accessor2 )
458 : 3107 : {}
459 : :
460 : : // -------------------------------------------------------
461 : :
462 : : WrappedAccessor1 const& get1stWrappedAccessor() const { return ma1stAccessor; }
463 : : WrappedAccessor1& get1stWrappedAccessor() { return ma1stAccessor; }
464 : :
465 : : WrappedAccessor2 const& get2ndWrappedAccessor() const { return ma2ndAccessor; }
466 : : WrappedAccessor2& get2ndWrappedAccessor() { return ma2ndAccessor; }
467 : :
468 : : // -------------------------------------------------------
469 : :
470 : : template< class Iterator >
471 : 25343782 : value_type operator()(Iterator const& i) const
472 : : {
473 : : return std::make_pair(ma1stAccessor(i.first()),
474 [ # # ][ + - ]: 25343782 : ma2ndAccessor(i.second()));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ + - ]
[ # # ][ # # ]
[ + - ][ # # ]
[ # # ][ + - ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ + - ]
[ # # ][ # # ]
[ # # ][ # # ]
475 : : }
476 : :
477 : : template< class Iterator, class Difference >
478 : : value_type operator()(Iterator const& i, Difference const& diff) const
479 : : {
480 : : return std::make_pair(ma1stAccessor(i.first(),diff),
481 : : ma2ndAccessor(i.second(),diff));
482 : : }
483 : :
484 : : // -------------------------------------------------------
485 : :
486 : : template< typename V, class Iterator >
487 : : void set(V const& value, Iterator const& i) const
488 : : {
489 : : ma1stAccessor.set(
490 : : vigra::detail::RequiresExplicitCast<typename WrappedAccessor1::value_type>::cast(
491 : : value.first),
492 : : i.first() );
493 : : ma2ndAccessor.set(
494 : : vigra::detail::RequiresExplicitCast<typename WrappedAccessor2::value_type>::cast(
495 : : value.second),
496 : : i.second() );
497 : : }
498 : :
499 : : template< typename V, class Iterator, class Difference >
500 : : void set(V const& value, Iterator const& i, Difference const& diff) const
501 : : {
502 : : ma1stAccessor.set(
503 : : vigra::detail::RequiresExplicitCast<typename WrappedAccessor1::value_type>::cast(
504 : : value.first),
505 : : i.first(),
506 : : diff );
507 : : ma2ndAccessor.set(
508 : : vigra::detail::RequiresExplicitCast<typename WrappedAccessor2::value_type>::cast(
509 : : value.second),
510 : : i.second(),
511 : : diff );
512 : : }
513 : :
514 : : };
515 : :
516 : : } // namespace basebmp
517 : :
518 : : #endif /* INCLUDED_BASEBMP_ACCESSORADAPTERS_HXX */
519 : :
520 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
