ExplicitAdjacency.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*------------------------ File ExplicitAdjacency.h ------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*------------------------------ DEFINITIONS -------------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef __PBeFS_ads_ExplicitAdjacency
 #define __PBeFS_ads_ExplicitAdjacency
                      /* self-identification: #endif at the end of the file */
 
/*--------------------------------------------------------------------------*/
/*-------------------------------- INCLUDES --------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include <atomic>
 
#include <cstddef>
 
#include <cstdint>
 
#include <mutex>
 
#include <optional>
 
#include "ADS/graph/ArrayGraph.h"
 
#include "ADS/graph/GraphBuilder.h"
 
/*--------------------------------------------------------------------------*/
/*------------------------------- NAMESPACE --------------------------------*/
/*--------------------------------------------------------------------------*/

namespace PBeFS_di_unipi_it
{
 
/*--------------------------------------------------------------------------*/
/*------------------------ CLASS ExplicitAdjacency -------------------------*/
/*--------------------------------------------------------------------------*/

 
template< class Cost >
class ExplicitAdjacency {
 
/*------------------------ PUBLIC PART OF THE CLASS ------------------------*/
 
 public:

 
 explicit ExplicitAdjacency( std::size_t n )
  : f_n( n ) , f_b( int( n ) , true ) {}

 
 ExplicitAdjacency( const ExplicitAdjacency & o )
  : f_n( o.f_n ) , f_b( o.f_b ) {}

 
 ExplicitAdjacency & operator=( const ExplicitAdjacency & o ) {
  if( this != & o ) {
   f_n = o.f_n;
   f_b = o.f_b;
   f_g.reset();
   f_frozen.store( false , std::memory_order_relaxed );
   }
  return( *this );
  }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
 void add( std::uint32_t u , std::uint32_t v , Cost c ) {
  if( u == v )
   return;
  f_b.addEdge( int( u ) , int( v ) , c );
  f_frozen.store( false , std::memory_order_relaxed );
  }

 
 template< class F >
 void for_each( std::uint32_t u , F && f ) const {
  if( ! f_frozen.load( std::memory_order_acquire ) )
   freeze();
  f_g->forEachEdge( int( u ) , [ & ]( int v , const Cost & c ) {
   f( std::uint32_t( v ) , c );
   } );
  }

 
 [[nodiscard]] std::size_t size( void ) const noexcept { return( f_n ); }
 
/*----------------------- PRIVATE PART OF THE CLASS ------------------------*/
 
 private:
 
 // builds the ArrayGraph of the arcs, once
 
 void freeze( void ) const {
  std::lock_guard< std::mutex > lock( f_lock );
  if( f_frozen.load( std::memory_order_relaxed ) )
   return;
  f_g.emplace( f_b.toArrayGraph() );
  f_frozen.store( true , std::memory_order_release );
  }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 
 std::size_t f_n;                                
 ADS::GraphBuilder< Cost > f_b;                  
 mutable std::optional< ADS::ArrayGraph< Cost > > f_g;
 mutable std::atomic< bool > f_frozen{ false };  
 mutable std::mutex f_lock;                      
 
 };  // end( class( ExplicitAdjacency ) )
 
/*--------------------------------------------------------------------------*/
 
}  // end( namespace PBeFS_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
 
#endif  /* __PBeFS_ads_ExplicitAdjacency */
 
/*--------------------------------------------------------------------------*/
/*---------------------- End File ExplicitAdjacency.h ----------------------*/
/*--------------------------------------------------------------------------*/