#include <layercoordinator.hh>

Inheritance diagram for LayerCoordinator:

Collaboration diagram for LayerCoordinator:

Public Types
using	Ptr = boost::shared_ptr< LayerCoordinator >

Public Types inherited from TileInitialisationObserver
using	Ptr = boost::shared_ptr< TileInitialisationObserver >

using	WeakPtr = boost::weak_ptr< TileInitialisationObserver >

Public Member Functions
	~LayerCoordinator () override

	LayerCoordinator (const LayerCoordinator &)=delete

	LayerCoordinator (LayerCoordinator &&)=delete

LayerCoordinator	operator= (const LayerCoordinator &)=delete

LayerCoordinator	operator= (LayerCoordinator &&)=delete

void	addSourceTile (int x, int y, const CompressedTile::Ptr &tile)

void	tileFinished (const CompressedTile::Ptr &tile) override
	TileInitialisationObserver. More...

Public Member Functions inherited from TileInitialisationObserver
virtual void	tileCreated (const boost::shared_ptr< CompressedTile > &tile)

virtual void	tileFinished (const boost::shared_ptr< CompressedTile > &tile)
	TileInitialisationObserver. More...

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 >
boost::shared_ptr< R >	shared_from_this ()

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

Static Public Member Functions
static Ptr	create (CompressedTile::Ptr targetTile, LayerOperations::Ptr lo)

Private Member Functions
	LayerCoordinator (CompressedTile::Ptr targetTile, LayerOperations::Ptr lo)

void	reduceSourceTile (const CompressedTile::Ptr &tile, ConstTile::Ptr const &tileData)
	Helpers. More...

Private Attributes
CompressedTile::Ptr	targetTile

Tile::Ptr	targetTileData

std::map< CompressedTile::Ptr, std::pair< int, int > >	sourceTiles

Scroom::Utils::StuffList	registrations

LayerOperations::Ptr	lo

boost::mutex	mut

int	unfinishedSourceTiles {0}

Member Typedef Documentation

◆ Ptr

using LayerCoordinator::Ptr = boost::shared_ptr<LayerCoordinator>

Constructor & Destructor Documentation

◆ ~LayerCoordinator()

LayerCoordinator::~LayerCoordinator ( )

override

 {
   registrations.clear();
   sourceTiles.clear();
 }

◆ LayerCoordinator() [1/3]

LayerCoordinator::LayerCoordinator ( const LayerCoordinator & )

delete

Referenced by create().

Here is the caller graph for this function:

◆ LayerCoordinator() [2/3]

LayerCoordinator::LayerCoordinator ( LayerCoordinator && )

delete

◆ LayerCoordinator() [3/3]

LayerCoordinator::LayerCoordinator	(	CompressedTile::Ptr	targetTile,
		LayerOperations::Ptr	lo
	)

private

   : targetTile(std::move(targetTile_))
   , lo(std::move(lo_))
  
 {
 }

Member Function Documentation

◆ addSourceTile()

void LayerCoordinator::addSourceTile	(	int	x,
		int	y,
		const CompressedTile::Ptr &	tile
	)

 {
   boost::unique_lock<boost::mutex> const lock(mut);
  
   sourceTiles[tile] = std::make_pair(x, y);
   registrations.emplace_back(tile->registerObserver(shared_from_this<LayerCoordinator>()));
   unfinishedSourceTiles++;
 }

◆ create()

LayerCoordinator::Ptr LayerCoordinator::create	(	CompressedTile::Ptr	targetTile,
		LayerOperations::Ptr	lo
	)

static

 {
   return LayerCoordinator::Ptr(new LayerCoordinator(std::move(targetTile), std::move(lo)));
 }

Referenced by TiledBitmap::connect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=() [1/2]

LayerCoordinator LayerCoordinator::operator= ( const LayerCoordinator & )

delete

◆ operator=() [2/2]

LayerCoordinator LayerCoordinator::operator= ( LayerCoordinator && )

delete

◆ reduceSourceTile()

void LayerCoordinator::reduceSourceTile	(	const CompressedTile::Ptr &	tile,
		ConstTile::Ptr const &	tileData
	)

private

Helpers.

 {
   // If tileData contains a valid pointer, then fetching
   // sourcetiledata, below, will be instananeous. Otherwise, it will
   // need to unzip the compressed tile.
   //
   // Other than that side-effect, we have no use for tileData
   UNUSED(tileData);
  
   Scroom::Utils::Stuff const s        = targetTile->initialize();
   const std::pair<int, int>  location = sourceTiles[tile];
   const int                  x        = location.first;
   const int                  y        = location.second;
  
   if(!targetTileData)
   {
     targetTileData = targetTile->getTileSync();
   }
   ConstTile::Ptr const source = tile->getConstTileSync();
  
   lo->reduce(targetTileData, source, x, y);
  
   boost::unique_lock<boost::mutex> const lock(mut);
   unfinishedSourceTiles--;
   if(!unfinishedSourceTiles)
   {
     targetTile->reportFinished();
     targetTileData.reset();
   }
 }

Referenced by tileFinished().

Here is the caller graph for this function:

◆ tileFinished()

void LayerCoordinator::tileFinished ( const CompressedTile::Ptr & tile )

override

TileInitialisationObserver.

 {
   ConstTile::Ptr const tileData = tile->getConstTileAsync();
   require(tileData);
  
   CpuBound()->schedule(boost::bind(&LayerCoordinator::reduceSourceTile, shared_from_this<LayerCoordinator>(), tile, tileData),
                        REDUCE_PRIO);
 }