resolver.h

Go to the documentation of this file.

// -*- Socket Streams -*-

// Copyright (C) 2003, 2004, 2005 Pedro Lamarão <pedro.lamarao@mndfck.org>

// This file is part of the Socket Streams Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License as published by the
// Free Software Foundation; either version 2.1 of the License
// or (at your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
// USA

#ifndef SOCKETSTREAM_RESOLVER_H
#define SOCKETSTREAM_RESOLVER_H

#include <socketstream/config.h>

#ifndef WIN32
# include <netdb.h>
#endif

#include <socketstream/sockets_base.h>
#include <socketstream/address_exception.h>

namespace ss
{

        class SOCKETSTREAM_API resolver_result_iterator
        {
        public:

                // Assignable
                resolver_result_iterator (resolver_result_iterator const& that)
                : _M_node(that._M_node) {}

                resolver_result_iterator&
                operator= (resolver_result_iterator const& that) {
                        _M_node = that._M_node;
                        return *this;
                }

                // EqualityComparable
                bool
                operator== (resolver_result_iterator const& that) const {
                        return _M_node == that._M_node;
                }

                bool
                operator!= (resolver_result_iterator const& that) const {
                        return _M_node != that._M_node;
                }

                // DefaultConstructible
                resolver_result_iterator () : _M_node(0) {}

                // TrivialIterator

                addrinfo const&
                operator* () const {
                        return *_M_node;
                }

                addrinfo const*
                operator-> () {
                        return _M_node;
                }

                // InputIterator
                resolver_result_iterator&
                operator++ () {
                        _M_node = _M_node->ai_next;
                        return *this;
                }

                resolver_result_iterator
                operator++ (int) {
                        resolver_result_iterator i(_M_node);
                        _M_node = _M_node->ai_next;
                        return i;
                }

                // etc.

                resolver_result_iterator (addrinfo* node) : _M_node(node) {}

        private:
                addrinfo* _M_node;
        };

        class SOCKETSTREAM_API resolver_result
        {
        public:

                // Assignable
                resolver_result () : _M_head(0) {}

                resolver_result (resolver_result const& that)
                : _M_head(that._M_head) {}

                resolver_result&
                operator= (resolver_result const& that) {
                        _M_head = that._M_head;
                        return *this;
                }

                // Container
                typedef addrinfo* value_type;
                typedef resolver_result_iterator iterator;
                typedef resolver_result_iterator const_iterator;
                typedef value_type& reference;
                typedef value_type const& const_reference;
                typedef value_type* pointer;
                typedef size_t difference_type;
                typedef size_t size_type;

                iterator begin () { return iterator(_M_head); }

                const_iterator begin () const {
                        return const_iterator(_M_head);
                }

                iterator end () { return iterator(); }

                const_iterator end () const { return const_iterator(); }

                size_type size () const {
                        size_type result = 0;
                        for (addrinfo* i = _M_head; i != 0; i = i->ai_next)
                                ++result;
                        return result;
                }

                size_type max_size () const { return this->size(); }

                bool empty () const { return (_M_head == 0); }

                void swap (resolver_result& that) {
                        addrinfo* tmp = _M_head;
                        _M_head = that._M_head;
                        that._M_head = tmp;
                }

                // EqualityComparable
                bool
                operator== (resolver_result const& that) const {
                        if (this->size() != that.size())
                                return false;
                        // FIXME: Every element must be equal.
                }

                bool
                operator!= (resolver_result const& that) const {
                        return (*this) != that;
                }

                // LessThanComparable
                bool
                operator< (resolver_result const& that) const {
                        return (*this) != that; // FIXME
                }

                bool
                operator> (resolver_result const& that) const {
                        return *this < that ? false : true;
                }

                bool
                operator<= (resolver_result const& that) const {
                        return *this < that or *this == that;
                }

                bool
                operator>= (resolver_result const& that) const {
                        return *this > that or *this == that;
                }

                // ForwardContainer

                // etc.
                resolver_result (addrinfo* head) : _M_head(head) {}

                ~resolver_result () {
                        if (_M_head)
                                ::freeaddrinfo(_M_head);
                }

        private:
                addrinfo* _M_head;
        };

        class SOCKETSTREAM_API resolver
        {
        public:

                resolver ();

                ~resolver ();

                resolver& family (sockets_base::family value);

                resolver& style (sockets_base::style value);

                resolver& flags (int value);

                void reset ();

                void resolve (char const* host, char const* service);

                resolver_result const& result () const { return _M_result; }

        private:

                // Not CopyConstructible.
                resolver (resolver const&);

                // Not Assignable.
                resolver& operator= (resolver const&);

                void initialize_hint ();

                void reset_hint ();

                addrinfo* _M_hint;

                resolver_result _M_result;

        };

}

#endif // SOCKETSTREAM_RESOLVER_H

---