From b80c937dc6b8d3a6a511f5fc82b0ab7e2172c9d1 Mon Sep 17 00:00:00 2001 From: Jens-Heiner Rechtien Date: Wed, 27 Jun 2007 11:15:38 +0000 Subject: INTEGRATION: CWS awttree01 (1.1.2); FILE ADDED 2007/05/21 13:36:16 thb 1.1.2.2: #i10000# Made this work for gcc3.x 2007/04/25 12:10:11 thb 1.1.2.1: #i75289# Added caching helper, to easy lazy update behaviour in XSimpleCanvas implementation --- o3tl/inc/o3tl/lazy_update.hxx | 279 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 279 insertions(+) create mode 100644 o3tl/inc/o3tl/lazy_update.hxx (limited to 'o3tl') diff --git a/o3tl/inc/o3tl/lazy_update.hxx b/o3tl/inc/o3tl/lazy_update.hxx new file mode 100644 index 000000000000..8479f522f91e --- /dev/null +++ b/o3tl/inc/o3tl/lazy_update.hxx @@ -0,0 +1,279 @@ +/************************************************************************* + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: lazy_update.hxx,v $ + * + * $Revision: 1.2 $ + * + * last change: $Author: hr $ $Date: 2007-06-27 12:15:38 $ + * + * The Contents of this file are made available subject to + * the terms of GNU Lesser General Public License Version 2.1. + * + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2005 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + ************************************************************************/ + +#ifndef INCLUDED_O3TL_LAZY_UPDATE_HXX +#define INCLUDED_O3TL_LAZY_UPDATE_HXX + +#include +#include + +namespace o3tl +{ + /** Update output object lazily + + This template collects data in input type, and updates the + output type with the given update functor, but only if the + output is requested. Usefúl if updating is expensive, or input + changes frequently, but output is only comparatively seldom + used. + + @example + 
+LazyUpdate myValue;
+*myValue = newInput;
+myValue->updateInput( this, that, those );
+
+output( *myValue );
+
+ or + 
+output( myValue.getOutValue() );
+
+ if the compiler does not recognize the const context. + */ + template< typename InputType, typename OutputType, typename Tag > class LazyUpdate; + + /// LazyUpdate specialization takes boost::function argument + struct LAZYUPDATE_FUNCTOR_TAG {}; + /// LazyUpdate specialization takes OutputType (*FunctionType)( InputType const& ) argument + struct LAZYUPDATE_FUNCTION_TAG {}; + /// LazyUpdate specialization can directly convert, OutputType ctor must take InputType argument + struct LAZYUPDATE_DIRECT_TAG {}; + + // ----------------------------------------------------------------------------------------------------- + + namespace detail + { + /// @internal + template< typename InputType, typename OutputType, typename Functor > class LazyUpdateImpl : private Functor + { + public: + typedef OutputType output_type; + typedef InputType input_type; + + LazyUpdateImpl() : + m_aInput() + {} + + template< typename ParamType > explicit LazyUpdateImpl( ParamType const& rParm ) : + Functor(rParm), + m_aInput() + {} + + enum UnaryConstructorTag{ UNARY_CONSTRUCTOR_TAG }; + LazyUpdateImpl( const input_type& rInput, UnaryConstructorTag ) : + m_aInput(rInput) + {} + + template< typename ParamType > LazyUpdateImpl( ParamType const& rParm, + const input_type& rInput ) : + Functor(rParm), + m_aInput(rInput) + {} + + // default copy ctor/assignment operator are ok + // LazyUpdate( const LazyUpdate& ); + // LazyUpdate& operator=( const LazyUpdate& ); + + void setInValue( input_type const& rIn ) { Functor::m_bCacheDirty = true; m_aInput = rIn; } + input_type const& getInValue() const { return m_aInput; } + output_type const& getOutValue() const { return implUpdateValue(m_aInput); } + + input_type& operator*() { Functor::m_bCacheDirty = true; return m_aInput; } + input_type* operator->() { Functor::m_bCacheDirty = true; return &m_aInput; } + + output_type const& operator*() const { return implUpdateValue(m_aInput); } + output_type const* operator->() const { return &implUpdateValue(m_aInput); } + + private: + input_type m_aInput; + }; + + template< typename InputType, typename OutputType > struct DefaultFunctor + { + protected: + typedef OutputType output_type; + typedef InputType input_type; + + DefaultFunctor() : + m_aOutput(), + m_bCacheDirty(true) + {} + + OutputType const& implUpdateValue( input_type const& rIn ) const + { + if( m_bCacheDirty ) + { + m_aOutput = output_type( rIn ); + m_bCacheDirty = false; + } + + return m_aOutput; + } + + mutable output_type m_aOutput; + mutable bool m_bCacheDirty; // when true, m_aOutput needs update + }; + + template< typename InputType, typename OutputType, typename FunctionType > struct FunctionPointer + { + protected: + typedef OutputType output_type; + typedef InputType input_type; + typedef FunctionType function_type; + + FunctionPointer() : + m_pFunc(), + m_aOutput(), + m_bCacheDirty(true) + + {} + + explicit FunctionPointer( function_type const& pFunc ) : + m_pFunc(pFunc), + m_aOutput(), + m_bCacheDirty(true) + + {} + + output_type const& implUpdateValue( input_type const& rIn ) const + { + if( m_bCacheDirty ) + { + m_aOutput = m_pFunc( rIn ); + m_bCacheDirty = false; + } + + return m_aOutput; + } + + function_type m_pFunc; + mutable output_type m_aOutput; + mutable bool m_bCacheDirty; // when true, m_aOutput needs update + }; + } + + // ----------------------------------------------------------------------------------------------------- + + // partial specializations for the three LAZYUPDATE_* tags + + template< typename InputType, typename OutputType > class LazyUpdate : + public detail::LazyUpdateImpl > + { + public: + LazyUpdate() {} + explicit LazyUpdate( InputType const& rIn ) : + detail::LazyUpdateImpl >( + rIn, + detail::LazyUpdateImpl< + InputType, + OutputType, + detail::DefaultFunctor >::UNARY_CONSTRUCTOR_TAG ) + {} + }; + + // ----------------------------------------------------------------------------------------------------- + + template< typename InputType, typename OutputType > class LazyUpdate : + public detail::LazyUpdateImpl > + { + public: + explicit LazyUpdate( OutputType (*pFunc)( InputType const& ) ) : + detail::LazyUpdateImpl >(pFunc) + {} + LazyUpdate( OutputType (*pFunc)( InputType const& ), + InputType const& rIn ) : + detail::LazyUpdateImpl >(pFunc,rIn) + {} + }; + + // ----------------------------------------------------------------------------------------------------- + + template< typename InputType, typename OutputType > class LazyUpdate : + public detail::LazyUpdateImpl > > + { + public: + explicit LazyUpdate( boost::function1 const& rFunc ) : + detail::LazyUpdateImpl > >(rFunc) + {} + LazyUpdate( boost::function1 const& rFunc, + InputType const& rIn ) : + detail::LazyUpdateImpl > >(rFunc,rIn) + {} + }; + +} + +#endif /* INCLUDED_O3TL_LAZY_UPDATE_HXX */ -- cgit