Program Listing for File ADT.h

↰ Return to documentation for file (ADS/ADT.h)

/*--------------------------------------------------------------------------*/
/*------------------------------- File ADT.h -------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/

#ifndef __ADS_ADT
 #define __ADS_ADT
                      /* self-identification: #endif constant */

/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/

#include <concepts>
#include <cstddef>
#include <optional>

/*--------------------------------------------------------------------------*/
/*--------------------------- NAMESPACE ------------------------------------*/
/*--------------------------------------------------------------------------*/

namespace ADS {

/*--------------------------------------------------------------------------*/
/*------------------------------- CONCEPTS ---------------------------------*/
/*--------------------------------------------------------------------------*/

template< class S >
concept Sequence = requires( S s , const S cs , typename S::Pos p ,
                             const typename S::Item & v ) {
 typename S::Item;
 typename S::Pos;
 { cs.empty() } -> std::same_as< bool >;
 { cs.finished( p ) } -> std::same_as< bool >;
 { cs.head() } -> std::same_as< typename S::Pos >;
 { cs.tail() } -> std::same_as< typename S::Pos >;
 { cs.next( p ) } -> std::same_as< typename S::Pos >;
 { cs.prev( p ) } -> std::same_as< typename S::Pos >;
 { s.insert( p , v ) } -> std::same_as< typename S::Pos >;
 { s.remove( p ) } -> std::same_as< typename S::Pos >;
 { cs.read( p ) } -> std::convertible_to< typename S::Item >;
 s.write( p , v );
 };

template< class S >
concept Set = requires( S s , const S cs , const typename S::Item & x ) {
 typename S::Item;
 { cs.size() } -> std::convertible_to< std::size_t >;
 { cs.contains( x ) } -> std::same_as< bool >;
 s.insert( x );
 s.remove( x );
 };

template< class D >
concept Dictionary = requires( D d , const D cd , const typename D::Key & k ,
                               const typename D::Value & v ) {
 typename D::Key;
 typename D::Value;
 { cd.lookup( k ) } -> std::same_as< std::optional< typename D::Value > >;
 d.insert( k , v );
 d.remove( k );
 };

template< class S >
concept Stack = requires( S s , const S cs , const typename S::Item & v ) {
 typename S::Item;
 { cs.empty() } -> std::same_as< bool >;
 s.push( v );
 { s.pop() } -> std::convertible_to< typename S::Item >;
 { cs.top() } -> std::convertible_to< typename S::Item >;
 };

template< class Q >
concept Queue = requires( Q q , const Q cq , const typename Q::Item & v ) {
 typename Q::Item;
 { cq.empty() } -> std::same_as< bool >;
 q.enqueue( v );
 { q.dequeue() } -> std::convertible_to< typename Q::Item >;
 { cq.top() } -> std::convertible_to< typename Q::Item >;
 };

/*--------------------------------------------------------------------------*/

}  // end( namespace ADS )

/*--------------------------------------------------------------------------*/

#endif  /* ADT.h included */

/*--------------------------------------------------------------------------*/
/*---------------------------- End File ADT.h ------------------------------*/
/*--------------------------------------------------------------------------*/