ClientSocketHandle.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Socket_ClientSocketHandle_
#define HH_SENF_Socket_ClientSocketHandle_ 1

// Custom includes
#include <boost/call_traits.hpp>
#include <boost/range/iterator.hpp>
#include <boost/type_traits/is_convertible.hpp>
#include <boost/optional.hpp>
#include "SocketHandle.hh"

//#include "ClientSocketHandle.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    //\{

    template <class SPolicy> class ServerSocketHandle;

    template <class SPolicy>
    class ClientSocketHandle
        : public SocketHandle<SPolicy>
    {
    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef typename SPolicy::AddressingPolicy::Address Address;

        typedef typename boost::call_traits<Address>::param_type AddressParam;

        typedef ServerSocketHandle<SPolicy> ServerHandle;

        //-////////////////////////////////////////////////////////////////////////
        //\{

        // default default constructor
        // default copy constructor
        // default copy assignment
        // default destructor

        // here to implement
        ClientSocketHandle();

        // conversion constructors
#       ifndef DOXYGEN
        template <class OtherPolicy>
        ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
                           typename SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type * = 0);
#       else
        ClientSocketHandle(ClientSocketHandle<OtherPolicy> other);
#       endif

#       ifndef DOXYGEN
        template <class OtherPolicy>
        typename SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type const &
        operator=(ClientSocketHandle<OtherPolicy> other);
#       else
        template <class OtherPolicy>
        ClientSocketHandle<OtherPolicy> const & operator=(ClientSocketHandle<OtherPolicy> other);
#       endif

        //\}
        //-////////////////////////////////////////////////////////////////////////

        //-////////////////////////////////////////////////////////////////////////
        //\{

        std::string  read         (unsigned limit=0);

#       ifndef DOXYGEN
        template <class ForwardWritableRange>
        typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned>,
        typename boost::range_iterator<ForwardWritableRange>::type>::type
        read(ForwardWritableRange const & range);
#       else
        template <class ForwardWritableRange>
        typename boost::range_iterator<ForwardWritableRange>::type
                     read         (ForwardWritableRange const & range);

#       endif
#       ifndef DOXYGEN
        template <class ForwardWritableRange>
        typename boost::disable_if< boost::is_convertible<ForwardWritableRange,unsigned>,
        typename boost::range_iterator<ForwardWritableRange>::type>::type
        read(ForwardWritableRange & range);
#       else
        template <class ForwardWritableRange>
        typename boost::range_iterator<ForwardWritableRange>::type
                     read         (ForwardWritableRange & range);

#       endif
        template <class Sequence>
        void         read         (Sequence & container, unsigned limit);

        char *       read         (char * start, char * end);

        std::pair<std::string, Address>
                     readfrom     (unsigned limit=0);
        template <class ForwardWritableRange>
        typename boost::range_iterator<ForwardWritableRange const>::type
                     readfrom     (ForwardWritableRange const & range, Address & from);

        template <class ForwardWritableRange>
        typename boost::range_iterator<ForwardWritableRange>::type
                     readfrom     (ForwardWritableRange & range, Address & from);

        template <class Sequence>
        void         readfrom     (Sequence & container, Address & from, unsigned limit);

        char *       readfrom     (char * start, char * end, Address & from);

        template <class ForwardReadableRange>
        typename boost::range_const_iterator<ForwardReadableRange const>::type
                     write        (ForwardReadableRange const & range);
        char const * write        (char const * start, char const * end);

        template <class ForwardReadableRange>
        typename boost::range_const_iterator<ForwardReadableRange const>::type
                     writeto      (AddressParam addr, ForwardReadableRange const & range);
        char const * writeto      (AddressParam addr, char const * start, char const * end);

        //\}

        //-////////////////////////////////////////////////////////////////////////

        boost::optional<typename SPolicy::ReadPolicy::Buffer> dequeue();

        void release();                 

        boost::optional<typename SPolicy::WritePolicy::Buffer> enqueue();

        bool send();                       

        //\}
        //-////////////////////////////////////////////////////////////////////////
        //\{

        void         connect      (AddressParam addr) const;

        void         bind         (AddressParam addr) const;

        Address      peer         () const;
        void         peer         (Address & addr) const;

        Address      local        () const;
        void         local        (Address & addr) const;

        //\}

        static ClientSocketHandle cast_static(FileHandle handle);
        static ClientSocketHandle cast_dynamic(FileHandle handle);

        // we need to override both since SocketHandle is *not* polymorphic
        void state(SocketStateMap & map, unsigned lod=0);
        std::string dumpState(unsigned lod=0);

        unsigned available();

    protected:
        ClientSocketHandle(FileHandle other, bool isChecked);
        explicit ClientSocketHandle(std::unique_ptr<SocketBody> body);

    private:
        friend class senf::ServerSocketHandle<SPolicy>;
    };

    //\}
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
//#include "ClientSocketHandle.cci"
#include "ClientSocketHandle.ct"
#include "ClientSocketHandle.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// comment-column: 40
// End: