// $Id$
//
// Copyright (C) 2006
// Fraunhofer Institute for Open Communication Systems (FOKUS)
//
// The contents of this file are subject to the Fraunhofer FOKUS Public License
// Version 1.0 (the "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at 
// http://senf.berlios.de/license.html
//
// The Fraunhofer FOKUS Public License Version 1.0 is based on, 
// but modifies the Mozilla Public License Version 1.1.
// See the full license text for the amendments.
//
// Software distributed under the License is distributed on an "AS IS" basis, 
// WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 
// for the specific language governing rights and limitations under the License.
//
// The Original Code is Fraunhofer FOKUS code.
//
// The Initial Developer of the Original Code is Fraunhofer-Gesellschaft e.V. 
// (registered association), Hansastraße 27 c, 80686 Munich, Germany.
// All Rights Reserved.
//
// Contributor(s):
//   Stefan Bund <g0dil@berlios.de>

/** \file
    \brief ClientSocketHandle inline template implementation
 */

#include "ClientSocketHandle.ih"

// Custom includes
#include <typeinfo>

#define prefix_ inline
//-/////////////////////////////////////////////////////////////////////////////////////////////////

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::detail::ReadRange<Policy,ForwardWritableRange,true>

template <class Handle, class ForwardWritableRange>
prefix_ typename boost::range_iterator<ForwardWritableRange>::type
senf::detail::ReadRange<Handle,ForwardWritableRange,true>::read(Handle & handle,
                                                                ForwardWritableRange & range)
{
    typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
    char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
    return i + (handle.read( ic,
                             reinterpret_cast<char*>(storage_iterator(boost::end(range))) )
                - ic);
}

