AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
metaforce/gmm/gmm_ref.h

527 lines
22 KiB
C++
Raw Blame History

/* -*- c++ -*- (enables emacs c++ mode) */
/*===========================================================================
Copyright (C) 2000-2017 Yves Renard
This file is a part of GetFEM++
GetFEM++ 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 3 of the License, or
(at your option) any later version along with the GCC Runtime Library
Exception either version 3.1 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 Lesser General Public
License and GCC Runtime Library Exception for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
As a special exception, you may use this file as it is a part of a free
software library without restriction. Specifically, if other files
instantiate templates or use macros or inline functions from this file,
or you compile this file and link it with other files to produce an
executable, this file does not by itself cause the resulting executable
to be covered by the GNU Lesser General Public License. This exception
does not however invalidate any other reasons why the executable file
might be covered by the GNU Lesser General Public License.
===========================================================================*/
#ifndef GMM_REF_H__
#define GMM_REF_H__
/** @file gmm_ref.h
@author Yves Renard <Yves.Renard@insa-lyon.fr>
@date August 26, 2000.
* @brief Provide some simple pseudo-containers.
*
* WARNING : modifiying the container infirm the validity of references.
*/
#include <iterator>
#include "gmm_except.h"
namespace gmm {
/* ********************************************************************* */
/* Simple reference. */
/* ********************************************************************* */
template<typename ITER> class tab_ref {
protected :
ITER begin_, end_;
public :
typedef typename std::iterator_traits<ITER>::value_type value_type;
typedef typename std::iterator_traits<ITER>::pointer pointer;
typedef typename std::iterator_traits<ITER>::pointer const_pointer;
typedef typename std::iterator_traits<ITER>::reference reference;
typedef typename std::iterator_traits<ITER>::reference const_reference;
typedef typename std::iterator_traits<ITER>::difference_type
difference_type;
typedef ITER iterator;
typedef ITER const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef size_t size_type;
bool empty(void) const { return begin_ == end_; }
size_type size(void) const { return end_ - begin_; }
const iterator &begin(void) { return begin_; }
const const_iterator &begin(void) const { return begin_; }
const iterator &end(void) { return end_; }
const const_iterator &end(void) const { return end_; }
reverse_iterator rbegin(void) { return reverse_iterator(end()); }
const_reverse_iterator rbegin(void) const
{ return const_reverse_iterator(end()); }
reverse_iterator rend(void) { return reverse_iterator(begin()); }
const_reverse_iterator rend(void) const
{ return const_reverse_iterator(begin()); }
reference front(void) { return *begin(); }
const_reference front(void) const { return *begin(); }
reference back(void) { return *(--(end())); }
const_reference back(void) const { return *(--(end())); }
void pop_front(void) { ++begin_; }
const_reference operator [](size_type ii) const { return *(begin_ + ii);}
reference operator [](size_type ii) { return *(begin_ + ii); }
tab_ref(void) {}
tab_ref(const ITER &b, const ITER &e) : begin_(b), end_(e) {}
};
/* ********************************************************************* */
/* Reference with index. */
/* ********************************************************************* */
// template<typename ITER> struct tab_ref_index_iterator_
// : public dynamic_array<size_t>::const_iterator
// {
// typedef typename std::iterator_traits<ITER>::value_type value_type;
// typedef typename std::iterator_traits<ITER>::pointer pointer;
// typedef typename std::iterator_traits<ITER>::reference reference;
// typedef typename std::iterator_traits<ITER>::difference_type
// difference_type;
// typedef std::random_access_iterator_tag iterator_category;
// typedef size_t size_type;
// typedef dynamic_array<size_type>::const_iterator dnas_iterator_;
// typedef tab_ref_index_iterator_<ITER> iterator;
// ITER piter;
// iterator operator ++(int)
// { iterator tmp = *this; ++(*((dnas_iterator_ *)(this))); return tmp; }
// iterator operator --(int)
// { iterator tmp = *this; --(*((dnas_iterator_ *)(this))); return tmp; }
// iterator &operator ++()
// { ++(*((dnas_iterator_ *)(this))); return *this; }
// iterator &operator --()
// { --(*((dnas_iterator_ *)(this))); return *this; }
// iterator &operator +=(difference_type i)
// { (*((dnas_iterator_ *)(this))) += i; return *this; }
// iterator &operator -=(difference_type i)
// { (*((dnas_iterator_ *)(this))) -= i; return *this; }
// iterator operator +(difference_type i) const
// { iterator it = *this; return (it += i); }
// iterator operator -(difference_type i) const
// { iterator it = *this; return (it -= i); }
// difference_type operator -(const iterator &i) const
// { return *((dnas_iterator_ *)(this)) - *((dnas_iterator_ *)(&i)); }
// reference operator *() const
// { return *(piter + *((*((dnas_iterator_ *)(this))))); }
// reference operator [](int ii)
// { return *(piter + *((*((dnas_iterator_ *)(this+ii))))); }
// bool operator ==(const iterator &i) const
// {
// return ((piter) == ((i.piter))
// && *((dnas_iterator_ *)(this)) == *((*((dnas_iterator_ *)(this)))));
// }
// bool operator !=(const iterator &i) const
// { return !(i == *this); }
// bool operator < (const iterator &i) const
// {
// return ((piter) == ((i.piter))
// && *((dnas_iterator_ *)(this)) < *((*((dnas_iterator_ *)(this)))));
// }
// tab_ref_index_iterator_(void) {}
// tab_ref_index_iterator_(const ITER &iter, const dnas_iterator_ &dnas_iter)
// : dnas_iterator_(dnas_iter), piter(iter) {}
// };
// template<typename ITER> class tab_ref_index
// {
// public :
// typedef typename std::iterator_traits<ITER>::value_type value_type;
// typedef typename std::iterator_traits<ITER>::pointer pointer;
// typedef typename std::iterator_traits<ITER>::pointer const_pointer;
// typedef typename std::iterator_traits<ITER>::reference reference;
// typedef typename std::iterator_traits<ITER>::reference const_reference;
// typedef typename std::iterator_traits<ITER>::difference_type
// difference_type;
// typedef size_t size_type;
// typedef tab_ref_index_iterator_<ITER> iterator;
// typedef iterator const_iterator;
// typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
// typedef std::reverse_iterator<iterator> reverse_iterator;
// protected :
// ITER begin_;
// dynamic_array<size_type> index_;
// public :
// bool empty(void) const { return index_.empty(); }
// size_type size(void) const { return index_.size(); }
// iterator begin(void) { return iterator(begin_, index_.begin()); }
// const_iterator begin(void) const
// { return iterator(begin_, index_.begin()); }
// iterator end(void) { return iterator(begin_, index_.end()); }
// const_iterator end(void) const { return iterator(begin_, index_.end()); }
// reverse_iterator rbegin(void) { return reverse_iterator(end()); }
// const_reverse_iterator rbegin(void) const
// { return const_reverse_iterator(end()); }
// reverse_iterator rend(void) { return reverse_iterator(begin()); }
// const_reverse_iterator rend(void) const
// { return const_reverse_iterator(begin()); }
// reference front(void) { return *(begin_ +index_[0]); }
// const_reference front(void) const { return *(begin_ +index_[0]); }
// reference back(void) { return *(--(end())); }
// const_reference back(void) const { return *(--(end())); }
// tab_ref_index(void) {}
// tab_ref_index(const ITER &b, const dynamic_array<size_type> &ind)
// { begin_ = b; index_ = ind; }
// // to be changed in a const_reference ?
// value_type operator [](size_type ii) const
// { return *(begin_ + index_[ii]);}
// reference operator [](size_type ii) { return *(begin_ + index_[ii]); }
// };
/// iterator over a gmm::tab_ref_index_ref<ITER,ITER_INDEX>
template<typename ITER, typename ITER_INDEX>
struct tab_ref_index_ref_iterator_
{
typedef typename std::iterator_traits<ITER>::value_type value_type;
typedef typename std::iterator_traits<ITER>::pointer pointer;
typedef typename std::iterator_traits<ITER>::reference reference;
typedef typename std::iterator_traits<ITER>::difference_type
difference_type;
typedef std::random_access_iterator_tag iterator_category;
typedef tab_ref_index_ref_iterator_<ITER, ITER_INDEX> iterator;
typedef size_t size_type;
ITER piter;
ITER_INDEX iter_index;
iterator operator ++(int)
{ iterator tmp = *this; ++iter_index; return tmp; }
iterator operator --(int)
{ iterator tmp = *this; --iter_index; return tmp; }
iterator &operator ++() { ++iter_index; return *this; }
iterator &operator --() { --iter_index; return *this; }
iterator &operator +=(difference_type i)
{ iter_index += i; return *this; }
iterator &operator -=(difference_type i)
{ iter_index -= i; return *this; }
iterator operator +(difference_type i) const
{ iterator it = *this; return (it += i); }
iterator operator -(difference_type i) const
{ iterator it = *this; return (it -= i); }
difference_type operator -(const iterator &i) const
{ return iter_index - i.iter_index; }
reference operator *() const
{ return *(piter + *iter_index); }
reference operator [](size_type ii) const
{ return *(piter + *(iter_index+ii)); }
bool operator ==(const iterator &i) const
{ return ((piter) == ((i.piter)) && iter_index == i.iter_index); }
bool operator !=(const iterator &i) const { return !(i == *this); }
bool operator < (const iterator &i) const
{ return ((piter) == ((i.piter)) && iter_index < i.iter_index); }
tab_ref_index_ref_iterator_(void) {}
tab_ref_index_ref_iterator_(const ITER &iter,
const ITER_INDEX &dnas_iter)
: piter(iter), iter_index(dnas_iter) {}
};
/**
convenience template function for quick obtention of a indexed iterator
without having to specify its (long) typename
*/
template<typename ITER, typename ITER_INDEX>
tab_ref_index_ref_iterator_<ITER,ITER_INDEX>
index_ref_iterator(ITER it, ITER_INDEX it_i) {
return tab_ref_index_ref_iterator_<ITER,ITER_INDEX>(it, it_i);
}
/** indexed array reference (given a container X, and a set of indexes I,
this class provides a pseudo-container Y such that
@code Y[i] = X[I[i]] @endcode
*/
template<typename ITER, typename ITER_INDEX> class tab_ref_index_ref {
public :
typedef std::iterator_traits<ITER> traits_type;
typedef typename traits_type::value_type value_type;
typedef typename traits_type::pointer pointer;
typedef typename traits_type::pointer const_pointer;
typedef typename traits_type::reference reference;
typedef typename traits_type::reference const_reference;
typedef typename traits_type::difference_type difference_type;
typedef size_t size_type;
typedef tab_ref_index_ref_iterator_<ITER, ITER_INDEX> iterator;
typedef iterator const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
protected :
ITER begin_;
ITER_INDEX index_begin_, index_end_;
public :
bool empty(void) const { return index_begin_ == index_end_; }
size_type size(void) const { return index_end_ - index_begin_; }
iterator begin(void) { return iterator(begin_, index_begin_); }
const_iterator begin(void) const
{ return iterator(begin_, index_begin_); }
iterator end(void) { return iterator(begin_, index_end_); }
const_iterator end(void) const { return iterator(begin_, index_end_); }
reverse_iterator rbegin(void) { return reverse_iterator(end()); }
const_reverse_iterator rbegin(void) const
{ return const_reverse_iterator(end()); }
reverse_iterator rend(void) { return reverse_iterator(begin()); }
const_reverse_iterator rend(void) const
{ return const_reverse_iterator(begin()); }
reference front(void) { return *(begin_ + *index_begin_); }
const_reference front(void) const { return *(begin_ + *index_begin_); }
reference back(void) { return *(--(end())); }
const_reference back(void) const { return *(--(end())); }
void pop_front(void) { ++index_begin_; }
tab_ref_index_ref(void) {}
tab_ref_index_ref(const ITER &b, const ITER_INDEX &bi,
const ITER_INDEX &ei)
: begin_(b), index_begin_(bi), index_end_(ei) {}
// to be changed in a const_reference ?
const_reference operator [](size_type ii) const
{ return *(begin_ + index_begin_[ii]);}
reference operator [](size_type ii)
{ return *(begin_ + index_begin_[ii]); }
};
/* ********************************************************************* */
/* Reference on regularly spaced elements. */
/* ********************************************************************* */
template<typename ITER> struct tab_ref_reg_spaced_iterator_ {
typedef typename std::iterator_traits<ITER>::value_type value_type;
typedef typename std::iterator_traits<ITER>::pointer pointer;
typedef typename std::iterator_traits<ITER>::reference reference;
typedef typename std::iterator_traits<ITER>::difference_type
difference_type;
typedef typename std::iterator_traits<ITER>::iterator_category
iterator_category;
typedef size_t size_type;
typedef tab_ref_reg_spaced_iterator_<ITER> iterator;
ITER it;
size_type N, i;
iterator operator ++(int) { iterator tmp = *this; i++; return tmp; }
iterator operator --(int) { iterator tmp = *this; i--; return tmp; }
iterator &operator ++() { i++; return *this; }
iterator &operator --() { i--; return *this; }
iterator &operator +=(difference_type ii) { i+=ii; return *this; }
iterator &operator -=(difference_type ii) { i-=ii; return *this; }
iterator operator +(difference_type ii) const
{ iterator itt = *this; return (itt += ii); }
iterator operator -(difference_type ii) const
{ iterator itt = *this; return (itt -= ii); }
difference_type operator -(const iterator &ii) const
{ return (N ? (it - ii.it) / N : 0) + i - ii.i; }
reference operator *() const { return *(it + i*N); }
reference operator [](size_type ii) const { return *(it + (i+ii)*N); }
bool operator ==(const iterator &ii) const
{ return (*this - ii) == difference_type(0); }
bool operator !=(const iterator &ii) const
{ return (*this - ii) != difference_type(0); }
bool operator < (const iterator &ii) const
{ return (*this - ii) < difference_type(0); }
tab_ref_reg_spaced_iterator_(void) {}
tab_ref_reg_spaced_iterator_(const ITER &iter, size_type n, size_type ii)
: it(iter), N(n), i(ii) { }
};
/**
convenience template function for quick obtention of a strided iterator
without having to specify its (long) typename
*/
template<typename ITER> tab_ref_reg_spaced_iterator_<ITER>
reg_spaced_iterator(ITER it, size_t stride) {
return tab_ref_reg_spaced_iterator_<ITER>(it, stride);
}
/**
provide a "strided" view a of container
*/
template<typename ITER> class tab_ref_reg_spaced {
public :
typedef typename std::iterator_traits<ITER>::value_type value_type;
typedef typename std::iterator_traits<ITER>::pointer pointer;
typedef typename std::iterator_traits<ITER>::pointer const_pointer;
typedef typename std::iterator_traits<ITER>::reference reference;
typedef typename std::iterator_traits<ITER>::reference const_reference;
typedef typename std::iterator_traits<ITER>::difference_type
difference_type;
typedef size_t size_type;
typedef tab_ref_reg_spaced_iterator_<ITER> iterator;
typedef iterator const_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
protected :
ITER begin_;
size_type N, size_;
public :
bool empty(void) const { return size_ == 0; }
size_type size(void) const { return size_; }
iterator begin(void) { return iterator(begin_, N, 0); }
const_iterator begin(void) const { return iterator(begin_, N, 0); }
iterator end(void) { return iterator(begin_, N, size_); }
const_iterator end(void) const { return iterator(begin_, N, size_); }
reverse_iterator rbegin(void) { return reverse_iterator(end()); }
const_reverse_iterator rbegin(void) const
{ return const_reverse_iterator(end()); }
reverse_iterator rend(void) { return reverse_iterator(begin()); }
const_reverse_iterator rend(void) const
{ return const_reverse_iterator(begin()); }
reference front(void) { return *begin_; }
const_reference front(void) const { return *begin_; }
reference back(void) { return *(begin_ + N * (size_-1)); }
const_reference back(void) const { return *(begin_ + N * (size_-1)); }
void pop_front(void) { begin_ += N; }
tab_ref_reg_spaced(void) {}
tab_ref_reg_spaced(const ITER &b, size_type n, size_type s)
: begin_(b), N(n), size_(s) {}
const_reference operator [](size_type ii) const
{ return *(begin_ + ii * N);}
reference operator [](size_type ii) { return *(begin_ + ii * N); }
};
/// iterator over a tab_ref_with_selection
template<typename ITER, typename COND>
struct tab_ref_with_selection_iterator_ : public ITER {
typedef typename std::iterator_traits<ITER>::value_type value_type;
typedef typename std::iterator_traits<ITER>::pointer pointer;
typedef typename std::iterator_traits<ITER>::reference reference;
typedef typename std::iterator_traits<ITER>::difference_type
difference_type;
typedef std::forward_iterator_tag iterator_category;
typedef tab_ref_with_selection_iterator_<ITER, COND> iterator;
const COND cond;
void forward(void) { while (!(cond)(*this)) ITER::operator ++(); }
iterator &operator ++()
{ ITER::operator ++(); forward(); return *this; }
iterator operator ++(int)
{ iterator tmp = *this; ++(*this); return tmp; }
tab_ref_with_selection_iterator_(void) {}
tab_ref_with_selection_iterator_(const ITER &iter, const COND c)
: ITER(iter), cond(c) {}
};
/**
given a container X and a predicate P, provide pseudo-container Y
of all elements of X such that P(X[i]).
*/
template<typename ITER, typename COND> class tab_ref_with_selection {
protected :
ITER begin_, end_;
COND cond;
public :
typedef typename std::iterator_traits<ITER>::value_type value_type;
typedef typename std::iterator_traits<ITER>::pointer pointer;
typedef typename std::iterator_traits<ITER>::pointer const_pointer;
typedef typename std::iterator_traits<ITER>::reference reference;
typedef typename std::iterator_traits<ITER>::reference const_reference;
typedef size_t size_type;
typedef tab_ref_with_selection_iterator_<ITER, COND> iterator;
typedef iterator const_iterator;
iterator begin(void) const
{ iterator it(begin_, cond); it.forward(); return it; }
iterator end(void) const { return iterator(end_, cond); }
bool empty(void) const { return begin_ == end_; }
value_type front(void) const { return *begin(); }
void pop_front(void) { ++begin_; begin_ = begin(); }
COND &condition(void) { return cond; }
const COND &condition(void) const { return cond; }
tab_ref_with_selection(void) {}
tab_ref_with_selection(const ITER &b, const ITER &e, const COND &c)
: begin_(b), end_(e), cond(c) { begin_ = begin(); }
};
}
#endif /* GMM_REF_H__ */
Reference in New Issue View Git Blame Copy Permalink