stored_range.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2019 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
 
// This library 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
// Lesser General Public License for more details.
 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
 
#ifndef LIBMESH_STORED_RANGE_H
#define LIBMESH_STORED_RANGE_H
 
// Local includes
#include "libmesh/threads.h"
 
// C++ includes
#include <vector>
 
namespace libMesh
{
 
template <typename iterator_type, typename object_type>
class StoredRange
{
public:
  typedef typename std::vector<object_type>::const_iterator const_iterator;
 
  StoredRange (const unsigned int new_grainsize = 1000) :
    _end(),
    _begin(),
    _last(),
    _first(),
    _grainsize(new_grainsize),
    _objs(new std::vector<object_type>()),
    _should_release(true)
  {}
 
  StoredRange (const iterator_type & first,
               const iterator_type & last,
               const unsigned int new_grainsize = 1000) :
    _end(),
    _begin(),
    _last(),
    _first(),
    _grainsize(new_grainsize),
    _objs(new std::vector<object_type>()),
    _should_release(true)
  {
    this->reset(first, last);
  }
 
  StoredRange (std::vector<object_type> * objs,
               const unsigned int new_grainsize = 1000) :
    _end(objs->end()),
    _begin(objs->begin()),
    _last(objs->size()),
    _first(0),
    _grainsize(new_grainsize),
    _objs(objs),
    _should_release(false)
  {
  }
 
  StoredRange (const StoredRange<iterator_type,object_type> & er):
    _end(er._end),
    _begin(er._begin),
    _last(er._last),
    _first(er._first),
    _grainsize(er._grainsize),
    _objs(nullptr),
    _should_release(false)
  {
    // specifically, do *not* copy the vector
  }
 
  StoredRange (const StoredRange<iterator_type,object_type> & er,
               const const_iterator & begin_range,
               const const_iterator & end_range):
    _end(end_range),
    _begin(begin_range),
    _last(0), // Initialize these in a moment
    _first(0),
    _grainsize(er._grainsize),
    _objs(nullptr),
    _should_release(false)
  {
    // specifically, do *not* copy the vector
 
    _first = std::distance(er._begin, _begin);
    _last = _first + std::distance(_begin, _end);
  }
 
  StoredRange (StoredRange<iterator_type,object_type> & r, Threads::split ) :
    _end(r._end),
    _begin(r._begin),
    _last(r._last),
    _first(r._first),
    _grainsize(r._grainsize),
    _objs(nullptr),
    _should_release(false)
  {
    const_iterator
      beginning = r._begin,
      ending    = r._end,
      middle    = beginning + std::distance(beginning, ending)/2u;
 
    r._end = _begin = middle;
 
    std::size_t
      first = r._first,
      last  = r._last,
      half  = first + (last-first)/2u;
 
    r._last = _first = half;
  }
 
  ~StoredRange ()
  {
    if (_should_release)
      delete _objs;
  }
 
  StoredRange<iterator_type, object_type> &
  reset (const iterator_type & first,
         const iterator_type & last)
  {
    _objs->clear();
 
    for (iterator_type it=first; it!=last; ++it)
      _objs->push_back(*it);
 
    _begin = _objs->begin();
    _end   = _objs->end();
 
    _first = 0;
    _last  = _objs->size();
 
    return *this;
  }
 
  StoredRange<iterator_type, object_type> & reset ()
  {
    _begin = _objs->begin();
    _end   = _objs->end();
 
    _first = 0;
    _last  = _objs->size();
 
    return *this;
  }
 
  const_iterator begin () const { return _begin; }
 
  const_iterator end () const { return _end; }
 
  std::size_t first_idx () const { return _first; }
 
  std::size_t last_idx () const { return _last; }
 
  std::size_t grainsize () const {return _grainsize;}
 
  void grainsize (const unsigned int & gs) {_grainsize = gs;}
 
  std::size_t size () const { return std::distance(_begin, _end); }
 
  //------------------------------------------------------------------------
  // Methods that implement Range concept
  //------------------------------------------------------------------------
 
  bool empty() const { return (_begin == _end); }
 
  bool is_divisible() const { return this->grainsize() < static_cast<unsigned int>(std::distance(_begin, _end)); }
 
private:
 
  const_iterator _end;
  const_iterator _begin;
  std::size_t _last;
  std::size_t _first;
  std::size_t _grainsize;
 
  // TODO: Make this a std::shared_ptr in the future!
  std::vector<object_type> * _objs;
  bool _should_release;
};
 
} // namespace libMesh
 
#endif // LIBMESH_STORED_RANGE_H