template <class Handle, class ForwardWritableRange>
prefix_ typename boost::range_iterator<ForwardWritableRange>::type
senf::detail::ReadRange<Handle,ForwardWritableRange,true>::
readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
{
    typename boost::range_iterator<ForwardWritableRange>::type const i (boost::begin(range));
    char * const ic (reinterpret_cast<char*>(storage_iterator(i)));
    return i + (handle.readfrom( ic,
                                 reinterpret_cast<char*>(storage_iterator(boost::end(range))),
                                 addr )
                - ic);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::detail::WriteRange<Handle, ForwardReadableRange, true>

template <class Handle, class ForwardReadableRange>
prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
write(Handle & handle, ForwardReadableRange & range)
{
    typename boost::range_const_iterator<ForwardReadableRange>::type i
        (boost::const_begin(range));
    char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
    std::advance(i, handle.write(ic,
                                 reinterpret_cast<char const *>(
                                     storage_iterator(boost::const_end(range)))) - ic);
    return i;
}

template <class Handle, class ForwardReadableRange>
prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
senf::detail::WriteRange<Handle, ForwardReadableRange, true>::
writeto(Handle & handle, ForwardReadableRange & range, typename Handle::Address const & addr)
{
    typename boost::range_const_iterator<ForwardReadableRange>::type i
        (boost::const_begin(range));
    char const * const ic (reinterpret_cast<char const *>(storage_iterator(i)));
    std::advance(i, handle.writeto(addr, ic,
                                   reinterpret_cast<char const *>(
                                       storage_iterator(boost::const_end(range)))) - ic);
    return i;
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::ClientSocketHandle<Policy>

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// structors

template <class SPolicy>
prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle()
{}

#ifndef DOXYGEN
template <class SPolicy>
template <class OtherPolicy>
prefix_ senf::ClientSocketHandle<SPolicy>::
ClientSocketHandle(ClientSocketHandle<OtherPolicy> other,
                   typename SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type *)
    : SocketHandle<SPolicy>(other,true)
{}
#else
template <class SPolicy>
template <class OtherPolicy>
prefix_ senf::ClientSocketHandle<SPolicy>::
ClientSocketHandle(ClientSocketHandle<OtherPolicy> other)
{}
#endif

template <class SPolicy>
prefix_ senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(FileHandle other, bool isChecked)
    : SocketHandle<SPolicy>(other, isChecked)
{}

template <class SPolicy>
prefix_
senf::ClientSocketHandle<SPolicy>::ClientSocketHandle(std::auto_ptr<SocketBody> body)
    : SocketHandle<SPolicy>(body)
{}

#ifndef DOXYGEN
template <class SPolicy>
template <class OtherPolicy>
prefix_ typename senf::SocketHandle<SPolicy>::template IsCompatible<OtherPolicy>::type const &
senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
{
    assign(other);
    return *this;
}
#else
template <class SPolicy>
template <class OtherPolicy>
prefix_ OtherPolicy const &
senf::ClientSocketHandle<SPolicy>::operator=(ClientSocketHandle<OtherPolicy> other)
{}
#endif

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// reading and writing

// senf::ClientSocketHandle<SPolicy>::read

#ifndef DOXYGEN

template <class SPolicy>
template <class ForwardWritableRange>
prefix_ typename boost::disable_if<boost::is_convertible<ForwardWritableRange,unsigned>,
typename boost::range_iterator<ForwardWritableRange>::type>::type
senf::ClientSocketHandle<SPolicy>::read(ForwardWritableRange const & range)
{
    return detail::ReadRange<
        ClientSocketHandle<SPolicy>,
        ForwardWritableRange const,
        contiguous_storage_iterator<
            typename boost::range_iterator<ForwardWritableRange>::type
        >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
        >::read(*this, range);
}
#else
template <class SPolicy>
template <class ForwardWritableRange>
prefix_ typename boost::range_iterator<ForwardWritableRange>::type
senf::ClientSocketHandle<SPolicy>::
read(ForwardWritableRange const & range)
{}
#endif

#ifndef DOXYGEN
template <class SPolicy>
template <class ForwardWritableRange>
prefix_ typename boost::disable_if<boost::is_convertible<ForwardWritableRange,unsigned>,
typename boost::range_iterator<ForwardWritableRange>::type>::type
senf::ClientSocketHandle<SPolicy>::read(ForwardWritableRange & range)
{
    return detail::ReadRange<
        ClientSocketHandle<SPolicy>,
        ForwardWritableRange,
        contiguous_storage_iterator<
            typename boost::range_iterator<ForwardWritableRange>::type
        >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
        >::read(*this, range);
}
#else
template <class SPolicy>
template <class ForwardWritableRange>
prefix_ typename boost::range_iterator<ForwardWritableRange>::type
senf::ClientSocketHandle<SPolicy>::
read(ForwardWritableRange & range)
{}
#endif

template <class SPolicy>
prefix_ char * senf::ClientSocketHandle<SPolicy>::read(char * start, char * end)
{
    return start + SPolicy::ReadPolicy::read(*this, start, end-start);
}

// senf::ClientSocketHandle<SPolicy>::readfrom

template <class SPolicy>
template <class ForwardWritableRange>
prefix_ typename boost::range_iterator<ForwardWritableRange const>::type
senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange const & range, Address & from)
{
    return detail::ReadRange<
        ClientSocketHandle<SPolicy>,
        ForwardWritableRange const,
        contiguous_storage_iterator<
            typename boost::range_iterator<ForwardWritableRange>::type
        >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
        >::readfrom(*this, range, from);
}

template <class SPolicy>
template <class ForwardWritableRange>
prefix_ typename boost::range_iterator<ForwardWritableRange>::type
senf::ClientSocketHandle<SPolicy>::readfrom(ForwardWritableRange & range, Address & from)
{
    return detail::ReadRange<
        ClientSocketHandle<SPolicy>,
        ForwardWritableRange,
        contiguous_storage_iterator<
            typename boost::range_iterator<ForwardWritableRange>::type
        >::value && sizeof(typename boost::range_value<ForwardWritableRange>::type)==sizeof(char)
        >::readfrom(*this, range, from);
}

template <class SPolicy>
prefix_ char * senf::ClientSocketHandle<SPolicy>::readfrom(char * start, char * end,
                                                          Address & from)
{
    return start + SPolicy::ReadPolicy::readfrom(*this, start, end-start, from);
}

// senf::ClientSocketHandle<SPolicy>::write

template <class SPolicy>
template <class ForwardReadableRange>
prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
senf::ClientSocketHandle<SPolicy>::write(ForwardReadableRange const & range)
{
    return detail::WriteRange<
        ClientSocketHandle<SPolicy>,
        ForwardReadableRange const,
        contiguous_storage_iterator<
            typename boost::range_iterator<ForwardReadableRange>::type
        >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
        >::write(*this, range);
}

template <class SPolicy>
prefix_ char const * senf::ClientSocketHandle<SPolicy>::write(char const * start, char const * end)
{
    return start + SPolicy::WritePolicy::write(*this, start, end-start);
}

// senf::ClientSocketHandle<SPolicy>::writeto

template <class SPolicy>
template <class ForwardReadableRange>
prefix_ typename boost::range_const_iterator<ForwardReadableRange const>::type
senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr, ForwardReadableRange const & range)
{
    return detail::WriteRange<
        ClientSocketHandle<SPolicy>,
        ForwardReadableRange const,
        contiguous_storage_iterator<
            typename boost::range_iterator<ForwardReadableRange>::type
        >::value && sizeof(typename boost::range_value<ForwardReadableRange>::type)==sizeof(char)
        >::writeto(*this, range, addr);
}

