choose.h

/***************************************************************************
 *  include/stxxl/bits/stream/choose.h
 *
 *  Part of the STXXL. See http://stxxl.sourceforge.net
 *
 *  Copyright (C) 2003-2005 Roman Dementiev <[email protected]>
 *  Copyright (C) 2010 Andreas Beckmann <[email protected]>
 *
 *  Distributed under the Boost Software License, Version 1.0.
 *  (See accompanying file LICENSE_1_0.txt or copy at
 *  http://www.boost.org/LICENSE_1_0.txt)
 **************************************************************************/

#ifndef STXXL_STREAM__CHOOSE_H_
#define STXXL_STREAM__CHOOSE_H_

#include <stxxl/bits/namespace.h>


__STXXL_BEGIN_NAMESPACE

namespace stream
{
    //     CHOOSE                                                         //

    template <class Input_, int Which>
    class choose
    { };

    template <class Input_>
    class choose<Input_, 1>
    {
        Input_ & in;

        typedef typename Input_::value_type tuple_type;

    public:
        typedef typename tuple_type::first_type value_type;

        choose(Input_ & in_) : in(in_)
        { }

        const value_type & operator * () const
        {
            return (*in).first;
        }

        const value_type * operator -> () const
        {
            return &(*in).first;
        }

        choose & operator ++ ()
        {
            ++in;
            return *this;
        }

        bool empty() const
        {
            return in.empty();
        }
    };

    template <class Input_>
    class choose<Input_, 2>
    {
        Input_ & in;

        typedef typename Input_::value_type tuple_type;

    public:
        typedef typename tuple_type::second_type value_type;

        choose(Input_ & in_) : in(in_)
        { }

        const value_type & operator * () const
        {
            return (*in).second;
        }

        const value_type * operator -> () const
        {
            return &(*in).second;
        }

        choose & operator ++ ()
        {
            ++in;
            return *this;
        }

        bool empty() const
        {
            return in.empty();
        }
    };

    template <class Input_>
    class choose<Input_, 3>
    {
        Input_ & in;

        typedef typename Input_::value_type tuple_type;

    public:
        typedef typename tuple_type::third_type value_type;

        choose(Input_ & in_) : in(in_)
        { }

        const value_type & operator * () const
        {
            return (*in).third;
        }

        const value_type * operator -> () const
        {
            return &(*in).third;
        }

        choose & operator ++ ()
        {
            ++in;
            return *this;
        }

        bool empty() const
        {
            return in.empty();
        }
    };

    template <class Input_>
    class choose<Input_, 4>
    {
        Input_ & in;

        typedef typename Input_::value_type tuple_type;

    public:
        typedef typename tuple_type::fourth_type value_type;

        choose(Input_ & in_) : in(in_)
        { }

        const value_type & operator * () const
        {
            return (*in).fourth;
        }

        const value_type * operator -> () const
        {
            return &(*in).fourth;
        }

        choose & operator ++ ()
        {
            ++in;
            return *this;
        }

        bool empty() const
        {
            return in.empty();
        }
    };

    template <class Input_>
    class choose<Input_, 5>
    {
        Input_ & in;

        typedef typename Input_::value_type tuple_type;

    public:
        typedef typename tuple_type::fifth_type value_type;

        choose(Input_ & in_) : in(in_)
        { }

        const value_type & operator * () const
        {
            return (*in).fifth;
        }

        const value_type * operator -> () const
        {
            return &(*in).fifth;
        }

        choose & operator ++ ()
        {
            ++in;
            return *this;
        }

        bool empty() const
        {
            return in.empty();
        }
    };

    template <class Input_>
    class choose<Input_, 6>
    {
        Input_ & in;

        typedef typename Input_::value_type tuple_type;

    public:
        typedef typename tuple_type::sixth_type value_type;

        choose(Input_ & in_) : in(in_)
        { }

        const value_type & operator * () const
        {
            return (*in).sixth;
        }

        const value_type * operator -> () const
        {
            return &(*in).sixth;
        }

        choose & operator ++ ()
        {
            ++in;
            return *this;
        }

        bool empty() const
        {
            return in.empty();
        }
    };


}

__STXXL_END_NAMESPACE


#include <stxxl/bits/stream/unique.h>


#endif // !STXXL_STREAM__CHOOSE_H_
// vim: et:ts=4:sw=4