- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

# bmig_support.hh

    00001 // boost_support.hh: this file is part of the Vaucanson project.
    00002 //
    00003 // Vaucanson, a generic library for finite state machines.
    00004 //
    00005 // Copyright (C) 2007, 2008 The Vaucanson Group.
    00006 //
    00007 // This program is free software; you can redistribute it and/or
    00008 // modify it under the terms of the GNU General Public License
    00009 // as published by the Free Software Foundation; either version 2
    00010 // of the License, or (at your option) any later version.
    00011 //
    00012 // The complete GNU General Public Licence Notice can be found as the
    00013 // `COPYING' file in the root directory.
    00014 //
    00015 // The Vaucanson Group consists of people listed in the `AUTHORS' file.
    00016 //
    00017 #ifndef VCSN_AUTOMATA_IMPLEMENTATION_BMIG_BMIG_SUPPORT_HH
    00018 # define VCSN_AUTOMATA_IMPLEMENTATION_BMIG_BMIG_SUPPORT_HH
    00019
    00020 # include <vaucanson/misc/support.hh>
    00021 # include <vaucanson/automata/implementation/bmig/initial_container.hh>
    00022 # include <boost/shared_ptr.hpp>
    00023
    00024 namespace vcsn
    00025 {
    00026   namespace misc
    00027   {
    00028
    00029     template <>
    00030     class SupportIterator<std::vector<boost::shared_ptr<std::size_t> > >
    00031     {
    00032       public:
    00033         typedef boost::shared_ptr<std::size_t>              data_type;
    00034         typedef vcsn::handler<state_h, data_type>           handler_t;
    00035         typedef std::vector<data_type>                      container_t;
    00036         typedef container_t::const_iterator                 vector_iterator;
    00037         typedef SupportIterator<container_t>                self_t;
    00038
    00039         typedef vector_iterator::iterator_category          iterator_category;
    00040         typedef vector_iterator::difference_type            difference_type;
    00041         typedef data_type                                   value_type;
    00042         typedef data_type*                                  pointer;
    00043         typedef data_type&                                  reference;
    00044
    00045         SupportIterator () {}
    00046         SupportIterator (const container_t* c, int i);
    00047
    00048         handler_t operator* () const;
    00049         self_t&  operator++ ();
    00050         self_t&  operator-- ();
    00051         self_t   operator++ (int);
    00052         bool     operator!= (const SupportIterator&) const;
    00053         bool     operator== (const SupportIterator&) const;
    00054
    00055       private:
    00056         int                 current_;
    00057         std::size_t         container_size_;
    00058         const container_t*  container_;
    00059     };
    00060
    00062     template <>
    00063     class Support<std::vector<boost::shared_ptr<std::size_t> > >
    00064     {
    00065       public:
    00066         typedef boost::shared_ptr<std::size_t>           value_type;
    00067         typedef vcsn::handler<state_h, value_type>       handler_t;
    00068         typedef SupportIterator<std::vector<value_type> > iterator;
    00069         typedef iterator                                 const_iterator;
    00071
    00072         Support (const std::vector<value_type>&);
    00073
    00074         const_iterator begin () const;
    00075         const_iterator end () const;
    00076         unsigned size () const;
    00077
    00078         // Find the element associated to \a k.
    00079         iterator find (const handler_t& k) const;
    00080
    00082         bool empty () const;
    00083
    00084         handler_t back () const;
    00085       private:
    00086         const std::vector<value_type>&  m_;
    00087     };
    00088
    00089   }
    00090 }
    00091
    00093 namespace std
    00094 {
    00095   template <>
    00096     struct iterator_traits<vcsn::misc::SupportIterator<std::vector<boost::shared_ptr<std::size_t> > > >
    00097     {
    00098       typedef input_iterator_tag  iterator_category;
    00099       typedef boost::shared_ptr<size_t>   value_type;
    00100       typedef int                 difference_type;
    00101       typedef int*                pointer;
    00102       typedef int&                reference;
    00103     };
    00104 } // std
    00105
    00106 namespace vcsn
    00107 {
    00108   namespace misc
    00109   {
    00110
    00111     template <>
    00112     class SupportIterator<std::set<boost::shared_ptr<std::size_t> > >
    00113     {
    00114       public:
    00115         typedef boost::shared_ptr<std::size_t>              data_type;
    00116         typedef vcsn::handler<state_h, data_type>           handler_t;
    00117         typedef std::set<data_type>                         container_t;
    00118         typedef container_t::const_iterator                 set_iterator;
    00119         typedef SupportIterator<container_t>                self_t;
    00120
    00121         typedef set_iterator::iterator_category     iterator_category;
    00122         typedef set_iterator::difference_type       difference_type;
    00123         typedef data_type                                   value_type;
    00124         typedef data_type*                                  pointer;
    00125         typedef data_type&                                  reference;
    00126
    00127         SupportIterator () {}
    00128         SupportIterator (const container_t* c, set_iterator it);
    00129
    00130         handler_t operator* () const;
    00131         self_t&  operator++ ();
    00132         self_t&  operator-- ();
    00133         self_t   operator++ (int);
    00134         bool     operator!= (const SupportIterator&) const;
    00135         bool     operator== (const SupportIterator&) const;
    00136
    00137       private:
    00138         set_iterator        current_;
    00139         std::size_t         container_size_;
    00140         const container_t*  container_;
    00141     };
    00142
    00144     template <>
    00145     class Support<std::set<boost::shared_ptr<std::size_t> > >
    00146     {
    00147       public:
    00148         typedef boost::shared_ptr<std::size_t>           value_type;
    00149         typedef vcsn::handler<state_h, value_type>       handler_t;
    00150         typedef SupportIterator<std::set<value_type> > iterator;
    00151         typedef iterator                                 const_iterator;
    00153
    00154         Support (const std::set<value_type>&);
    00155
    00156         const_iterator begin () const;
    00157         const_iterator end () const;
    00158         unsigned size () const;
    00159
    00160         // Find the element associated to \a k.
    00161         iterator find (const handler_t& k) const;
    00162
    00164         bool empty () const;
    00165
    00166         handler_t back () const;
    00167       private:
    00168         const std::set<value_type>&     m_;
    00169     };
    00170
    00171   }
    00172 }
    00173
    00175 namespace std
    00176 {
    00177   template <>
    00178     struct iterator_traits<vcsn::misc::SupportIterator<std::set<boost::shared_ptr<std::size_t> > > >
    00179     {
    00180       typedef input_iterator_tag  iterator_category;
    00181       typedef boost::shared_ptr<std::size_t>      value_type;
    00182       typedef int                 difference_type;
    00183       typedef int*                pointer;
    00184       typedef int&                reference;
    00185     };
    00186 } // std
    00187
    00188 namespace vcsn
    00189 {
    00190   namespace misc
    00191   {
    00192     template <typename U, typename HState>
    00193     class SupportIterator<vcsn::bmig::InitialContainer<U, HState> >
    00194     {
    00195       public:
    00196         typedef typename vcsn::bmig::InitialContainer<U, HState>::Type  container_t;
    00197         typedef typename container_t::key_type                  key_type;
    00198         typedef typename container_t::const_iterator            container_iterator;
    00199         typedef SupportIterator<vcsn::bmig::InitialContainer<U, HState> >       self_t;
    00200         typedef vcsn::handler<state_h, HState>                  handler_t;
    00201         typedef typename container_iterator::iterator_category  iterator_category;
    00202         typedef typename container_iterator::difference_type    difference_type;
    00203         typedef key_type                                        value_type;
    00204         typedef key_type*                                       pointer;
    00205         typedef key_type&                                       reference;
    00206
    00207         SupportIterator () {}
    00208         SupportIterator (const container_t* c, container_iterator);
    00209
    00210         handler_t  operator* () const;
    00211         self_t&  operator++ ();
    00212         self_t&  operator-- ();
    00213         self_t   operator++ (int);
    00214         bool     operator!= (const SupportIterator&) const;
    00215         bool     operator== (const SupportIterator&) const;
    00216
    00217
    00218       private:
    00219         container_iterator  i_;
    00220         container_iterator  next_;
    00221         const container_t*  container_;
    00222     };
    00223
    00224
    00226     template <typename  U, typename HState>
    00227     class Support<vcsn::bmig::InitialContainer<U, HState> >
    00228     {
    00229       public:
    00230         typedef typename vcsn::bmig::InitialContainer<U, HState>::Type container_t;
    00231         typedef SupportIterator<vcsn::bmig::InitialContainer<U, HState> > iterator;
    00232         typedef SupportIterator<vcsn::bmig::InitialContainer<U, HState> > const_iterator;
    00233         typedef vcsn::handler<state_h, HState>                          handler_t;
    00234
    00235         Support (const container_t&);
    00236         Support (const Support&);
    00237
    00238         iterator begin () const;
    00239         iterator end () const;
    00240         unsigned size () const;
    00241
    00242         // Find the element associated to \a k.
    00243         iterator find (const HState& k) const;
    00244
    00246         bool empty () const;
    00247
    00248         handler_t back () const;
    00249       private:
    00250         const container_t&      m_;
    00251     };
    00252
    00253   }
    00254 }
    00255
    00257 namespace std
    00258 {
    00259   template <class T, class U>
    00260   struct iterator_traits<vcsn::misc::SupportIterator<std::vector<vcsn::handler<T, U> > > >
    00261   {
    00262     typedef input_iterator_tag  iterator_category;
    00263     typedef U                   value_type;
    00264     typedef int                 difference_type;
    00265     typedef int*                pointer;
    00266     typedef int&                reference;
    00267   };
    00268 } // std
    00269
    00270 # if !defined VCSN_USE_INTERFACE_ONLY || defined VCSN_USE_LIB
    00271 # include <vaucanson/automata/implementation/bmig/bmig_support.hxx>
    00272 # endif // VCSN_USE_INTERFACE_ONLY
    00273
    00274 #endif // !VCSN_AUTOMATA_IMPLEMENTATION_BMIG_BMIG_SUPPORT_HH
    00275