template <class SPolicy>
prefix_ char const * senf::ClientSocketHandle<SPolicy>::writeto(AddressParam addr,
                                                               char const * start,
                                                               char const * end)
{
    return start + SPolicy::WritePolicy::writeto(*this, addr, start, end-start);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// addressing

// senf::ClientSocketHandle<SPolicy>::peer

template <class SPolicy>
prefix_ typename SPolicy::AddressingPolicy::Address
senf::ClientSocketHandle<SPolicy>::peer()
    const
{
    typename SPolicy::AddressingPolicy::Address addr;
    this->peer(addr);
    return addr;
}

template <class SPolicy>
prefix_ void senf::ClientSocketHandle<SPolicy>::
peer(typename SPolicy::AddressingPolicy::Address & addr)
    const
{
    SPolicy::AddressingPolicy::peer(*this, addr);
}

// senf::ClientSocketHandle<SPolicy>::local

template <class SPolicy>
prefix_ typename SPolicy::AddressingPolicy::Address
senf::ClientSocketHandle<SPolicy>::local()
    const
{
    typename SPolicy::AddressingPolicy::Address addr;
    this->local(addr);
    return addr;
}

template <class SPolicy>
prefix_ void senf::ClientSocketHandle<SPolicy>::
local(typename SPolicy::AddressingPolicy::Address & addr)
    const
{
    SPolicy::AddressingPolicy::local(*this,addr);
}

// senf::ClientSocketHandle<SPolicy>::connect

template <class SPolicy>
prefix_ void senf::ClientSocketHandle<SPolicy>::connect(AddressParam addr)
    const
{
    SPolicy::AddressingPolicy::connect(*this, addr);
}

// senf::ClientSocketHandle<SPolicy>::bind

template <class SPolicy>
prefix_ void senf::ClientSocketHandle<SPolicy>::bind(AddressParam addr)
    const
{
    SPolicy::AddressingPolicy::bind(*this, addr);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// Casting

template <class SPolicy>
prefix_ senf::ClientSocketHandle<SPolicy>
senf::ClientSocketHandle<SPolicy>::cast_static(FileHandle handle)
{
    return ClientSocketHandle(handle, true);
}

template <class SPolicy>
prefix_ senf::ClientSocketHandle<SPolicy>
senf::ClientSocketHandle<SPolicy>::cast_dynamic(FileHandle handle)
{
    SocketHandle<SPolicy> h (SocketHandle<SPolicy>::cast_dynamic(handle));
    if (static_cast<SocketBody&>(FileHandle::body(h)).isServer())
        throw std::bad_cast();
    return cast_static(handle);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// State information

template <class SPolicy>
prefix_ void senf::ClientSocketHandle<SPolicy>::state(SocketStateMap & map, unsigned lod)
{
    map["handle"] = prettyName(typeid(*this));
    if (this->valid()) {
        map["valid"] << "true";
        this->body().state(map,lod);
    } else
        map["valid"] << "false";
}

template <class SPolicy>
prefix_ std::string senf::ClientSocketHandle<SPolicy>::dumpState(unsigned lod)
{
    SocketStateMap map;
    state(map,lod);
    return detail::dumpState(map);
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#undef prefix_


// 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: