LayerCoordinator Class Reference

#include <layercoordinator.hh>

Inheritance diagram for LayerCoordinator:

Collaboration diagram for LayerCoordinator:

Public Types
using	Ptr = std::shared_ptr< LayerCoordinator >
Public Types inherited from TileInitialisationObserver
using	Ptr = std::shared_ptr< TileInitialisationObserver >
using	WeakPtr = std::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.
Public Member Functions inherited from TileInitialisationObserver
virtual void	tileCreated (const std::shared_ptr< CompressedTile > &tile)
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 (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.

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 = std::shared_ptr<LayerCoordinator>

Constructor & Destructor Documentation

~LayerCoordinator()

LayerCoordinator::~LayerCoordinator ( )

override

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

LayerCoordinator() [1/3]

LayerCoordinator::LayerCoordinator ( const LayerCoordinator &  )

delete

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

tileFinished()

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

overridevirtual

TileInitialisationObserver.

Reimplemented from TileInitialisationObserver.

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

Here is the call graph for this function:

Member Data Documentation

lo

LayerOperations::Ptr LayerCoordinator::lo

private

Referenced by create(), and reduceSourceTile().

mut

boost::mutex LayerCoordinator::mut

private

Referenced by addSourceTile(), and reduceSourceTile().

registrations

Scroom::Utils::StuffList LayerCoordinator::registrations

private

Referenced by addSourceTile(), and ~LayerCoordinator().

sourceTiles

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

private

Referenced by addSourceTile(), reduceSourceTile(), and ~LayerCoordinator().

targetTile

CompressedTile::Ptr LayerCoordinator::targetTile

private

Referenced by create(), and reduceSourceTile().

targetTileData

Tile::Ptr LayerCoordinator::targetTileData

private

Referenced by reduceSourceTile().

unfinishedSourceTiles

int LayerCoordinator::unfinishedSourceTiles {0}

private

{0};

Referenced by addSourceTile(), and reduceSourceTile().

---

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

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