os::posix::net_stack_implementable< T > Class Template Reference

#include <net-stack.h>

Inheritance diagram for os::posix::net_stack_implementable< T >:

Public Types
using	value_type = T

Public Member Functions
Constructors & Destructor
template<typename... Args>
	net_stack_implementable (const char *name, net_interface &interface, Args &&... args)
virtual	~net_stack_implementable ()
Public Member Functions
value_type &	impl (void) const

Public Static Member Functions
using	deferred_sockets_list_t = utils::intrusive_list< class socket, utils::double_list_links, &socket::deferred_links_ >
virtual class socket *	socket (int domain, int type, int protocol)
const char *	name (void) const
void	add_deferred_socket (class socket *sock)
deferred_sockets_list_t &	deferred_sockets_list (void)
template<typename T >
T *	allocate_socket (void)
template<typename T , typename L >
T *	allocate_socket (L &locker)
net_interface &	interface (void) const

Detailed Description

template<typename T>
class os::posix::net_stack_implementable< T >

Definition at line 286 of file net-stack.h.

Member Typedef Documentation

deferred_sockets_list_t

using os::posix::net_stack::deferred_sockets_list_t = utils::intrusive_list<class socket, utils::double_list_links, &socket::deferred_links_>

inherited

Definition at line 132 of file net-stack.h.

value_type

template<typename T >

using os::posix::net_stack_implementable< T >::value_type = T

Definition at line 291 of file net-stack.h.

Constructor & Destructor Documentation

net_stack_implementable()

template<typename T >

template<typename... Args>

os::posix::net_stack_implementable< T >::net_stack_implementable	(	const char *	name,
		net_interface &	interface,
		Args &&...	args
	)

Definition at line 564 of file net-stack.h.

        : net_stack{ impl_instance_, name }, //
          impl_instance_{ interface, std::forward<Args> (args)... }
    {
#if defined(OS_TRACE_POSIX_IO_NET_STACK)
      trace::printf ("net_stack_implementable::%s(\"%s\")=@%p\n", __func__,
                     name_, this);
#endif
    }

References os::trace::printf().

~net_stack_implementable()

template<typename T >

os::posix::net_stack_implementable< T >::~net_stack_implementable

virtual

Definition at line 576 of file net-stack.h.

    {
#if defined(OS_TRACE_POSIX_IO_NET_STACK)
      trace::printf ("net_stack_implementable::%s() @%p %s\n", __func__, this,
                     name_);
#endif
    }

References os::trace::printf().

Member Function Documentation

add_deferred_socket()

void os::posix::net_stack::add_deferred_socket ( class socket *  sock )

inlineinherited

Definition at line 469 of file net-stack.h.

    {
      deferred_sockets_list_.link (*sock);
    }

allocate_socket() [1/2]

template<typename T , typename L >

T * os::posix::net_stack::allocate_socket ( L &  locker )

inherited

Definition at line 518 of file net-stack.h.

    {
      using socket_type = T;
 
      socket_type* sock;
 
      if (deferred_sockets_list_.empty ())
        {
          sock = new socket_type (*this, locker);
        }
      else
        {
          sock = static_cast<socket_type*> (
              deferred_sockets_list_.unlink_head ());
 
          // Call the constructor before reusing the object,
          sock->~socket_type ();
 
          // Placement new, run only the constructor.
          new (sock) socket_type (*this, locker);
 
          // Deallocate all remaining elements in the list.
          while (!deferred_sockets_list_.empty ())
            {
              socket_type* s = static_cast<socket_type*> (
                  deferred_sockets_list_.unlink_head ());
 
              // Call the destructor and the deallocator.
              delete s;
            }
        }
      return sock;
    }

allocate_socket() [2/2]

template<typename T >

T * os::posix::net_stack::allocate_socket ( void  )

inherited

Definition at line 482 of file net-stack.h.

    {
      using socket_type = T;
 
      socket_type* sock;
 
      if (deferred_sockets_list_.empty ())
        {
          sock = new socket_type (*this);
        }
      else
        {
          sock = static_cast<socket_type*> (
              deferred_sockets_list_.unlink_head ());
 
          // Call the constructor before reusing the object,
          sock->~socket_type ();
 
          // Placement new, run only the constructor.
          new (sock) socket_type (*this);
 
          // Deallocate all remaining elements in the list.
          while (!deferred_sockets_list_.empty ())
            {
              socket_type* s = static_cast<socket_type*> (
                  deferred_sockets_list_.unlink_head ());
 
              // Call the destructor and the deallocator.
              delete s;
            }
        }
      return sock;
    }

deferred_sockets_list()

net_stack::deferred_sockets_list_t & os::posix::net_stack::deferred_sockets_list ( void  )

inlineinherited

Definition at line 475 of file net-stack.h.

    {
      return deferred_sockets_list_;
    }

impl()

template<typename T >

net_stack_implementable< T >::value_type & os::posix::net_stack_implementable< T >::impl

(

void

)

const

Definition at line 586 of file net-stack.h.

    {
      return static_cast<value_type&> (impl_);
    }

interface()

net_interface & os::posix::net_stack::interface ( void  ) const

inherited

name()

const char * os::posix::net_stack::name ( void  ) const

inlineinherited

Definition at line 450 of file net-stack.h.

    {
      return name_;
    }

socket()

class socket * os::posix::net_stack::socket ( int  domain, int  type, int  protocol  )

virtualinherited

Definition at line 104 of file net-stack.cpp.

    {
      errno = 0;
 
      return impl ().do_socket (domain, type, protocol);
    }

References os::posix::net_stack_impl::do_socket(), and os::posix::net_stack::impl().

Referenced by os::posix::socket().

---

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

• net-stack.h