// $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 non-inline template implementation
 */

#include "ClientSocketHandle.ih"

// Custom includes
#include <algorithm>
#include <boost/utility/value_init.hpp>
#include <senf/Utils/Buffer.hh>

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

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>

template <class Handle, class ForwardWritableRange, bool IsContiguous>
prefix_ typename boost::range_iterator<ForwardWritableRange>::type
senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>::
read(Handle & handle, ForwardWritableRange & range)
{
    typename boost::range_size<ForwardWritableRange>::type nread (boost::size(range));
    SENF_SCOPED_BUFFER(char, buffer, nread);
    return std::copy(buffer, handle.read(buffer,buffer+nread), boost::begin(range));
}

template <class Handle, class ForwardWritableRange, bool IsContiguous>
prefix_ typename boost::range_iterator<ForwardWritableRange>::type
senf::detail::ReadRange<Handle,ForwardWritableRange,IsContiguous>::
readfrom(Handle & handle, ForwardWritableRange & range, typename Handle::Address & addr)
{
    typename boost::range_size<ForwardWritableRange>::type nread (boost::size(range));
    SENF_SCOPED_BUFFER(char, buffer, nread);
    return std::copy(buffer, handle.readfrom(buffer,buffer+nread,addr), boost::begin(range));
}

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

template <class Handle, class ForwardReadableRange, bool IsContiguous>
prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
senf::detail::WriteRange<Handle,ForwardReadableRange,IsContiguous>::
write(Handle & handle, ForwardReadableRange & range)
{
    typename boost::range_size<ForwardReadableRange>::type nwrite (boost::size(range));
    typename boost::range_const_iterator<ForwardReadableRange>::type i (boost::begin(range));
    SENF_SCOPED_BUFFER(char, buffer, nwrite);
    std::copy(i, boost::end(range), buffer);
    std::advance(i, handle.write(std::make_pair(buffer, buffer+nwrite)) - buffer);
    return i;
}

template <class Handle, class ForwardReadableRange, bool IsContiguous>
prefix_ typename boost::range_const_iterator<ForwardReadableRange>::type
senf::detail::WriteRange<Handle,ForwardReadableRange,IsContiguous>::
writeto(Handle & handle, ForwardReadableRange & range, typename Handle::Address const & addr)
{
    typename boost::range_size<ForwardReadableRange>::type nwrite (boost::size(range));
    typename boost::range_const_iterator<ForwardReadableRange>::type i (boost::begin(range));
    SENF_SCOPED_BUFFER(char, buffer, nwrite);
    std::copy(i, boost::end(range), buffer);
    std::advance(i, handle.writeto(std::make_pair(buffer, buffer+nwrite), addr) - buffer);
    return i;
}

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

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

// senf::ClientSocketHandle<Policy>::read

template <class SPolicy>
prefix_ std::string senf::ClientSocketHandle<SPolicy>::read(unsigned limit)
{
    std::string rv;
    this->read(rv, limit);
    return rv;
}

template <class SPolicy>
template <class Sequence>
prefix_ void senf::ClientSocketHandle<SPolicy>::read(Sequence & container, unsigned limit)
{
    if (limit == 0)
        limit = available();
    container.resize(limit);
    container.erase(read( std::make_pair(container.begin(), container.end()) ),
                    container.end());
}

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

template <class SPolicy>
prefix_ std::pair<std::string, typename SPolicy::AddressingPolicy::Address>
senf::ClientSocketHandle<SPolicy>::readfrom(unsigned limit)
{
    std::string rv;
    boost::value_initialized<typename SPolicy::AddressingPolicy::Address> addr;
    this->readfrom(rv, addr.data(), limit);
    return std::make_pair(rv, addr.data());
}

template <class SPolicy>
template <class Sequence>
prefix_ void senf::ClientSocketHandle<SPolicy>::readfrom(Sequence & container, Address & from,
                                                        unsigned limit)
{
    if (limit == 0)
        limit = available();
    container.resize(limit);
    container.erase(readfrom( std::make_pair(container.begin(), container.end()), from ),
                    container.end());
}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
// private members

// senf::ClientSocketHandle<SPolicy>::available

template <class SPolicy>
prefix_ unsigned senf::ClientSocketHandle<SPolicy>::available()
{
    unsigned nread = this->protocol().available();
    if (nread == 0 && this->blocking()) {
        // We have to block explicitly here so we can return the
        // number of bytes available explicitly. If no more date can
        // be expected to arive (i.e. the other end has closed the
        // connection), the socket will always be in the readable
        // state. This is the only case when available() will return
        // 0.
        this->waitReadable();
        nread = this->protocol().available();
    }
    return nread;
}

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