include/o3tl/lazy_update.hxx

   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_O3TL_LAZY_UPDATE_HXX
  21 #define INCLUDED_O3TL_LAZY_UPDATE_HXX
  22
  23 #include <sal/types.h>
  24 #include <boost/function.hpp>
  25
  26 namespace o3tl
  27 {
  28     /** Update output object lazily
  29
  30         This template collects data in input type, and updates the
  31         output type with the given update functor, but only if the
  32         output is requested. Usefúl if updating is expensive, or input
  33         changes frequently, but output is only comparatively seldom
  34         used.
  35
  36         @example
  37         <pre>
  38 LazyUpdate<InType,OutType,LAZYUPDATE_DIRECT_TAG> myValue;
  39 *myValue = newInput;
  40 myValue->updateInput( this, that, those );
  41
  42 output( *myValue );
  43         </pre>
  44         or
  45         <pre>
  46 output( myValue.getOutValue() );
  47         </pre>
  48         if the compiler does not recognize the const context.
  49      */
  50     template< typename InputType, typename OutputType, typename Tag > class LazyUpdate;
  51
  52     /// LazyUpdate specialization takes boost::function argument
  53     struct LAZYUPDATE_FUNCTOR_TAG       {};
  54     /// LazyUpdate specialization takes OutputType (*FunctionType)( InputType const& ) argument
  55     struct LAZYUPDATE_FUNCTION_TAG      {};
  56     /// LazyUpdate specialization can directly convert, OutputType ctor must take InputType argument
  57     struct LAZYUPDATE_DIRECT_TAG  {};
  58
  59     // -----------------------------------------------------------------------------------------------------
  60
  61     namespace detail
  62     {
  63         /// @internal
  64         template< typename InputType, typename OutputType, typename Functor > class LazyUpdateImpl : private Functor
  65         {
  66         public:
  67             typedef OutputType output_type;
  68             typedef InputType  input_type;
  69
  70             LazyUpdateImpl() :
  71                 m_aInput()
  72             {}
  73
  74             template< typename ParamType > explicit LazyUpdateImpl( ParamType const& rParm ) :
  75                 Functor(rParm),
  76                 m_aInput()
  77             {}
  78
  79             enum UnaryConstructorTag{ UNARY_CONSTRUCTOR_TAG };
  80             LazyUpdateImpl( const input_type& rInput, UnaryConstructorTag ) :
  81                 m_aInput(rInput)
  82             {}
  83
  84             template< typename ParamType > LazyUpdateImpl( ParamType const&  rParm,
  85                                                            const input_type& rInput ) :
  86                 Functor(rParm),
  87                 m_aInput(rInput)
  88             {}
  89
  90             // default copy ctor/assignment operator are ok
  91             // LazyUpdate( const LazyUpdate& );
  92             // LazyUpdate& operator=( const LazyUpdate& );
  93
  94             void               setInValue( input_type const& rIn ) { Functor::m_bCacheDirty = true; m_aInput = rIn; }
  95             input_type const&  getInValue()  const                 { return m_aInput; }
  96             output_type const& getOutValue() const                 { return this->implUpdateValue(m_aInput); }
  97
  98             input_type& operator*()  { Functor::m_bCacheDirty = true; return m_aInput;  }
  99             input_type* operator->() { Functor::m_bCacheDirty = true; return &m_aInput; }
 100
 101             output_type const& operator*() const  { return this->implUpdateValue(m_aInput);  }
 102             output_type const* operator->() const { return &(this->implUpdateValue(m_aInput)); }
 103
 104         private:
 105             input_type m_aInput;
 106         };
 107
 108         template< typename InputType, typename OutputType > struct DefaultFunctor
 109         {
 110         protected:
 111             typedef OutputType output_type;
 112             typedef InputType  input_type;
 113
 114             DefaultFunctor() :
 115                 m_aOutput(),
 116                 m_bCacheDirty(true)
 117             {}
 118
 119             OutputType const& implUpdateValue( input_type const& rIn ) const
 120             {
 121                 if( m_bCacheDirty )
 122                 {
 123                     m_aOutput = output_type( rIn );
 124                     m_bCacheDirty = false;
 125                 }
 126
 127                 return m_aOutput;
 128             }
 129
 130             mutable output_type m_aOutput;
 131             mutable bool        m_bCacheDirty; // when true, m_aOutput needs update
 132         };
 133
 134         template< typename InputType, typename OutputType, typename FunctionType > struct FunctionPointer
 135         {
 136         protected:
 137             typedef OutputType   output_type;
 138             typedef InputType    input_type;
 139             typedef FunctionType function_type;
 140
 141             FunctionPointer() :
 142                 m_pFunc(),
 143                 m_aOutput(),
 144                 m_bCacheDirty(true)
 145
 146             {}
 147
 148             explicit FunctionPointer( function_type const& pFunc ) :
 149                 m_pFunc(pFunc),
 150                 m_aOutput(),
 151                 m_bCacheDirty(true)
 152
 153             {}
 154
 155             output_type const& implUpdateValue( input_type const& rIn ) const
 156             {
 157                 if( m_bCacheDirty )
 158                 {
 159                     m_aOutput = m_pFunc( rIn );
 160                     m_bCacheDirty = false;
 161                 }
 162
 163                 return m_aOutput;
 164             }
 165
 166             function_type       m_pFunc;
 167             mutable output_type m_aOutput;
 168             mutable bool        m_bCacheDirty; // when true, m_aOutput needs update
 169         };
 170     }
 171
 172     // -----------------------------------------------------------------------------------------------------
 173
 174     // partial specializations for the three LAZYUPDATE_* tags
 175
 176     template< typename InputType, typename OutputType > class LazyUpdate<InputType,
 177                                                                          OutputType,
 178                                                                          LAZYUPDATE_DIRECT_TAG> :
 179         public detail::LazyUpdateImpl<InputType,
 180                                       OutputType,
 181                                       detail::DefaultFunctor<InputType, OutputType> >
 182     {
 183     public:
 184         LazyUpdate() {}
 185         explicit LazyUpdate( InputType const& rIn ) :
 186             detail::LazyUpdateImpl<InputType,
 187                                    OutputType,
 188                                    detail::DefaultFunctor<InputType, OutputType> >(
 189                                        rIn,
 190                                        detail::LazyUpdateImpl<
 191                                             InputType,
 192                                             OutputType,
 193                                             detail::DefaultFunctor<InputType, OutputType> >::UNARY_CONSTRUCTOR_TAG )
 194         {}
 195     };
 196
 197     // -----------------------------------------------------------------------------------------------------
 198
 199     template< typename InputType, typename OutputType > class LazyUpdate<InputType,
 200                                                                          OutputType,
 201                                                                          LAZYUPDATE_FUNCTION_TAG> :
 202         public detail::LazyUpdateImpl<InputType,
 203                                       OutputType,
 204                                       detail::FunctionPointer<
 205                                           InputType,
 206                                           OutputType,
 207                                           OutputType (*)( InputType const& ) > >
 208     {
 209     public:
 210         explicit LazyUpdate( OutputType (*pFunc)( InputType const& ) ) :
 211             detail::LazyUpdateImpl<InputType,
 212                                    OutputType,
 213                                    detail::FunctionPointer<
 214                                        InputType,
 215                                        OutputType,
 216                                        OutputType (*)( InputType const& )> >(pFunc)
 217         {}
 218         LazyUpdate( OutputType (*pFunc)( InputType const& ),
 219                     InputType const& rIn ) :
 220             detail::LazyUpdateImpl<InputType,
 221                                    OutputType,
 222                                    detail::FunctionPointer<
 223                                        InputType,
 224                                        OutputType,
 225                                        OutputType (*)( InputType const& )> >(pFunc,rIn)
 226         {}
 227     };
 228
 229     // -----------------------------------------------------------------------------------------------------
 230
 231     template< typename InputType, typename OutputType > class LazyUpdate<InputType,
 232                                                                          OutputType,
 233                                                                          LAZYUPDATE_FUNCTOR_TAG> :
 234         public detail::LazyUpdateImpl<InputType,
 235                                       OutputType,
 236                                       detail::FunctionPointer<
 237                                           InputType,
 238                                           OutputType,
 239                                           boost::function1<OutputType,InputType> > >
 240     {
 241     public:
 242         explicit LazyUpdate( boost::function1<OutputType,InputType> const& rFunc ) :
 243             detail::LazyUpdateImpl<InputType,
 244                                    OutputType,
 245                                    detail::FunctionPointer<
 246                                        InputType,
 247                                        OutputType,
 248                                        boost::function1<OutputType,InputType> > >(rFunc)
 249         {}
 250         LazyUpdate( boost::function1<OutputType,InputType> const& rFunc,
 251                     InputType const& rIn ) :
 252             detail::LazyUpdateImpl<InputType,
 253                                    OutputType,
 254                                    detail::FunctionPointer<
 255                                        InputType,
 256                                        OutputType,
 257                                        boost::function1<OutputType,InputType> > >(rFunc,rIn)
 258         {}
 259     };
 260
 261 }
 262
 263 #endif /* INCLUDED_O3TL_LAZY_UPDATE_HXX */
 264
 265 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */