Skip to content
Snippets Groups Projects
Commit a7811f02 authored by Jö Fahlke's avatar Jö Fahlke
Browse files

Merge branch 'remove-basearray' into 'master' 

[cleanup] Remove base_array and base_array_window.

See merge request core/dune-istl!201
parents f5fd1e5f 412cfd32
Branches
Tags
1 merge request!201[cleanup] Remove base_array and base_array_window.
Pipeline #
Hide whitespace changes
Inline Side-by-side
dune/istl/basearray.hh
+ 0
− 242
View file @ a7811f02
......@@ -279,248 +279,6 @@ namespace Imp {
/** \brief Extend base_array_unmanaged by functions to manipulate
This container has *NO* memory management at all,
copy constuctor, assignment and destructor are all default.
A container can be constructed as empty or from a given pointer
and size. This class is used to implement a view into a larger
array.
You can copy such an object to a base_array to make a real copy.
Error checking: no error checking is provided normally.
Setting the compile time switch DUNE_ISTL_WITH_CHECKING
enables error checking.
\internal This class is an implementation detail, and should not be used outside of dune-istl.
*/
template<class B, class A=std::allocator<B> >
class base_array_window : public base_array_unmanaged<B,A>
{
public:
//===== type definitions and constants
//! export the type representing the components
typedef B member_type;
//! export the allocator type
typedef A allocator_type;
//! make iterators available as types
typedef typename base_array_unmanaged<B,A>::iterator iterator;
//! make iterators available as types
typedef typename base_array_unmanaged<B,A>::const_iterator const_iterator;
//! The type used for the index access
typedef typename base_array_unmanaged<B,A>::size_type size_type;
//! The type used for the difference between two iterator positions
typedef typename A::difference_type difference_type;
//===== constructors and such
//! makes empty array
base_array_window ()
: base_array_unmanaged<B,A>()
{ }
//! make array from given pointer and size
base_array_window (B* _p, size_type _n)
: base_array_unmanaged<B,A>(_n ,_p)
{}
//===== window manipulation methods
//! set pointer and length
void set (size_type _n, B* _p)
{
this->n = _n;
this->p = _p;
}
//! advance pointer by newsize elements and then set size to new size
void advance (difference_type newsize)
{
this->p += this->n;
this->n = newsize;
}
//! increment pointer by offset and set size
void move (difference_type offset, size_type newsize)
{
this->p += offset;
this->n = newsize;
}
//! increment pointer by offset, leave size
void move (difference_type offset)
{
this->p += offset;
}
//! return the pointer
B* getptr ()
{
return this->p;
}
};
/** \brief This container extends base_array_unmanaged by memory management
with the usual copy semantics providing the full range of
copy constructor, destructor and assignment operators.
You can make
- empty array
- array with n components dynamically allocated
- resize an array with complete loss of data
- assign/construct from a base_array_window to make a copy of the data
Error checking: no error checking is provided normally.
Setting the compile time switch DUNE_ISTL_WITH_CHECKING
enables error checking.
\internal This class is an implementation detail, and should not be used outside of dune-istl.
*/
template<class B, class A=std::allocator<B> >
class base_array : public base_array_unmanaged<B,A>
{
public:
//===== type definitions and constants
//! export the type representing the components
typedef B member_type;
//! export the allocator type
typedef A allocator_type;
//! make iterators available as types
typedef typename base_array_unmanaged<B,A>::iterator iterator;
//! make iterators available as types
typedef typename base_array_unmanaged<B,A>::const_iterator const_iterator;
//! The type used for the index access
typedef typename base_array_unmanaged<B,A>::size_type size_type;
//! The type used for the difference between two iterator positions
typedef typename A::difference_type difference_type;
//===== constructors and such
//! makes empty array
base_array ()
: base_array_unmanaged<B,A>()
{}
//! make array with _n components
base_array (size_type _n)
: base_array_unmanaged<B,A>(_n, 0)
{
if (this->n>0) {
this->p = allocator_.allocate(this->n);
new (this->p)B[this->n];
} else
{
this->n = 0;
this->p = 0;
}
}
//! copy constructor
base_array (const base_array& a)
{
// allocate memory with same size as a
this->n = a.n;
if (this->n>0) {
this->p = allocator_.allocate(this->n);
new (this->p)B[this->n];
} else
{
this->n = 0;
this->p = 0;
}
// and copy elements
for (size_type i=0; i<this->n; i++) this->p[i]=a.p[i];
}
//! free dynamic memory
~base_array ()
{
if (this->n>0) {
int i=this->n;
while (i)
this->p[--i].~B();
allocator_.deallocate(this->p,this->n);
}
}
//! reallocate array to given size, any data is lost
void resize (size_type _n)
{
if (this->n==_n) return;
if (this->n>0) {
int i=this->n;
while (i)
this->p[--i].~B();
allocator_.deallocate(this->p,this->n);
}
this->n = _n;
if (this->n>0) {
this->p = allocator_.allocate(this->n);
new (this->p)B[this->n];
} else
{
this->n = 0;
this->p = 0;
}
}
//! assignment
base_array& operator= (const base_array& a)
{
if (&a!=this) // check if this and a are different objects
{
// adjust size of array
if (this->n!=a.n) // check if size is different
{
if (this->n>0) {
int i=this->n;
while (i)
this->p[--i].~B();
allocator_.deallocate(this->p,this->n); // delete old memory
}
this->n = a.n;
if (this->n>0) {
this->p = allocator_.allocate(this->n);
new (this->p)B[this->n];
} else
{
this->n = 0;
this->p = 0;
}
}
// copy data
for (size_type i=0; i<this->n; i++) this->p[i]=a.p[i];
}
return *this;
}
protected:
A allocator_;
};
/** \brief A simple array container with non-consecutive index set.
Elements in the array are of type B. This class provides
......
dune/istl/test/CMakeLists.txt
+ 0
− 2
View file @ a7811f02
......@@ -2,8 +2,6 @@
install(FILES vectortest.hh
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/istl/test)
dune_add_test(SOURCES basearraytest.cc)
dune_add_test(SOURCES bcrsassigntest.cc)
dune_add_test(SOURCES bcrsnormtest.cc)
......
dune/istl/test/basearraytest.cc deleted 100644 → 0
+ 0
− 18
View file @ f5fd1e5f
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#include "config.h"
#include <dune/istl/basearray.hh>
using namespace Dune;
int main()
{
Imp::base_array<double> v1(10);
Imp::base_array<double> v2 = v1;
v1.resize(20);
v1 = v2;
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment