Si Namespace Reference

Namespaces
	detail
	experimental
	html
	SQLite3

Classes
struct	absolute_path
struct	alignment_of
struct	async_process
struct	async_process_parameters
struct	basic_c_string
struct	boost_threading
struct	buffer_observable
struct	copy_const
struct	error_code
struct	error_or
struct	file_handle
struct	file_notification
struct	flush
struct	function
struct	function< Result(Args...)>
struct	hash_visitor
struct	identity
struct	inplace
struct	is_copy_assignable
struct	is_copy_constructible
struct	is_default_constructible
struct	is_error_or
struct	is_error_or< error_or< Value, Error > >
struct	is_handle
struct	is_move_assignable
struct	is_move_assignable< std::unique_ptr< T > >
struct	is_move_constructible
struct	is_move_constructible< std::unique_ptr< T > >
struct	is_nothrow_default_constructible
struct	is_nothrow_destructible
struct	is_nothrow_move_assignable
struct	is_nothrow_move_constructible
struct	iterator_range
struct	none_t
struct	nothing
struct	optional
struct	optional< T & >
struct	path
struct	path_segment
struct	process_parameters
struct	ptr_adaptor
struct	range_value
struct	relative_path
struct	some_t
struct	std_threading
struct	success
struct	try_get_ptr_visitor
struct	try_get_visitor
struct	variant
struct	vector

Typedefs
typedef basic_c_string< char >	c_string
typedef basic_c_string< wchar_t >	cw_string
typedef c_string	os_c_string
typedef os_c_string	native_path_string
typedef std::uintptr_t	uintptr_t
typedef detail::basic_dynamic_library< linux::dynamic_library_impl >	dynamic_library
template<class... T>
using	fast_variant = variant< T... >
typedef iterator_range< char const * >	memory_range
typedef iterator_range< char * >	mutable_memory_range
typedef boost::container::string	noexcept_string
typedef char	os_char
typedef noexcept_string	os_string
typedef char	native_path_char

Enumerations
enum	environment_inheritance { environment_inheritance::inherit, environment_inheritance::no_inherit }
enum	byte : boost::uint8_t { byte::minimum = 0, byte::zero = 0, byte::one = 1, byte::maximum = 255 }
enum	file_notification_type {   file_notification_type::add, file_notification_type::remove, file_notification_type::move_self, file_notification_type::remove_self,   file_notification_type::change_content, file_notification_type::change_metadata, file_notification_type::change_content_or_metadata }

Functions
	BOOST_STATIC_ASSERT (Si::is_handle< absolute_path >::value)
std::ostream &	operator<< (std::ostream &out, absolute_path const &p)
std::istream &	operator>> (std::istream &in, absolute_path &p)
template<class ComparableToPath >
SILICIUM_USE_RESULT bool	operator== (absolute_path const &left, ComparableToPath const &right)
template<class ComparableToPath >
SILICIUM_USE_RESULT bool	operator== (ComparableToPath const &left, absolute_path const &right)
SILICIUM_USE_RESULT bool	operator== (absolute_path const &left, boost::filesystem::path const &right)
SILICIUM_USE_RESULT bool	operator== (boost::filesystem::path const &left, absolute_path const &right)
SILICIUM_USE_RESULT bool	operator== (absolute_path const &left, absolute_path const &right)
template<class ComparableToPath >
SILICIUM_USE_RESULT bool	operator!= (absolute_path const &left, ComparableToPath const &right)
template<class ComparableToPath >
SILICIUM_USE_RESULT bool	operator!= (ComparableToPath const &left, absolute_path const &right)
SILICIUM_USE_RESULT bool	operator< (absolute_path const &left, absolute_path const &right)
SILICIUM_USE_RESULT std::size_t	hash_value (absolute_path const &value)
SILICIUM_USE_RESULT relative_path	leaf (absolute_path const &whole)
SILICIUM_USE_RESULT optional< absolute_path >	parent (absolute_path const &whole)
SILICIUM_USE_RESULT absolute_path	operator/ (absolute_path const &front, relative_path const &back)
template<std::size_t N>
SILICIUM_USE_RESULT absolute_path	operator/ (absolute_path const &front, absolute_path::char_type const (&literal)[N])
SILICIUM_USE_RESULT absolute_path	get_current_working_directory ()
SILICIUM_USE_RESULT boost::system::error_code	remove_file (absolute_path const &name)
SILICIUM_USE_RESULT boost::system::error_code	create_directories (absolute_path const &directories)
SILICIUM_USE_RESULT error_or< boost::uint64_t >	remove_all (absolute_path const &directories)
SILICIUM_USE_RESULT boost::system::error_code	recreate_directories (absolute_path const &directories)
SILICIUM_USE_RESULT error_or< bool >	file_exists (absolute_path const &file)
template<class Original >
auto	make_buffer_observable (Original &&from, std::size_t size) -> buffer_observable< typename std::decay< Original >::type::element_type, typename std::decay< Original >::type >
std::size_t	hash_value (byte value)
template<class Char >
std::basic_ostream< Char > &	operator<< (std::basic_ostream< Char > &out, byte value)
	BOOST_STATIC_ASSERT (is_handle< c_string >::value)
	BOOST_STATIC_ASSERT (is_handle< cw_string >::value)
bool	operator== (nothing const &, nothing const &)
template<class T , class... Args>
auto	make_unique (Args &&...args) -> std::unique_ptr< T >
template<class To , class From >
To	function_ptr_cast (From from)
	BOOST_STATIC_ASSERT (sizeof(dynamic_library)==sizeof(void *))
	BOOST_STATIC_ASSERT (is_handle< dynamic_library >::value)
SILICIUM_USE_RESULT boost::system::error_code	set_environment_variable (os_c_string key, os_c_string value)
	BOOST_STATIC_ASSERT (sizeof(error_code<>)==sizeof(void *))
template<class UnderlyingErrorCode , class UnderlyingCategory >
bool	operator== (error_code< UnderlyingErrorCode, UnderlyingCategory > const &left, error_code< UnderlyingErrorCode, UnderlyingCategory > const &right)
template<class UnderlyingErrorCode , class UnderlyingCategory >
SILICIUM_NORETURN void	throw_error (error_code< UnderlyingErrorCode, UnderlyingCategory > error)
template<class UnderlyingErrorCode , class UnderlyingCategory >
std::size_t	hash_value (error_code< UnderlyingErrorCode, UnderlyingCategory > const &value)
template<class UnderlyingErrorCode , class UnderlyingCategory >
std::ostream &	operator<< (std::ostream &out, error_code< UnderlyingErrorCode, UnderlyingCategory > const &value)
SILICIUM_NORETURN void	throw_error (boost::system::error_code error)
SILICIUM_NORETURN void	throw_error (std::error_code error)
	BOOST_STATIC_ASSERT (is_handle< error_or< nothing >>::value)
	BOOST_STATIC_ASSERT (is_handle< error_or< int >>::value)
	BOOST_STATIC_ASSERT (is_handle< error_or< std::unique_ptr< int >>>::value)
template<class Value , class Error , class Anything >
bool	operator== (error_or< Value, Error > const &left, Anything const &right)
template<class Anything , class Value , class Error , class = typename std::enable_if<!is_error_or<Anything>::value, void>::type>
bool	operator== (Anything const &left, error_or< Value, Error > const &right)
template<class Anything , class Value , class Error >
bool	operator!= (Anything const &left, error_or< Value, Error > const &right)
template<class Anything , class Value , class Error >
bool	operator!= (error_or< Value, Error > const &left, Anything const &right)
template<class Value , class Error >
bool	operator< (error_or< Value, Error > const &left, error_or< Value, Error > const &right)
template<class Value , class Error >
std::size_t	hash_value (error_or< Value, Error > const &value)
template<class Value , class Error >
std::ostream &	operator<< (std::ostream &out, error_or< Value, Error > const &value)
template<class ErrorOr , class OnValue , class CleanErrorOr = typename std::decay<ErrorOr>::type, class = typename std::enable_if<is_error_or<CleanErrorOr>::value, void>::type>
auto	map (ErrorOr &&maybe, OnValue &&on_value) -> error_or< decltype(std::forward< OnValue >(on_value)(std::forward< ErrorOr >(maybe).get()))>
template<class Value , class Error >
Value	get (error_or< Value, Error > &&value)
template<class T , class U >
T	exchange (T &dest, U &&source)
	BOOST_STATIC_ASSERT (is_handle< file_handle >::value)
	BOOST_STATIC_ASSERT (is_handle< file_notification >::value)
Si::error_or< Si::optional< boost::uint64_t > >	file_size (Si::native_file_descriptor file)
	BOOST_STATIC_ASSERT (is_handle< function< void()>>::value)
SILICIUM_USE_RESULT boost::system::error_code	get_last_error ()
template<class CharRange >
auto	make_range_from_string_like (CharRange &&range) -> CharRange
template<class Char >
auto	make_range_from_string_like (Char const *c_str) -> decltype(make_c_str_range(c_str))
	BOOST_STATIC_ASSERT (is_handle< char >::value)
	BOOST_STATIC_ASSERT (is_handle< int >::value)
	BOOST_STATIC_ASSERT (is_handle< long >::value)
	BOOST_STATIC_ASSERT (is_handle< float >::value)
	BOOST_STATIC_ASSERT (is_handle< void * >::value)
	BOOST_STATIC_ASSERT (is_handle< int * >::value)
	BOOST_STATIC_ASSERT (is_handle< int(*)()>::value)
	BOOST_STATIC_ASSERT (!is_handle< int & >::value)
	BOOST_STATIC_ASSERT (!is_handle< int const >::value)
	BOOST_STATIC_ASSERT (is_handle< nothing >::value)
	BOOST_STATIC_ASSERT (is_handle< std::unique_ptr< int >>::value)
template<class Iterator1 , class Iterator2 >
BOOST_CONSTEXPR bool	pointing_to_same_subrange (iterator_range< Iterator1 > const &left, iterator_range< Iterator2 > const &right)
template<class Iterator >
BOOST_CONSTEXPR Iterator const &	begin (iterator_range< Iterator > const &range)
template<class Iterator >
BOOST_CONSTEXPR Iterator const &	range_begin (iterator_range< Iterator > const &range)
template<class Iterator >
BOOST_CONSTEXPR Iterator const &	end (iterator_range< Iterator > const &range)
template<class Iterator1 , class Iterator2 >
BOOST_CONSTEXPR auto	make_iterator_range (Iterator1 &&begin, Iterator2 &&end) -> iterator_range< typename std::decay< Iterator1 >::type >
template<class Range >
auto	make_iterator_range (Range &&range) -> decltype(make_iterator_range(std::begin(range), std::end(range)))
template<class ContiguousRange >
auto	make_contiguous_range (ContiguousRange &&range) -> decltype(make_iterator_range(boost::addressof(*std::begin(range)), boost::addressof(*std::end(range))))
template<class Element = void, class... T>
auto	make_array (T &&...elements) -> std::array< typename std::conditional< std::is_same< Element, void >::value, std::common_type< T... >, identity< Element > >::type::type, sizeof...(elements) >
	BOOST_STATIC_ASSERT (is_handle< memory_range >::value)
	BOOST_STATIC_ASSERT (is_handle< mutable_memory_range >::value)
template<class Byte , class DestType = typename copy_const<char, Byte>::type>
auto	make_memory_range (Byte *begin, Byte *end) -> iterator_range< DestType * >
template<class Byte >
auto	make_memory_range (Byte *data, std::size_t size) -> iterator_range< Byte * >
template<class ContiguousRange >
auto	make_memory_range (ContiguousRange &&range) -> decltype(make_memory_range(boost::addressof(*std::begin(range)), boost::addressof(*std::end(range))))
template<class C >
auto	make_c_str_range (C const *str) -> iterator_range< C const * >
template<class T >
std::remove_reference< T >::type &&	move (T &&ref)
template<class T , class Result = typename std::conditional< !Si::is_nothrow_move_constructible<T>::value && Si::is_copy_constructible<T>::value, const T &, T && >::type>
BOOST_CONSTEXPR Result	move_if_noexcept (T &x)
noexcept_string	to_noexcept_string (std::string const &str)
noexcept_string &&	to_noexcept_string (noexcept_string &&str)
noexcept_string	to_noexcept_string (noexcept_string const &str)
bool	operator== (none_t, none_t)
	BOOST_STATIC_ASSERT (is_handle< optional< int >>::value)
	BOOST_STATIC_ASSERT (is_handle< optional< int * >>::value)
	BOOST_STATIC_ASSERT (is_handle< optional< int const * >>::value)
	BOOST_STATIC_ASSERT (is_handle< optional< nothing >>::value)
	BOOST_STATIC_ASSERT (is_handle< optional< int & >>::value)
	BOOST_STATIC_ASSERT (is_handle< optional< int const & >>::value)
template<class T >
SILICIUM_USE_RESULT bool	operator== (optional< T > const &left, optional< T > const &right)
template<class T >
SILICIUM_USE_RESULT bool	operator== (optional< T > const &left, T const &right)
template<class T >
SILICIUM_USE_RESULT bool	operator== (T const &left, optional< T > const &right)
template<class T >
SILICIUM_USE_RESULT bool	operator== (none_t const &, optional< T > const &right)
template<class T >
SILICIUM_USE_RESULT bool	operator== (optional< T > const &left, none_t const &)
template<class T >
SILICIUM_USE_RESULT bool	operator!= (optional< T > const &left, optional< T > const &right)
template<class T >
SILICIUM_USE_RESULT bool	operator< (optional< T > const &left, optional< T > const &right)
template<class T >
SILICIUM_USE_RESULT Si::optional< typename std::decay< T >::type >	make_optional (T &&value)
std::ostream &	operator<< (std::ostream &out, none_t const &)
template<class T >
std::ostream &	operator<< (std::ostream &out, optional< T > const &value)
template<class T >
SILICIUM_USE_RESULT std::size_t	hash_value (optional< T > const &value)
	BOOST_STATIC_ASSERT (sizeof(optional< boost::int8_t >)==2)
	BOOST_STATIC_ASSERT (sizeof(optional< boost::int16_t >)==4)
	BOOST_STATIC_ASSERT (sizeof(optional< boost::uint32_t >)==(2 *sizeof(boost::uint32_t)))
	BOOST_STATIC_ASSERT (sizeof(optional< char * >)==(alignment_of< char * >::value+sizeof(char *)))
	BOOST_STATIC_ASSERT (sizeof(optional< boost::int8_t & >)==sizeof(boost::int8_t *))
os_string	to_os_string (os_string original)
os_string	to_os_string (std::string const &original)
os_string	to_os_string (char const *original)
os_string	to_os_string (char const *begin, char const *end)
std::string	to_utf8_string (os_string const &str)
	BOOST_STATIC_ASSERT (is_handle< path >::value)
std::ostream &	operator<< (std::ostream &out, path const &p)
template<class ComparableToPath >
bool	operator== (path const &left, ComparableToPath const &right)
template<class ComparableToPath >
bool	operator== (ComparableToPath const &left, path const &right)
bool	operator== (path const &left, boost::filesystem::path const &right)
bool	operator== (boost::filesystem::path const &left, path const &right)
bool	operator== (path const &left, path const &right)
template<class ComparableToPath >
bool	operator!= (path const &left, ComparableToPath const &right)
template<class ComparableToPath >
bool	operator!= (ComparableToPath const &left, path const &right)
bool	operator< (path const &left, path const &right)
std::size_t	hash_value (path const &value)
path	leaf (path const &whole)
path	parent (path const &whole)
path	operator/ (path const &front, path const &back)
	BOOST_STATIC_ASSERT (is_handle< path_segment >::value)
std::ostream &	operator<< (std::ostream &out, path_segment const &p)
template<class ComparableToPath >
bool	operator== (path_segment const &left, ComparableToPath const &right)
template<class ComparableToPath >
bool	operator== (ComparableToPath const &left, path_segment const &right)
bool	operator== (path_segment const &left, boost::filesystem::path const &right)
bool	operator== (boost::filesystem::path const &left, path_segment const &right)
bool	operator== (path_segment const &left, path_segment const &right)
template<class ComparableToPath >
bool	operator!= (path_segment const &left, ComparableToPath const &right)
template<class ComparableToPath >
bool	operator!= (ComparableToPath const &left, path_segment const &right)
bool	operator< (path_segment const &left, path_segment const &right)
std::size_t	hash_value (path_segment const &value)
relative_path	operator/ (path_segment const &front, path_segment const &back)
relative_path	operator/ (relative_path const &front, path_segment const &back)
absolute_path	operator/ (absolute_path const &front, path_segment const &back)
	BOOST_STATIC_ASSERT (is_handle< process_handle >::value)
template<class Pointee >
auto	make_ptr_adaptor (Pointee &&value) -> ptr_adaptor< typename std::decay< Pointee >::type >
template<class BidirectionalRange1 , class BidirectionalRange2 >
bool	operator== (range_value< BidirectionalRange1 > const &left, range_value< BidirectionalRange2 > const &right)
template<class BidirectionalRange >
auto	make_range_value (BidirectionalRange &&range) -> range_value< typename std::decay< BidirectionalRange >::type >
error_or< std::size_t >	read (native_file_descriptor file, mutable_memory_range destination)
	BOOST_STATIC_ASSERT (is_handle< relative_path >::value)
std::ostream &	operator<< (std::ostream &out, relative_path const &p)
template<class ComparableToPath >
SILICIUM_USE_RESULT bool	operator== (relative_path const &left, ComparableToPath const &right)
template<class ComparableToPath >
SILICIUM_USE_RESULT bool	operator== (ComparableToPath const &left, relative_path const &right)
SILICIUM_USE_RESULT bool	operator== (relative_path const &left, boost::filesystem::path const &right)
SILICIUM_USE_RESULT bool	operator== (boost::filesystem::path const &left, relative_path const &right)
SILICIUM_USE_RESULT bool	operator== (relative_path const &left, relative_path const &right)
template<class ComparableToPath >
SILICIUM_USE_RESULT bool	operator!= (relative_path const &left, ComparableToPath const &right)
template<class ComparableToPath >
SILICIUM_USE_RESULT bool	operator!= (ComparableToPath const &left, relative_path const &right)
SILICIUM_USE_RESULT bool	operator< (relative_path const &left, relative_path const &right)
SILICIUM_USE_RESULT std::size_t	hash_value (relative_path const &value)
SILICIUM_USE_RESULT relative_path	leaf (relative_path const &whole)
SILICIUM_USE_RESULT relative_path	parent (relative_path const &whole)
SILICIUM_USE_RESULT relative_path	operator/ (relative_path const &front, relative_path const &back)
template<class T >
bool	extract (T &destination, optional< T > &&source)
template<class T >
T	default_construct ()
template<class First , class... Sequence>
auto	then (First &&first, Sequence &&...actions) -> decltype(std::forward< First >(first)())
void	throw_last_error ()
template<class T >
auto	to_shared (T &&t) -> std::shared_ptr< typename std::decay< T >::type >
template<class T >
auto	to_unique (T &&t) -> std::unique_ptr< typename std::decay< T >::type >
template<class Pointee , class T >
auto	to_unique (T &&t) -> std::unique_ptr< Pointee >
template<class Visitor , class Variant >
auto	apply_visitor (Visitor &&visitor, Variant &&variant) -> typename std::decay< Visitor >::type::result_type
	BOOST_STATIC_ASSERT (is_handle< variant< int >>::value)
	BOOST_STATIC_ASSERT ((is_handle< variant< int, nothing >>::value))
template<class... T>
bool	operator!= (variant< T... > const &left, variant< T... > const &right)
template<class... T>
bool	operator> (variant< T... > const &left, variant< T... > const &right)
template<class... T>
bool	operator<= (variant< T... > const &left, variant< T... > const &right)
template<class... T>
bool	operator>= (variant< T... > const &left, variant< T... > const &right)
template<class Element , class... T>
boost::optional< Element >	try_get (variant< T... > &from)
template<class Element , class... T>
Element *	try_get_ptr (variant< T... > &from) BOOST_NOEXCEPT
template<class Element , class... T>
std::add_const< Element >::type *	try_get_ptr (variant< T... > const &from) BOOST_NOEXCEPT
template<class Result , class... T, class... Visitors>
Result	visit (variant< T... > &variant, Visitors &&...visitors)
template<class Result , class... T, class... Visitors>
Result	visit (variant< T... > const &variant, Visitors &&...visitors)
template<class Element , class Allocator >
bool	operator== (vector< Element, Allocator > const &left, vector< Element, Allocator > const &right)
SILICIUM_USE_RESULT error_or< std::size_t >	write (native_file_descriptor file, memory_range data)
SILICIUM_USE_RESULT boost::system::error_code	write_file (native_path_string name, memory_range data)

Typedef Documentation

typedef basic_c_string<char> Si::c_string

typedef basic_c_string<wchar_t> Si::cw_string

typedef detail::basic_dynamic_library< linux::dynamic_library_impl > Si::dynamic_library

template<class... T>

using Si::fast_variant = typedef variant<T...>

typedef iterator_range<char const *> Si::memory_range

typedef iterator_range<char *> Si::mutable_memory_range

typedef char Si::native_path_char

typedef os_c_string Si::native_path_string

typedef boost::container::string Si::noexcept_string

typedef c_string Si::os_c_string

typedef char Si::os_char

typedef noexcept_string Si::os_string

typedef std::uintptr_t Si::uintptr_t

Enumeration Type Documentation

enum Si::byte : boost::uint8_t

strong

Enumerator
minimum
zero
one
maximum

enum Si::environment_inheritance

strong

Enumerator
inherit
no_inherit

enum Si::file_notification_type

strong

Enumerator
add
remove
move_self
remove_self
change_content
change_metadata
change_content_or_metadata

Function Documentation

template<class Visitor , class Variant >

auto Si::apply_visitor	(	Visitor &&	visitor,
		Variant &&	variant
	)		-> typename std::decay<Visitor>::type::result_type

template<class Iterator >

BOOST_CONSTEXPR Iterator const& Si::begin

(

iterator_range< Iterator > const &

range

)

Si::BOOST_STATIC_ASSERT

(

is_handle< process_handle >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< memory_range >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< mutable_memory_range >::value

)

Si::BOOST_STATIC_ASSERT

(

sizeof(dynamic_library)

= =sizeof(void *)

)

Si::BOOST_STATIC_ASSERT

(

is_handle< dynamic_library >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< char >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< int >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< long >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< float >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< void * >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< int * >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< int(*)()>::value

)

Si::BOOST_STATIC_ASSERT

(

!is_handle< int & >::value

)

Si::BOOST_STATIC_ASSERT

(

!is_handle< int const >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< nothing >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< std::unique_ptr< int >>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< file_notification >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< c_string >::value

)

Si::BOOST_STATIC_ASSERT

(

sizeof(error_code<>)

= =sizeof(void *)

)

Si::BOOST_STATIC_ASSERT

(

is_handle< cw_string >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< file_handle >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< path_segment >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< function< void()>>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< relative_path >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< path >::value

)

Si::BOOST_STATIC_ASSERT

(

Si::is_handle< absolute_path >::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< optional< int >>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< optional< int * >>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< optional< int const * >>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< optional< nothing >>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< error_or< nothing >>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< optional< int & >>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< error_or< int >>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< optional< int const & >>::value

)

Si::BOOST_STATIC_ASSERT

(

is_handle< error_or< std::unique_ptr< int >>>::value

)

Si::BOOST_STATIC_ASSERT

(

sizeof(optional< boost::int8_t >)

= =2

)

Si::BOOST_STATIC_ASSERT

(

sizeof(optional< boost::int16_t >)

= =4

)

Si::BOOST_STATIC_ASSERT

(

sizeof(optional< boost::uint32_t >)

= =(2 *sizeof(boost::uint32_t))

)

Si::BOOST_STATIC_ASSERT

(

sizeof(optional< char * >)

= =(alignment_of< char * >::value+sizeof(char *))

)

Si::BOOST_STATIC_ASSERT

(

sizeof(optional< boost::int8_t & >)

= =sizeof(boost::int8_t *)

)

Si::BOOST_STATIC_ASSERT

(

is_handle< variant< int >>::value

)

Si::BOOST_STATIC_ASSERT

(

(is_handle< variant< int, nothing >>::value)

)

SILICIUM_USE_RESULT boost::system::error_code Si::create_directories ( absolute_path const &  directories )

inline

template<class T >

T Si::default_construct

(

)

template<class Iterator >

BOOST_CONSTEXPR Iterator const& Si::end

(

iterator_range< Iterator > const &

range

)

template<class T , class U >

T Si::exchange	(	T &	dest,
		U &&	source
	)

template<class T >

bool Si::extract	(	T &	destination,
		optional< T > &&	source
	)

SILICIUM_USE_RESULT error_or<bool> Si::file_exists ( absolute_path const &  file )

inline

Si::error_or<Si::optional<boost::uint64_t> > Si::file_size ( Si::native_file_descriptor  file )

inline

Returns the size of the regular file given by the file descriptor or none if the file is not regular.

template<class To , class From >

To Si::function_ptr_cast

(

From

from

)

template<class Value , class Error >

Value Si::get

(

error_or< Value, Error > &&

value

)

SILICIUM_USE_RESULT absolute_path Si::get_current_working_directory ( )

inline

SILICIUM_USE_RESULT boost::system::error_code Si::get_last_error ( )

inline

std::size_t Si::hash_value ( byte  value )

inline

template<class UnderlyingErrorCode , class UnderlyingCategory >

std::size_t Si::hash_value

(

error_code< UnderlyingErrorCode, UnderlyingCategory > const &

value

)

std::size_t Si::hash_value ( path_segment const &  value )

inline

SILICIUM_USE_RESULT std::size_t Si::hash_value ( relative_path const &  value )

inline

std::size_t Si::hash_value ( path const &  value )

inline

SILICIUM_USE_RESULT std::size_t Si::hash_value ( absolute_path const &  value )

inline

template<class Value , class Error >

std::size_t Si::hash_value

(

error_or< Value, Error > const &

value

)

template<class T >

SILICIUM_USE_RESULT std::size_t Si::hash_value

(

optional< T > const &

value

)

SILICIUM_USE_RESULT relative_path Si::leaf ( relative_path const &  whole )

inline

path Si::leaf ( path const &  whole )

inline

SILICIUM_USE_RESULT relative_path Si::leaf ( absolute_path const &  whole )

inline

template<class Element = void, class... T>

auto Si::make_array

(

T &&...

elements

)

-> std::array< typename std::conditional< std::is_same<Element, void>::value, std::common_type<T...>, identity<Element> >::type::type, sizeof...(elements) >

template<class Original >

auto Si::make_buffer_observable	(	Original &&	from,
		std::size_t	size
	)		-> buffer_observable<typename std::decay<Original>::type::element_type, typename std::decay<Original>::type>

template<class C >

auto Si::make_c_str_range

(

C const *

str

)

-> iterator_range<C const *>

template<class ContiguousRange >

auto Si::make_contiguous_range

(

ContiguousRange &&

range

)

-> decltype(make_iterator_range(boost::addressof(*std::begin(range)), boost::addressof(*std::end(range))))

template<class Iterator1 , class Iterator2 >

BOOST_CONSTEXPR auto Si::make_iterator_range	(	Iterator1 &&	begin,
		Iterator2 &&	end
	)		-> iterator_range<typename std::decay<Iterator1>::type>

template<class Range >

auto Si::make_iterator_range

(

Range &&

range

)

-> decltype(make_iterator_range(std::begin(range), std::end(range)))

template<class Byte , class DestType = typename copy_const<char, Byte>::type>

auto Si::make_memory_range	(	Byte *	begin,
		Byte *	end
	)		-> iterator_range<DestType *>

template<class Byte >

auto Si::make_memory_range	(	Byte *	data,
		std::size_t	size
	)		-> iterator_range<Byte *>

template<class ContiguousRange >

auto Si::make_memory_range

(

ContiguousRange &&

range

)

-> decltype(make_memory_range(boost::addressof(*std::begin(range)), boost::addressof(*std::end(range))))

template<class T >

SILICIUM_USE_RESULT Si::optional<typename std::decay<T>::type> Si::make_optional

(

T &&

value

)

template<class Pointee >

auto Si::make_ptr_adaptor

(

Pointee &&

value

)

-> ptr_adaptor<typename std::decay<Pointee>::type>

template<class CharRange >

auto Si::make_range_from_string_like

(

CharRange &&

range

)

-> CharRange

template<class Char >

auto Si::make_range_from_string_like

(

Char const *

c_str

)

-> decltype(make_c_str_range(c_str))

template<class BidirectionalRange >

auto Si::make_range_value

(

BidirectionalRange &&

range

)

-> range_value<typename std::decay<BidirectionalRange>::type>

template<class T , class... Args>

auto Si::make_unique

(

Args &&...

args

)

-> std::unique_ptr<T>

template<class ErrorOr , class OnValue , class CleanErrorOr = typename std::decay<ErrorOr>::type, class = typename std::enable_if<is_error_or<CleanErrorOr>::value, void>::type>

auto Si::map	(	ErrorOr &&	maybe,
		OnValue &&	on_value
	)		-> error_or<decltype(std::forward<OnValue>(on_value)(std::forward<ErrorOr>(maybe).get()))>

template<class T >

std::remove_reference<T>::type&& Si::move

(

T &&

ref

)

template<class T , class Result = typename std::conditional< !Si::is_nothrow_move_constructible<T>::value && Si::is_copy_constructible<T>::value, const T &, T && >::type>

BOOST_CONSTEXPR Result Si::move_if_noexcept

(

T &

x

)

template<class ComparableToPath >

bool Si::operator!= ( path_segment const &  left, ComparableToPath const &  right  )

inline

template<class ComparableToPath >

bool Si::operator!= ( ComparableToPath const &  left, path_segment const &  right  )

inline

template<class ComparableToPath >

SILICIUM_USE_RESULT bool Si::operator!= ( relative_path const &  left, ComparableToPath const &  right  )

inline

template<class ComparableToPath >

bool Si::operator!= ( path const &  left, ComparableToPath const &  right  )

inline

template<class ComparableToPath >

SILICIUM_USE_RESULT bool Si::operator!= ( ComparableToPath const &  left, relative_path const &  right  )

inline

template<class ComparableToPath >

bool Si::operator!= ( ComparableToPath const &  left, path const &  right  )

inline

template<class ComparableToPath >

SILICIUM_USE_RESULT bool Si::operator!= ( absolute_path const &  left, ComparableToPath const &  right  )

inline

template<class ComparableToPath >

SILICIUM_USE_RESULT bool Si::operator!= ( ComparableToPath const &  left, absolute_path const &  right  )

inline

template<class Anything , class Value , class Error >

bool Si::operator!=	(	Anything const &	left,
		error_or< Value, Error > const &	right
	)

template<class Anything , class Value , class Error >

bool Si::operator!=	(	error_or< Value, Error > const &	left,
		Anything const &	right
	)

template<class T >

SILICIUM_USE_RESULT bool Si::operator!=	(	optional< T > const &	left,
		optional< T > const &	right
	)

template<class... T>

bool Si::operator!=	(	variant< T... > const &	left,
		variant< T... > const &	right
	)

relative_path Si::operator/ ( path_segment const &  front, path_segment const &  back  )

