Line data    Source code

       1             : // The libMesh Finite Element Library.
       2             : // Copyright (C) 2002-2025 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
       3             : 
       4             : // This library is free software; you can redistribute it and/or
       5             : // modify it under the terms of the GNU Lesser General Public
       6             : // License as published by the Free Software Foundation; either
       7             : // version 2.1 of the License, or (at your option) any later version.
       8             : 
       9             : // This library is distributed in the hope that it will be useful,
      10             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             : // Lesser General Public License for more details.
      13             : 
      14             : // You should have received a copy of the GNU Lesser General Public
      15             : // License along with this library; if not, write to the Free Software
      16             : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      17             : 
      18             : 
      19             : 
      20             : #ifndef LIBMESH_MAPVECTOR_H
      21             : #define LIBMESH_MAPVECTOR_H
      22             : 
      23             : // libMesh Includes   -------------------------------
      24             : #include "libmesh/pool_allocator.h"
      25             : 
      26             : // C++ Includes   -----------------------------------
      27             : #include <map>
      28             : 
      29             : namespace libMesh
      30             : {
      31             : 
      32             : /**
      33             :  * This \p mapvector templated class is intended to provide the
      34             :  * performance characteristics of a std::map with an interface more
      35             :  * closely resembling that of a std::vector, for use with
      36             :  * DistributedMesh.
      37             :  *
      38             :  * \author  Roy H. Stogner
      39             :  */
      40             : 
      41             : template <typename Val, typename index_t=unsigned int>
      42      271008 : class mapvector :
      43             :   public std::map<index_t, Val, std::less<index_t>,
      44             :                   FastPoolAllocator<std::pair<const index_t, Val>>>
      45             : {
      46             : public:
      47             :   typedef std::map<index_t, Val, std::less<index_t>,
      48             :                    FastPoolAllocator<std::pair<const index_t, Val>>> maptype;
      49             : 
      50             :   class veclike_iterator
      51             :   {
      52             :   public:
      53      751454 :     veclike_iterator(const typename maptype::iterator & i)
      54      751454 :       : it(i) {}
      55             : 
      56  1345142736 :     Val & operator*() const { return it->second; }
      57             : 
      58    10794779 :     index_t index() const { return it->first; }
      59             : 
      60   442219260 :     veclike_iterator & operator++() { ++it; return *this; }
      61             : 
      62             :     veclike_iterator operator++(int)
      63             :     {
      64             :       veclike_iterator i = *this;
      65             :       ++(*this);
      66             :       return i;
      67             :     }
      68             : 
      69     3794971 :     bool operator==(const veclike_iterator & other) const
      70             :     {
      71     7337084 :       return it == other.it;
      72             :     }
      73             : 
      74      729636 :     bool operator!=(const veclike_iterator & other) const
      75             :     {
      76     1077175 :       return it != other.it;
      77             :     }
      78             : 
      79             :   private:
      80             :     friend class mapvector;
      81             : 
      82             :     typename maptype::iterator it;
      83             :   };
      84             : 
      85             :   class const_veclike_iterator
      86             :   {
      87             :   public:
      88     4257261 :     const_veclike_iterator(const typename maptype::const_iterator & i)
      89     4257261 :       : it(i) {}
      90             : 
      91             :     const_veclike_iterator(const veclike_iterator & i)
      92             :       : it(i.it) {}
      93             : 
      94   528873212 :     const Val & operator*() const { return it->second; }
      95             : 
      96             :     index_t index() const { return it->first; }
      97             : 
      98     3091666 :     const_veclike_iterator & operator++() { ++it; return *this; }
      99             : 
     100             :     const_veclike_iterator operator++(int)
     101             :     {
     102             :       veclike_iterator i = *this;
     103             :       ++(*this);
     104             :       return i;
     105             :     }
     106             : 
     107     5072088 :     bool operator==(const const_veclike_iterator & other) const
     108             :     {
     109     7418377 :       return it == other.it;
     110             :     }
     111             : 
     112     1224232 :     bool operator!=(const const_veclike_iterator & other) const
     113             :     {
     114     1224232 :       return it != other.it;
     115             :     }
     116             : 
     117             :   private:
     118             :     friend class mapvector;
     119             : 
     120             :     typename maptype::const_iterator it;
     121             :   };
     122             : 
     123             :   class const_reverse_veclike_iterator
     124             :   {
     125             :   public:
     126       28620 :     const_reverse_veclike_iterator(const typename maptype::const_reverse_iterator & i)
     127       28620 :       : it(i) {}
     128             : 
     129             :     const_reverse_veclike_iterator(const const_veclike_iterator & i)
     130             :       : it(i.it) {}
     131             : 
     132             :     const_reverse_veclike_iterator(const veclike_iterator & i)
     133             :       : it(i.it) {}
     134             : 
     135       78376 :     const Val & operator*() const { return it->second; }
     136             : 
     137       64454 :     const_reverse_veclike_iterator & operator++() { ++it; return *this; }
     138             : 
     139             :     const_reverse_veclike_iterator operator++(int)
     140             :     {
     141             :       const_reverse_veclike_iterator i = *this;
     142             :       ++(*this);
     143             :       return i;
     144             :     }
     145             : 
     146             :     bool operator==(const const_reverse_veclike_iterator & other) const
     147             :     {
     148             :       return it == other.it;
     149             :     }
     150             : 
     151       78764 :     bool operator!=(const const_reverse_veclike_iterator & other) const
     152             :     {
     153       78764 :       return it != other.it;
     154             :     }
     155             : 
     156             :   private:
     157             :     friend class mapvector;
     158             : 
     159             :     typename maptype::const_reverse_iterator it;
     160             :   };
     161             : 
     162      334371 :   veclike_iterator find (const index_t & k)
     163             :   {
     164      334371 :     return veclike_iterator(maptype::find(k));
     165             :   }
     166             : 
     167     1224232 :   const_veclike_iterator find (const index_t & k) const
     168             :   {
     169     1224232 :     return const_veclike_iterator(maptype::find(k));
     170             :   }
     171             : 
     172     2356615 :   Val & operator[] (const index_t & k)
     173             :   {
     174  1563523203 :     return maptype::operator[](k);
     175             :   }
     176             : 
     177    45046634 :   Val operator[] (const index_t & k) const
     178             :   {
     179     1671177 :     auto it = this->maptype::find(k);
     180    45207199 :     return it == this->end().it? Val() : it->second;
     181             :   }
     182             : 
     183        4394 :   void erase(index_t i)
     184             :   {
     185        4394 :     maptype::erase(i);
     186        4394 :   }
     187             : 
     188   107723663 :   veclike_iterator erase(const veclike_iterator & pos)
     189             :   {
     190   107723663 :     return veclike_iterator(maptype::erase(pos.it));
     191             :   }
     192             : 
     193       19586 :   veclike_iterator begin()
     194             :   {
     195       19586 :     return veclike_iterator(maptype::begin());
     196             :   }
     197             : 
     198       34407 :   const_veclike_iterator begin() const
     199             :   {
     200       34407 :     return const_veclike_iterator(maptype::begin());
     201             :   }
     202             : 
     203      381957 :   veclike_iterator end()
     204             :   {
     205      381957 :     return veclike_iterator(maptype::end());
     206             :   }
     207             : 
     208     2998622 :   const_veclike_iterator end() const
     209             :   {
     210     2998622 :     return const_veclike_iterator(maptype::end());
     211             :   }
     212             : };
     213             : 
     214             : } // namespace libMesh
     215             : 
     216             : #endif // LIBMESH_MAPVECTOR_H