#include <tileviewstate.hh>

Inheritance diagram for TileViewState:

Collaboration diagram for TileViewState:

Public Types
enum	State { INIT , LOADED , COMPUTING_BASE , BASE_COMPUTED , COMPUTING_ZOOM , ZOOM_COMPUTED , DONE }

using	Ptr = std::shared_ptr< TileViewState >

using	WeakPtr = std::weak_ptr< TileViewState >

Public Types inherited from Scroom::Utils::Observable< TileLoadingObserver >
using	Observer = std::shared_ptr< TileLoadingObserver >

using	Ptr = std::shared_ptr< Observable< TileLoadingObserver > >

Public Types inherited from TileLoadingObserver
using	Ptr = std::shared_ptr< TileLoadingObserver >

using	WeakPtr = std::weak_ptr< TileLoadingObserver >

Public Member Functions
	~TileViewState () override

	TileViewState (const TileViewState &)=delete

	TileViewState (TileViewState &&)=delete

TileViewState	operator= (const TileViewState &)=delete

TileViewState	operator= (TileViewState &&)=delete

Scroom::Utils::Stuff	getCacheResult ()

void	setViewData (const std::shared_ptr< TiledBitmapViewData > &tbvd)

void	setZoom (LayerOperations::Ptr lo, int zoom)

void	tileLoaded (ConstTile::Ptr tile) override

Public Member Functions inherited from Scroom::Utils::Observable< TileLoadingObserver >
	Observable ()

	Observable (const Observable &)=delete

	Observable (Observable &&)=delete

	~Observable () override

Observable	operator= (const Observable &)=delete

Observable	operator= (Observable &&)=delete

Scroom::Bookkeeping::Token	registerStrongObserver (Observer const &observer)

Scroom::Bookkeeping::Token	registerObserver (ObserverWeak const &observer)

Public Member Functions inherited from Scroom::Utils::Base
	Base ()=default

	Base (const Base &)=delete

	Base (Base &&)=delete

Base &	operator= (const Base &)=delete

Base &	operator= (Base &&)=delete

virtual	~Base ()=default

template<typename R >
std::shared_ptr< R >	shared_from_this ()

template<typename R >
std::shared_ptr< R const >	shared_from_this () const

Static Public Member Functions
static Ptr	create (const std::shared_ptr< CompressedTile > &parent)

Private Member Functions
	TileViewState (std::shared_ptr< CompressedTile > parent)

void	kick ()

void	process (const ThreadPool::WeakQueue::Ptr &wq)

void	computeBase (const ThreadPool::WeakQueue::Ptr &wq, const ConstTile::Ptr &tile_, const LayerOperations::Ptr &lo_)

void	computeZoom (const ThreadPool::WeakQueue::Ptr &wq, const ConstTile::Ptr &tile, const LayerOperations::Ptr &lo, Scroom::Utils::Stuff baseCache, int zoom)

void	reportDone (const ThreadPool::WeakQueue::Ptr &wq, const ConstTile::Ptr &tile)

void	clear ()

Private Attributes
std::shared_ptr< CompressedTile >	parent

boost::mutex	mut

State	state {INIT}

State	desiredState {LOADED}

ThreadPool::Queue::Ptr	queue

ThreadPool::WeakQueue::Ptr	weakQueue

Scroom::Utils::Stuff	r

ConstTile::Ptr	tile

std::weak_ptr< TiledBitmapViewData >	tbvd

LayerOperations::Ptr	lo

int	zoom {0}

Scroom::Utils::StuffWeak	lifeTimeManager

Scroom::Utils::Stuff	baseCache

Scroom::Utils::Stuff	zoomCache

ThreadPool::Ptr	cpuBound

Additional Inherited Members
Protected Member Functions inherited from Scroom::Utils::Observable< TileLoadingObserver >
std::list< Observer >	getObservers ()

virtual void	observerAdded (Observer const &observer, Scroom::Bookkeeping::Token const &token)

Member Typedef Documentation

◆ Ptr

using TileViewState::Ptr = std::shared_ptr<TileViewState>

◆ WeakPtr

using TileViewState::WeakPtr = std::weak_ptr<TileViewState>