inline

relative_path Si::operator/ ( relative_path const &  front, path_segment const &  back  )

inline

absolute_path Si::operator/ ( absolute_path const &  front, path_segment const &  back  )

inline

path Si::operator/ ( path const &  front, path const &  back  )

inline

SILICIUM_USE_RESULT relative_path Si::operator/ ( relative_path const &  front, relative_path const &  back  )

inline

SILICIUM_USE_RESULT absolute_path Si::operator/ ( absolute_path const &  front, relative_path const &  back  )

inline

template<std::size_t N>

SILICIUM_USE_RESULT absolute_path Si::operator/ ( absolute_path const &  front, absolute_path::char_type const (&)  literal[N]  )

inline

bool Si::operator< ( path_segment const &  left, path_segment const &  right  )

inline

SILICIUM_USE_RESULT bool Si::operator< ( relative_path const &  left, relative_path const &  right  )

inline

bool Si::operator< ( path const &  left, path const &  right  )

inline

SILICIUM_USE_RESULT bool Si::operator< ( absolute_path const &  left, absolute_path const &  right  )

inline

template<class Value , class Error >

bool Si::operator<	(	error_or< Value, Error > const &	left,
		error_or< Value, Error > const &	right
	)

template<class T >

SILICIUM_USE_RESULT bool Si::operator<	(	optional< T > const &	left,
		optional< T > const &	right
	)

template<class Char >

std::basic_ostream<Char>& Si::operator<<	(	std::basic_ostream< Char > &	out,
		byte	value
	)

template<class UnderlyingErrorCode , class UnderlyingCategory >

std::ostream& Si::operator<<	(	std::ostream &	out,
		error_code< UnderlyingErrorCode, UnderlyingCategory > const &	value
	)

std::ostream& Si::operator<< ( std::ostream &  out, path_segment const &  p  )

inline

std::ostream& Si::operator<< ( std::ostream &  out, relative_path const &  p  )

inline

std::ostream& Si::operator<< ( std::ostream &  out, path const &  p  )

inline

std::ostream& Si::operator<< ( std::ostream &  out, absolute_path const &  p  )

inline

template<class Value , class Error >

std::ostream& Si::operator<<	(	std::ostream &	out,
		error_or< Value, Error > const &	value
	)

std::ostream& Si::operator<< ( std::ostream &  out, none_t const &    )

inline

template<class T >

std::ostream& Si::operator<<	(	std::ostream &	out,
		optional< T > const &	value
	)

template<class... T>

bool Si::operator<=	(	variant< T... > const &	left,
		variant< T... > const &	right
	)

template<class BidirectionalRange1 , class BidirectionalRange2 >

bool Si::operator==	(	range_value< BidirectionalRange1 > const &	left,
		range_value< BidirectionalRange2 > const &	right
	)

bool Si::operator== ( none_t  , none_t    )

inline

template<class UnderlyingErrorCode , class UnderlyingCategory >

bool Si::operator==	(	error_code< UnderlyingErrorCode, UnderlyingCategory > const &	left,
		error_code< UnderlyingErrorCode, UnderlyingCategory > const &	right
	)

template<class ComparableToPath >

bool Si::operator== ( path_segment const &  left, ComparableToPath const &  right  )

inline

template<class ComparableToPath >

bool Si::operator== ( ComparableToPath const &  left, path_segment const &  right  )

inline

template<class Element , class Allocator >

bool Si::operator==	(	vector< Element, Allocator > const &	left,
		vector< Element, Allocator > const &	right
	)

bool Si::operator== ( path_segment const &  left, boost::filesystem::path const &  right  )

inline

bool Si::operator== ( boost::filesystem::path const &  left, path_segment const &  right  )

inline

bool Si::operator== ( path_segment const &  left, path_segment const &  right  )

inline

template<class ComparableToPath >

SILICIUM_USE_RESULT bool Si::operator== ( relative_path const &  left, ComparableToPath const &  right  )

inline

template<class ComparableToPath >

SILICIUM_USE_RESULT bool Si::operator== ( ComparableToPath const &  left, relative_path const &  right  )

inline

template<class ComparableToPath >

bool Si::operator== ( path const &  left, ComparableToPath const &  right  )

inline

SILICIUM_USE_RESULT bool Si::operator== ( relative_path const &  left, boost::filesystem::path const &  right  )

inline

template<class ComparableToPath >

bool Si::operator== ( ComparableToPath const &  left, path const &  right  )

inline

SILICIUM_USE_RESULT bool Si::operator== ( boost::filesystem::path const &  left, relative_path const &  right  )

inline

bool Si::operator== ( path const &  left, boost::filesystem::path const &  right  )

inline

SILICIUM_USE_RESULT bool Si::operator== ( relative_path const &  left, relative_path const &  right  )

inline

bool Si::operator== ( boost::filesystem::path const &  left, path const &  right  )

inline

bool Si::operator== ( nothing const &  , nothing const &    )

inline

bool Si::operator== ( path const &  left, path const &  right  )

inline

template<class ComparableToPath >

SILICIUM_USE_RESULT bool Si::operator== ( absolute_path const &  left, ComparableToPath const &  right  )

inline

template<class ComparableToPath >

SILICIUM_USE_RESULT bool Si::operator== ( ComparableToPath const &  left, absolute_path const &  right  )

inline

