root/tlate/basic_sequential_value.hh

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2009, 2011 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue 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
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GUARD_TLATE_BASIC_SEQUENTIAL_VALUE_HH
#define GUARD_TLATE_BASIC_SEQUENTIAL_VALUE_HH

#include "sequential_value.hh"

namespace tlate
{
        template <typename Seq, typename ValFac>
        class basic_sequential_value : public sequential_value
        {
                class vit : public virtual_iterator
                {
                        typename Seq::const_iterator it;
                        mutable value::const_ptr cur;
                        ValFac factory;
                public:
                        vit(typename Seq::const_iterator it, ValFac factory)
                                : it(it)
                                , factory(factory)
                                {}
                        virtual_iterator *clone() const {
                                return new vit(*this);
                        }
                        value::const_ptr get() const {
                                if (!cur) cur = factory(*it);
                                return cur;
                        }
                        void next() { cur.reset(); it++; }
                        bool eq(const virtual_iterator &o_) const {
                                const vit *o = dynamic_cast<const vit *>(&o_);
                                return o ? it == o->it : false;
                        }
                };
                
                Seq seq;
                ValFac factory;
        public:
                typedef boost::shared_ptr<basic_sequential_value<Seq,ValFac> >
                ptr;
                typedef boost::shared_ptr
                <const basic_sequential_value<Seq,ValFac> >
                const_ptr;

                basic_sequential_value(Seq seq, ValFac factory)
                        : seq(seq)
                        , factory(factory)
                        {}

                Seq &operator*() { return seq; }
                const Seq &operator*() const { return seq; }
                Seq *operator->() { return &seq; }
                const Seq *operator->() const { return &seq; }
                Seq &get() { return seq; }
                const Seq &get() const { return seq; }

                virtual const_iterator begin() const {
                        return const_iterator(new vit(seq.begin(), factory));
                }
                virtual const_iterator end() const {
                        return const_iterator(new vit(seq.end(), factory));
                }
        };

        template <typename Seq, typename ValFac>
        boost::shared_ptr<basic_sequential_value<Seq,ValFac> >
        seqval(Seq seq, ValFac vf)
        {
                boost::shared_ptr<basic_sequential_value<Seq,ValFac> > rv;
                if (seq.begin() != seq.end())
                        rv.reset(new basic_sequential_value<Seq,ValFac>
                                 (seq, vf));
                return rv;
        }
};

#endif /* GUARD_TLATE_BASIC_SEQUENTIAL_VALUE_HH */