TileViewState Class Reference

#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 = boost::shared_ptr< TileViewState >
using	WeakPtr = boost::weak_ptr< TileViewState >
Public Types inherited from Scroom::Utils::Observable< TileLoadingObserver >
using	Observer = boost::shared_ptr< TileLoadingObserver >
using	Ptr = boost::shared_ptr< Observable< TileLoadingObserver > >
Public Types inherited from TileLoadingObserver
using	Ptr = boost::shared_ptr< TileLoadingObserver >
using	WeakPtr = boost::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 boost::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)

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

Private Member Functions
	TileViewState (boost::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
boost::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
boost::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 = boost::shared_ptr<TileViewState>

WeakPtr

using TileViewState::WeakPtr = boost::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

{ r.reset(); }

TileViewState() [1/3]

TileViewState::TileViewState ( const TileViewState &  )

delete

Referenced by create().

Here is the caller graph for this function:

TileViewState() [2/3]

TileViewState::TileViewState ( TileViewState &&  )

delete

TileViewState() [3/3]

TileViewState::TileViewState ( boost::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();
}

Referenced by setViewData().

Here is the call graph for this function:

Here is the caller 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;
  }
}

Referenced by process().

Here is the caller graph for this function:

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;
  }
}

Referenced by process().

Here is the caller graph for this function:

create()

TileViewState::Ptr TileViewState::create ( const boost::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 call graph for this function:

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(boost::bind(&TileViewState::process, shared_from_this<TileViewState>(), 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    = boost::bind(&TileViewState::computeBase, shared_from_this<TileViewState>(), wq, tile, lo);
        state = COMPUTING_BASE;
        break;
 
      case BASE_COMPUTED:
        fn    = boost::bind(&TileViewState::computeZoom, shared_from_this<TileViewState>(), wq, tile, lo, baseCache, zoom);
        state = COMPUTING_ZOOM;
        break;
 
      case ZOOM_COMPUTED:
        state = DONE;
        fn    = boost::bind(&TileViewState::reportDone, shared_from_this<TileViewState>(), 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();
    }
  }
}

Referenced by kick().

Here is the call graph for this function:

Here is the caller graph for this function:

reportDone()

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

private

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

Referenced by process().

Here is the caller graph for this function:

setViewData()

void TileViewState::setViewData

(

const boost::shared_ptr< TiledBitmapViewData > &

tbvd

)

{
  boost::mutex::scoped_lock const l(mut);
  tbvd = tbvd_;
 
  Scroom::Utils::Stuff lifeTimeManager_ = lifeTimeManager.lock();
  if(!lifeTimeManager_)
  {
    lifeTimeManager_ = boost::shared_ptr<void>(reinterpret_cast<void*>(0xDEAD),
                                               boost::bind(&TileViewState::clear, shared_from_this<TileViewState>()));
    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();
}

Here is the call graph for this function:

Member Data Documentation

baseCache

Scroom::Utils::Stuff TileViewState::baseCache

private

Referenced by clear(), computeBase(), and process().

cpuBound

ThreadPool::Ptr TileViewState::cpuBound

private

Referenced by kick().

desiredState

State TileViewState::desiredState {LOADED}

private

Referenced by computeBase(), computeZoom(), kick(), process(), and setZoom().

lifeTimeManager

Scroom::Utils::StuffWeak TileViewState::lifeTimeManager

private

Referenced by clear(), and setViewData().

lo

LayerOperations::Ptr TileViewState::lo

private

Referenced by process(), and setZoom().

mut

boost::mutex TileViewState::mut

private

Referenced by clear(), computeBase(), computeZoom(), getCacheResult(), process(), setViewData(), setZoom(), and tileLoaded().

parent

boost::shared_ptr<CompressedTile> TileViewState::parent

private

Referenced by create().

queue

ThreadPool::Queue::Ptr TileViewState::queue

private

Referenced by clear(), kick(), process(), setZoom(), and tileLoaded().

r

Scroom::Utils::Stuff TileViewState::r

private

Referenced by ~TileViewState().

state

State TileViewState::state {INIT}

private

Referenced by clear(), computeBase(), computeZoom(), kick(), process(), setZoom(), and tileLoaded().

tbvd

boost::weak_ptr<TiledBitmapViewData> TileViewState::tbvd

private

Referenced by computeBase(), computeZoom(), kick(), and setViewData().

tile

ConstTile::Ptr TileViewState::tile

private

Referenced by kick(), process(), and tileLoaded().

weakQueue

ThreadPool::WeakQueue::Ptr TileViewState::weakQueue

private

Referenced by clear(), computeBase(), computeZoom(), kick(), process(), setZoom(), and tileLoaded().

zoom

int TileViewState::zoom {0}

private

Referenced by computeZoom(), process(), and setZoom().

zoomCache

Scroom::Utils::Stuff TileViewState::zoomCache

private

Referenced by clear(), computeZoom(), getCacheResult(), setZoom(), and tileLoaded().

---

The documentation for this class was generated from the following files:

• libs/tiled-bitmap/src/tileviewstate.hh
• libs/tiled-bitmap/src/tileviewstate.cc