SILICIUM_USE_RESULT bool Si::operator== ( absolute_path const &  left, boost::filesystem::path const &  right  )

inline

SILICIUM_USE_RESULT bool Si::operator== ( boost::filesystem::path const &  left, absolute_path const &  right  )

inline

SILICIUM_USE_RESULT bool Si::operator== ( absolute_path const &  left, absolute_path const &  right  )

inline

template<class T >

SILICIUM_USE_RESULT bool Si::operator==	(	optional< T > const &	left,
		optional< T > const &	right
	)

template<class Value , class Error , class Anything >

bool Si::operator==	(	error_or< Value, Error > const &	left,
		Anything const &	right
	)

template<class T >

SILICIUM_USE_RESULT bool Si::operator==	(	optional< T > const &	left,
		T const &	right
	)

template<class Anything , class Value , class Error , class = typename std::enable_if<!is_error_or<Anything>::value, void>::type>

bool Si::operator==	(	Anything const &	left,
		error_or< Value, Error > const &	right
	)

template<class T >

SILICIUM_USE_RESULT bool Si::operator==	(	T const &	left,
		optional< T > const &	right
	)

template<class T >

SILICIUM_USE_RESULT bool Si::operator==	(	none_t const &	,
		optional< T > const &	right
	)

template<class T >

SILICIUM_USE_RESULT bool Si::operator==	(	optional< T > const &	left,
		none_t const &
	)

template<class... T>

bool Si::operator>	(	variant< T... > const &	left,
		variant< T... > const &	right
	)

template<class... T>

bool Si::operator>=	(	variant< T... > const &	left,
		variant< T... > const &	right
	)

std::istream& Si::operator>> ( std::istream &  in, absolute_path &  p  )

inline

SILICIUM_USE_RESULT relative_path Si::parent ( relative_path const &  whole )

inline

path Si::parent ( path const &  whole )

inline

SILICIUM_USE_RESULT optional<absolute_path> Si::parent ( absolute_path const &  whole )

inline

template<class Iterator1 , class Iterator2 >

BOOST_CONSTEXPR bool Si::pointing_to_same_subrange	(	iterator_range< Iterator1 > const &	left,
		iterator_range< Iterator2 > const &	right
	)

template<class Iterator >

BOOST_CONSTEXPR Iterator const& Si::range_begin

(

iterator_range< Iterator > const &

range

)

error_or<std::size_t> Si::read ( native_file_descriptor  file, mutable_memory_range  destination  )

inline

SILICIUM_USE_RESULT boost::system::error_code Si::recreate_directories ( absolute_path const &  directories )

inline

SILICIUM_USE_RESULT error_or<boost::uint64_t> Si::remove_all ( absolute_path const &  directories )

inline

SILICIUM_USE_RESULT boost::system::error_code Si::remove_file ( absolute_path const &  name )

inline

SILICIUM_USE_RESULT boost::system::error_code Si::set_environment_variable	(	os_c_string	key,
		os_c_string	value
	)

template<class First , class... Sequence>

auto Si::then	(	First &&	first,
		Sequence &&...	actions
	)		-> decltype(std::forward<First>(first)())

SILICIUM_NORETURN void Si::throw_error ( boost::system::error_code  error )

inline

SILICIUM_NORETURN void Si::throw_error ( std::error_code  error )

inline

template<class UnderlyingErrorCode , class UnderlyingCategory >

SILICIUM_NORETURN void Si::throw_error ( error_code< UnderlyingErrorCode, UnderlyingCategory >  error )

inline

void Si::throw_last_error ( )

inline

noexcept_string Si::to_noexcept_string ( std::string const &  str )

inline

noexcept_string&& Si::to_noexcept_string ( noexcept_string &&  str )

inline

noexcept_string Si::to_noexcept_string ( noexcept_string const &  str )

inline

os_string Si::to_os_string ( os_string  original )

inline

os_string Si::to_os_string ( std::string const &  original )

inline

os_string Si::to_os_string ( char const *  original )

inline

os_string Si::to_os_string ( char const *  begin, char const *  end  )

inline

template<class T >

auto Si::to_shared

(

T &&

t

)

-> std::shared_ptr<typename std::decay<T>::type>

template<class T >

auto Si::to_unique

(

T &&

t

)

-> std::unique_ptr<typename std::decay<T>::type>

template<class Pointee , class T >

auto Si::to_unique

(

T &&

t

)

-> std::unique_ptr<Pointee>

std::string Si::to_utf8_string ( os_string const &  str )

inline

template<class Element , class... T>

boost::optional<Element> Si::try_get

(

variant< T... > &

from

)

template<class Element , class... T>

Element* Si::try_get_ptr

(

variant< T... > &

from

)

template<class Element , class... T>

std::add_const<Element>::type* Si::try_get_ptr

(

variant< T... > const &

from

)

template<class Result , class... T, class... Visitors>

Result Si::visit	(	variant< T... > &	variant,
		Visitors &&...	visitors
	)

template<class Result , class... T, class... Visitors>

Result Si::visit	(	variant< T... > const &	variant,
		Visitors &&...	visitors
	)

SILICIUM_USE_RESULT error_or<std::size_t> Si::write ( native_file_descriptor  file, memory_range  data  )

inline

SILICIUM_USE_RESULT boost::system::error_code Si::write_file ( native_path_string  name, memory_range  data  )

inline