include/wipal/pcap/file_iterator.hh

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2007, 2008, 2009  Universite Pierre et Marie Curie - Paris 6
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA  02110-1301  USA
 *
 * Author: Thomas Claveirole <thomas.claveirole@lip6.fr>
 */
#ifndef PCAP_FILE_ITERATOR_HH_
# define PCAP_FILE_ITERATOR_HH_

# include <istream>

# include <boost/scoped_ptr.hpp>

# include <wipal/pcap/pkt.hh>
# include <wipal/tool/valued_iterator.hh>

namespace wpl
{

  /*---------------------.
  | Forward declarations |
  `---------------------*/

  namespace pcap
  {
    namespace internals
    {

      template <class, class>
      struct file_iterator;

    } // End of namespace wpl::pcap::internals.
  } // End of namespace wpl::pcap.


  /*--------------.
  | Virtual types |
  `--------------*/

  namespace tool
  {

    template <class S, class B>
    struct types< pcap::internals::file_iterator<S, B> >
    {
      typedef pkt::packet<S>    value_type;
      typedef S                 iterable_type;
    };

  } // End of namespace wpl::tool.


  /*-------------.
  | Declarations |
  `-------------*/

  namespace pcap
  {

    namespace internals
    {

      template <class Stream, class Bottom = tool::bottom>
      struct file_iterator:
        public tool::valued_iterator<WP_GET_EXACT(Bottom,
                                                  file_iterator<Stream,
                                                                Bottom>)>
      {

        typedef WP_GET_EXACT(Bottom, file_iterator<Stream,
                                                   Bottom>)     exact_type;
        typedef WP_TYPE(iterable_type, exact_type)              iterable_type;
        typedef WP_TYPE(value_type, exact_type)                 value_type;

        file_iterator(const iterable_type& stream, bool end);

        file_iterator(const iterable_type&      stream,
                      const std::streampos&     pos,
                      unsigned                  count,
                      std::istream* const       istream = 0);

        file_iterator(const file_iterator&);

        file_iterator&  operator = (const file_iterator&);


        bool            equal(const file_iterator& rhs) const;
        void            increment();

      protected:
        std::istream&   stream();

        void            increment_pcap();

      private:
        const iterable_type*            stream_;


        /*
         * Profiling showed std::ifstream's constructor takes much time,
         * even when not requesting to open a file (which is a frequent
         * case).  Thus we use a pointer instead to avoid that overhead.
         * Of course, this implies the required allocation will slow
         * down cases where we must open a file and initialize this
         * attribute.
         */
        boost::scoped_ptr<std::istream> input_;
        std::streampos                  pos_;   
        unsigned                        count_; 

      };

    } // End of namespace wpl::pcap::internals.

  } // End of namespace wpl::pcap.

} // End of namespace wpl.

# include "file_iterator.hxx"

#endif // ! PCAP_FILE_ITERATOR_HH_

---