Member Enumeration Documentation

◆ State

enum TileViewState::State

Enumerator
INIT
LOADED
COMPUTING_BASE
BASE_COMPUTED
COMPUTING_ZOOM
ZOOM_COMPUTED
DONE

  {
    INIT,
    LOADED,
    COMPUTING_BASE,
    BASE_COMPUTED,
    COMPUTING_ZOOM,
    ZOOM_COMPUTED,
    DONE
  };

Constructor & Destructor Documentation

◆ ~TileViewState()

TileViewState::~TileViewState ( )

override

24{ r.reset(); }

TileViewState::r

Scroom::Utils::Stuff r

Definition tileviewstate.hh:50

◆ TileViewState() [1/3]

TileViewState::TileViewState ( const TileViewState & )

delete

◆ TileViewState() [2/3]

TileViewState::TileViewState ( TileViewState && )

delete

◆ TileViewState() [3/3]

TileViewState::TileViewState ( std::shared_ptr< CompressedTile > parent )

explicitprivate

  : parent(std::move(parent_))
  , cpuBound(CpuBound())
{
}

Member Function Documentation

◆ clear()

void TileViewState::clear ( )

private

{
  boost::mutex::scoped_lock const l(mut);
 
  if(state >= LOADED)
  {
    state = LOADED;
  }
 
  queue.reset();
  weakQueue.reset();
  lifeTimeManager.reset();
  baseCache.reset();
  zoomCache.reset();
 
  kick();
}

Here is the call graph for this function:

◆ computeBase()

void TileViewState::computeBase	(	const ThreadPool::WeakQueue::Ptr &	wq,
		const ConstTile::Ptr &	tile_,
		const LayerOperations::Ptr &	lo_
	)

private

{
  Scroom::Utils::Stuff const baseCache_ = lo_->cache(tile_);
 
  boost::mutex::scoped_lock const l(mut);
  TiledBitmapViewData::Ptr const tbvd_ = tbvd.lock();
 
  if(tbvd_ && desiredState >= BASE_COMPUTED && weakQueue == wq)
  {
    baseCache = baseCache_;
    state = BASE_COMPUTED;
  }
}

◆ computeZoom()

void TileViewState::computeZoom	(	const ThreadPool::WeakQueue::Ptr &	wq,
		const ConstTile::Ptr &	tile,
		const LayerOperations::Ptr &	lo,
		Scroom::Utils::Stuff	baseCache,
		int	zoom
	)

private

{
  Scroom::Utils::Stuff const zoomCache_ = lo_->cacheZoom(tile_, zoom_, baseCache_);
 
  boost::mutex::scoped_lock const l(mut);
  TiledBitmapViewData::Ptr const tbvd_ = tbvd.lock();
  if(tbvd_ && desiredState >= ZOOM_COMPUTED && zoom == zoom_ && weakQueue == wq)
  {
    zoomCache = zoomCache_;
    state = ZOOM_COMPUTED;
  }
}

◆ create()

TileViewState::Ptr TileViewState::create ( const std::shared_ptr< CompressedTile > & parent )

static

{
  TileViewState::Ptr result(new TileViewState(parent));
 
  result->r = parent->registerObserver(result);
 
  return result;
}

Referenced by CompressedTile::getViewState().

Here is the caller graph for this function:

◆ getCacheResult()

Scroom::Utils::Stuff TileViewState::getCacheResult ( )

{
  boost::mutex::scoped_lock const l(mut);
  return zoomCache;
}

◆ kick()

void TileViewState::kick ( )

private

Kick the internal state machine into making some progress

{
  if(state >= LOADED && !tile)
  {
    defect_message("PANIC: State LOADED and no tile shouldn't happen.");
  }
 
  TiledBitmapViewData::Ptr const tbvd_ = tbvd.lock();
 
  if(state >= LOADED && desiredState >= state && !queue && tbvd_)
  {
    queue = ThreadPool::Queue::createAsync();
    weakQueue = queue->getWeak();
 
    cpuBound->schedule(
      [me = shared_from_this<TileViewState>(), weakQueue = weakQueue] { me->process(weakQueue); }, LOAD_PRIO, queue
    );
  }
}

Referenced by clear(), setViewData(), setZoom(), and tileLoaded().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

TileViewState TileViewState::operator= ( const TileViewState & )

delete

◆ operator=() [2/2]

TileViewState TileViewState::operator= ( TileViewState && )

delete

◆ process()

void TileViewState::process ( const ThreadPool::WeakQueue::Ptr & wq )

private

Asynchronously do work to make the state machine progress

{
  for(;;)
  {
    boost::mutex::scoped_lock l(mut);
 
    if(wq == weakQueue && state < desiredState)
    {
      boost::function<void()> fn;
 
      switch(state)
      {
      case LOADED:
        fn = [me = shared_from_this<TileViewState>(), wq, tile = tile, lo = lo] { me->computeBase(wq, tile, lo); };
        state = COMPUTING_BASE;
        break;
 
      case BASE_COMPUTED:
        fn = [me = shared_from_this<TileViewState>(), wq, tile = tile, lo = lo, baseCache = baseCache, zoom = zoom]
        { me->computeZoom(wq, tile, lo, baseCache, zoom); };
        state = COMPUTING_ZOOM;
        break;
 
      case ZOOM_COMPUTED:
        state = DONE;
        fn = [me = shared_from_this<TileViewState>(), wq, tile = tile] { me->reportDone(wq, tile); };
        break;
 
      case INIT:
      case COMPUTING_BASE:
      case COMPUTING_ZOOM:
      case DONE:
      default:
        defect_message(fmt::format("PANIC: Don't know what to do in state {}", state));
        return;
      }
 
      l.unlock();
      fn();
    }
    else
    {
      break;
    }
  }
 
  {
    boost::mutex::scoped_lock const l(mut);
 
    if(wq == weakQueue)
    {
      queue.reset();
      weakQueue.reset();
    }
  }
}

Here is the call graph for this function:

◆ reportDone()

void TileViewState::reportDone	(	const ThreadPool::WeakQueue::Ptr &	wq,
		const ConstTile::Ptr &	tile
	)

private

{
  for(const TileLoadingObserver::Ptr& observer: Scroom::Utils::Observable<TileLoadingObserver>::getObservers())
  {
    observer->tileLoaded(tile_);
  }
}

Here is the call graph for this function:

◆ setViewData()

void TileViewState::setViewData ( const std::shared_ptr< TiledBitmapViewData > & tbvd )

{
  boost::mutex::scoped_lock const l(mut);
  tbvd = tbvd_;
 
  Scroom::Utils::Stuff lifeTimeManager_ = lifeTimeManager.lock();
  if(!lifeTimeManager_)
  {
    lifeTimeManager_ = std::shared_ptr<void>(
      reinterpret_cast<void*>(0xDEAD), [me = shared_from_this<TileViewState>()](auto p [[maybe_unused]]) { me->clear(); }
    );
    lifeTimeManager = lifeTimeManager_;
  }
  tbvd_->storeVolatileStuff(lifeTimeManager_);
 
  kick();
}

Here is the call graph for this function:

◆ setZoom()

void TileViewState::setZoom	(	LayerOperations::Ptr	lo,
		int	zoom
	)

{
  bool mustKick = false;
 
  boost::mutex::scoped_lock const l(mut);
  if(desiredState != DONE || zoom_ != zoom)
  {
    zoom = zoom_;
    lo = std::move(lo_);
    desiredState = DONE;
    mustKick = true;
 
    // Abort any zoom currently in progress
    if(state >= BASE_COMPUTED)
    {
      queue.reset();
      weakQueue.reset();
      zoomCache.reset();
      state = BASE_COMPUTED;
    }
  }
 
  if(mustKick)
  {
    kick();
  }
}

Here is the call graph for this function:

◆ tileLoaded()

void TileViewState::tileLoaded ( ConstTile::Ptr tile )

overridevirtual

The Tile has been loaded.

Implements TileLoadingObserver.

{
  boost::mutex::scoped_lock const l(mut);
 
  tile = tile_;
 
  // Abort any zoom currently in progress
  if(state > LOADED)
  {
    queue.reset();
    weakQueue.reset();
    zoomCache.reset();
  }
  state = LOADED;
 
  kick();
}