ImageCachePolicies.h

#pragma once

#if defined(ImageCachePolicies_RECURSES)
#error Recursive header files inclusion detected in ImageCachePolicies.h
#else // defined(ImageCachePolicies_RECURSES)

#define ImageCachePolicies_RECURSES

#if !defined ImageCachePolicies_h

#define ImageCachePolicies_h

// Inclusions
#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/base/ConceptUtils.h"
#include "DGtal/images/CImage.h"
#include "DGtal/images/CImageFactory.h"
#include "DGtal/base/Alias.h"

#include "DGtal/images/ImageCache.h"

namespace DGtal
{

// Template class ImageCacheReadPolicyLAST
template <typename TImageContainer, typename TImageFactory>
class ImageCacheReadPolicyLAST
{
public:
  
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));    
    
    typedef TImageFactory ImageFactory;
    
    typedef TImageContainer ImageContainer;
    typedef typename TImageContainer::Domain Domain;
    typedef typename TImageContainer::Point Point;
    typedef typename TImageContainer::Value Value;
    
    ImageCacheReadPolicyLAST(Alias<ImageFactory> anImageFactory):
      myCacheImagesPtr(NULL),  myImageFactory(&anImageFactory)
    {
    }

    ~ImageCacheReadPolicyLAST() {}
    
private:
    
    ImageCacheReadPolicyLAST( const ImageCacheReadPolicyLAST & other );
    
    ImageCacheReadPolicyLAST & operator=( const ImageCacheReadPolicyLAST & other );
    
public:
    
    ImageContainer * getPage(const Point & aPoint);
    
    ImageContainer * getPage(const Domain & aDomain);
    
    ImageContainer * getPageToDetach();
    
    void updateCache(const Domain &aDomain);
    
    void clearCache();
    
protected:
    
    ImageContainer * myCacheImagesPtr;
    
    ImageFactory * myImageFactory;
    
}; // end of class ImageCacheReadPolicyLAST

// Template class ImageCacheReadPolicyFIFO
template <typename TImageContainer, typename TImageFactory>
class ImageCacheReadPolicyFIFO
{
public:
  
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));    
    
    typedef TImageFactory ImageFactory;
    
    typedef TImageContainer ImageContainer;
    typedef typename TImageContainer::Domain Domain;
    typedef typename TImageContainer::Point Point;
    typedef typename TImageContainer::Value Value;
    
    ImageCacheReadPolicyFIFO(Alias<ImageFactory> anImageFactory, int aFIFOSizeMax=10):
       myFIFOSizeMax(aFIFOSizeMax), myImageFactory(&anImageFactory)
    {
    }

    ~ImageCacheReadPolicyFIFO() {}
    
private:
    
    ImageCacheReadPolicyFIFO( const ImageCacheReadPolicyFIFO & other );
    
    ImageCacheReadPolicyFIFO & operator=( const ImageCacheReadPolicyFIFO & other );
    
public:
    
    ImageContainer * getPage(const Point & aPoint);
    
    ImageContainer * getPage(const Domain & aDomain);
    
    ImageContainer * getPageToDetach();
    
    void updateCache(const Domain &aDomain);
    
    void clearCache();
    
protected:
    
    std::deque <ImageContainer *> myFIFOCacheImages;
    
    unsigned int myFIFOSizeMax;
    
    ImageFactory * myImageFactory;
    
}; // end of class ImageCacheReadPolicyFIFO

// Template class ImageCacheWritePolicyWT
template <typename TImageContainer, typename TImageFactory>
class ImageCacheWritePolicyWT
{
public:
  
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));
  
    typedef TImageFactory ImageFactory;
    
    typedef TImageContainer ImageContainer;
    typedef typename TImageContainer::Domain Domain;
    typedef typename TImageContainer::Point Point;
    typedef typename TImageContainer::Value Value;
    
    ImageCacheWritePolicyWT(Alias<ImageFactory> anImageFactory):
      myImageFactory(&anImageFactory)
    {
    }

    ~ImageCacheWritePolicyWT() {}
    
private:
    
    ImageCacheWritePolicyWT( const ImageCacheWritePolicyWT & other );
    
    ImageCacheWritePolicyWT & operator=( const ImageCacheWritePolicyWT & other );
    
public:
    
    void writeInPage(ImageContainer * anImageContainer, const Point & aPoint, const Value &aValue);
    
    void flushPage(ImageContainer * anImageContainer);
    
protected:
    
    ImageFactory * myImageFactory;
    
}; // end of class ImageCacheWritePolicyWT

// Template class ImageCacheWritePolicyWB
template <typename TImageContainer, typename TImageFactory>
class ImageCacheWritePolicyWB
{
public:
  
    BOOST_CONCEPT_ASSERT(( concepts::CImage<TImageContainer> ));
    BOOST_CONCEPT_ASSERT(( concepts::CImageFactory<TImageFactory> ));
  
    typedef TImageFactory ImageFactory;
    
    typedef TImageContainer ImageContainer;
    typedef typename TImageContainer::Domain Domain;
    typedef typename TImageContainer::Point Point;
    typedef typename TImageContainer::Value Value;
    
    ImageCacheWritePolicyWB(Alias<ImageFactory> anImageFactory):
      myImageFactory(&anImageFactory)
    {
    }

    ~ImageCacheWritePolicyWB() {}
    
private:
    
    ImageCacheWritePolicyWB( const ImageCacheWritePolicyWB & other );
    
    ImageCacheWritePolicyWB & operator=( const ImageCacheWritePolicyWB & other );
    
public:
    
    void writeInPage(ImageContainer * anImageContainer, const Point & aPoint, const Value &aValue);
    
    void flushPage(ImageContainer * anImageContainer);
    
protected:
    
    ImageFactory * myImageFactory;
    
}; // end of class ImageCacheWritePolicyWB

} // namespace DGtal


// Includes inline functions.
#include "DGtal/images/ImageCachePolicies.ih"

//                                                                           //

#endif // !defined ImageCachePolicies_h

#undef ImageCachePolicies_RECURSES
#endif // else defined(ImageCachePolicies_RECURSES)