Namespaces

• namespace guile
• namespace python
• namespace resources

  Mini-language for selecting nodes with appropriate resources (memory, cores, graphical accelerators etc.)
• namespace this_application

Types

• using Port = std::uint16_t
• using foreign_kernel_ptr = std::unique_ptr< foreign_kernel >
• using kernel_ptr = std::unique_ptr< kernel >
• using kernel_ptr_array = std::vector< kernel_ptr >
• using kernel_sack = std::vector< kernel_ptr >
• using modular_weight_array = basic_weight_array< std::array< weight_type, 2 > >
• template <class T>
using pointer = std::unique_ptr< T >
• using resource_array = resources::Bindings
• using weight_array = basic_weight_array< weight_type >
• using weight_type = basic_weight< sys::u32 >

Enumerations

• enum Target
• enum connection_flags: sys::u32
• enum exit_code: sys::u16
• enum kernel_field: sys::u8
• enum kernel_flag: sys::u32

  Various kernel flags.
• enum transaction_status: sys::u8

Classes

• class sbn::Duration
• class sbn::Factory
• template <class ... Elements>
class sbn::List
• template <class Head, class ... Tail>
class sbn::List< Head, Tail... >
• class sbn::List<>
• class sbn::Properties
• class sbn::application
• class sbn::basic_socket_pipeline
• template <class T>
class sbn::basic_weight
• template <class T>
class sbn::basic_weight_array
• class sbn::child_process_pipeline
• class sbn::connection
• class sbn::connection_table
• class sbn::error
• class sbn::foreign_kernel
• class sbn::kernel
• class sbn::kernel_base
• class sbn::kernel_buffer
• class sbn::kernel_frame
• class sbn::kernel_instance_registry
• class sbn::kernel_read_guard
• class sbn::kernel_type
• class sbn::kernel_type_registry
• class sbn::kernel_write_guard
• template <class Container>
class sbn::list_view
• class sbn::parallel_pipeline
• class sbn::pipeline
• class sbn::pipeline_base
• class sbn::process_handler
• class sbn::properties
• class sbn::service_kernel
• template <class Container>
class sbn::text
• class sbn::thread_pool
• class sbn::transaction_kernel
• class sbn::transaction_log

Structs

• struct sbn::factory_guard
• struct sbn::transaction_record

Variables

• Factory factory

Functions

• SBN_INTERNAL_OPERATOR(/) -> SBN_INTERNAL_OPERATOR *
• SBN_INTERNAL_OPERATOR(-)
• SBN_INTERNAL_OPERATOR(+)
• SBN_INTERNAL_UNWRAP(!)
• SBN_INTERNAL_UNWRAP(>=)
• SBN_INTERNAL_UNWRAP(<=)
• SBN_INTERNAL_UNWRAP()
• SBN_INTERNAL_WRAP(/) -> SBN_INTERNAL_WRAP *
• SBN_INTERNAL_WRAP(-)
• SBN_INTERNAL_WRAP(+)
• UNISTDX_FLAGS(kernel_field)
• template <Target target = Target::Local>
commit(kernel_ptr && rhs) -> void
• template <Target target = Target::Local>
commit(kernel_ptr && rhs, exit_code ret) -> void
• exit(kernel * k) -> void
• exit(int ret) -> void
• template <class Queue>
find_kernel(const sbn::kernel * a, const Queue & queue) -> Queue::const_iterator
• generate_application_id() -> application::id_type
• install_error_handler() -> void
• template <class ... Elements>
list(Elements &&... elems) -> List< Elements... >
• template <class Container>
make_list_view(const Container & c) -> list_view< Container >
• template <class T, class ... Args>
make_pointer(Args &&... args) -> pointer< T >
• template <class Container>
make_string(const Container & c) -> text< Container >
• template <class T>
operator%(basic_weight< T > a, basic_weight< T > b) -> basic_weight< T >
• template <class T>
operator*(basic_weight< T > a, basic_weight< T > b) -> basic_weight< T >
• template <class T>
operator+(basic_weight< T > a, basic_weight< T > b) -> basic_weight< T >
• template <class T>
operator-(basic_weight< T > a, basic_weight< T > b) -> basic_weight< T >
• template <class T>
operator/(basic_weight< T > a, basic_weight< T > b) -> basic_weight< T >
• operator<<(kernel_buffer & out, const weight_array & rhs) -> kernel_buffer &
• operator<<(std::ostream & out, const modular_weight_array & rhs) -> std::ostream &
• operator<<(std::ostream & out, const weight_array & rhs) -> std::ostream &
• operator<<(std::ostream & out, const transaction_log & rhs) -> std::ostream &
• operator<<(kernel_buffer & out, const transaction_record & rhs) -> kernel_buffer &
• operator<<(kernel_buffer & out, transaction_status rhs) -> kernel_buffer &
• operator<<(std::ostream & out, pipeline_base::states rhs) -> std::ostream &
• operator<<(std::ostream & out, const parallel_pipeline & rhs) -> std::ostream &
• template <class Container>
operator<<(std::ostream & out, const text< Container > & rhs) -> std::ostream &
• template <class Container>
operator<<(std::ostream & out, const list_view< Container > & rhs) -> std::ostream &
• template <class ... Elements>
operator<<(std::ostream & out, const List< Elements... > & rhs) -> std::ostream &
• operator<<(std::ostream & out, const List<> &) -> std::ostream &
• operator<<(std::ostream & out, const kernel_type_registry & rhs) -> std::ostream &
• operator<<(std::ostream & out, const kernel_type & rhs) -> std::ostream &
• operator<<(std::ostream & out, const kernel_instance_registry & rhs) -> std::ostream &
• template <class T>
operator<<(kernel_buffer & out, const T & rhs) -> auto
• operator<<(std::ostream & out, exit_code rhs) -> std::ostream &
• operator<<(sbn::kernel_buffer & out, const kernel & rhs) -> sbn::kernel_buffer &
• operator<<(std::ostream & out, const kernel_ptr & rhs) -> std::ostream &
• operator<<(std::ostream & out, const kernel & rhs) -> std::ostream &
• operator<<(std::ostream & out, const connection::connection_ptr & rhs) -> std::ostream &
• operator<<(std::ostream & out, const connection * rhs) -> std::ostream &
• operator<<(std::ostream & out, const connection & rhs) -> std::ostream &
• operator<<(std::ostream & out, connection::states rhs) -> std::ostream &
• operator<<(std::ostream & out, const basic_socket_pipeline & rhs) -> std::ostream &
• operator<<(kernel_buffer & out, const application & rhs) -> kernel_buffer &
• operator<<(std::ostream & out, const application & rhs) -> std::ostream &
• operator>>(kernel_buffer & in, weight_array & rhs) -> kernel_buffer &
• operator>>(kernel_buffer & in, transaction_record & rhs) -> kernel_buffer &
• operator>>(std::istream & in, Duration & rhs) -> std::istream &
• operator>>(sbn::kernel_buffer & in, kernel & rhs) -> sbn::kernel_buffer &
• operator>>(kernel_buffer & in, application & rhs) -> kernel_buffer &
• template <class B, class A>
pointer_dynamic_cast(pointer< A > && ptr) -> pointer< B >
• template <class B, class A>
pointer_static_cast(pointer< A > && ptr) -> auto
• template <Target target = Target::Local>
send(kernel_ptr && lhs, kernel * rhs) -> void
• template <Target t = Target::Local>
send(kernel_ptr && k) -> void
• send< Local >(kernel_ptr && k) -> void
• send< Remote >(kernel_ptr && k) -> void
• starts_with(const std::string & s, const char * prefix) -> bool
• string_to_bool(std::string s) -> bool
• string_to_duration(std::string s) -> auto
• string_to_port(std::string s) -> auto
• template <class ... Arguments>
throw_error(const char * what, Arguments ... args) -> void
• throw_error(const char * what) -> void
• to_string(pipeline_base::states rhs) -> const char *
• to_string(exit_code rhs) -> const char *
• to_string(connection::states rhs) -> const char *
• template <class Pipeline>
upstream(Pipeline & ppl, kernel * lhs, kernel_ptr && rhs) -> void
• template <Target target = Target::Local>
upstream(kernel * lhs, kernel_ptr && rhs) -> void
• wait_and_return() -> int