SaraP
669 lines
28 KiB
C++
669 lines
28 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
||
/**
|
||
\file
|
||
\brief \ru Упорядоченный массив индексов присланного PArray.
|
||
\en Ordered array of indices of the given PArray. \~
|
||
|
||
*/
|
||
////////////////////////////////////////////////////////////////////////////////
|
||
|
||
#ifndef __TEMPL_IM_ARRAY_H
|
||
#define __TEMPL_IM_ARRAY_H
|
||
|
||
|
||
#include <templ_s_array.h>
|
||
#include <templ_p_array.h>
|
||
|
||
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( class IMArray );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( Type * add_to_array ( IMArray<Type> &, size_t ind, size_t * ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( size_t add_to_array ( IMArray<Type> &, Type * el, size_t * ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( size_t find_in_array ( const IMArray<Type> &, const void *, size_t * ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( void array_remove_ind ( IMArray<Type> &, size_t delIndex, bool completely ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( void array_remove_obj ( IMArray<Type> &, const size_t & delObj, bool completely ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( size_t find_my_index ( const IMArray<Type> &, size_t ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( Type * reindex_array_obj ( IMArray<Type> &, size_t ind, size_t * myIndex ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( size_t reindex_array_obj ( IMArray<Type> &, Type * el, size_t * myIndex ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( Type * reindex_array_ind ( IMArray<Type> &, size_t myIndex ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( bool exchange_to_array ( IMArray<Type> &, size_t ind1, size_t ind2 ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( void reindexall_to_array ( IMArray<Type> & ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( void array_reduction_obj ( IMArray<Type> & arr, const size_t & delObject ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( reader& CALL_DECLARATION operator >> ( reader& in, IMArray<Type> & ref ) );
|
||
FORVARD_DECL_TEMPLATE_TYPENAME( writer& CALL_DECLARATION operator << ( writer& out, const IMArray<Type> & ref ) );
|
||
|
||
|
||
//------------------------------------------------------------------------------
|
||
/** \brief \ru Упорядоченный массив индексов присланного PArray.
|
||
\en Ordered array of indices of the given PArray. \~
|
||
\details \ru Упорядоченный массив индексов присланного PArray. \n
|
||
\en Ordered array of indices of the given PArray. \n \~
|
||
\ingroup Base_Tools_Containers
|
||
*/
|
||
// ---
|
||
template <class Type>
|
||
class IMArray : private SArray<size_t> {
|
||
public :
|
||
typedef int (Type::*Compare_t)( const Type * );
|
||
typedef int (Type::*Compare_v)( const void * );
|
||
|
||
PArray<Type> & array;
|
||
Compare_t compT; // \ru функция сортировки используется при добавлении объекта \en sorting function is used while adding an object
|
||
Compare_v compV; // \ru функция сортировки используется при поиске объекта \en sorting function is used while search an object
|
||
|
||
public:
|
||
IMArray( PArray< Type > & arr, Compare_t c_t, Compare_v c_v, size_t maxCnt = 0, uint16 delt = 1 );
|
||
|
||
using SArray<size_t>::Flush;
|
||
using SArray<size_t>::Count;
|
||
using SArray<size_t>::Sort; // \ru сортировать массив \en sort the array
|
||
using SArray<size_t>::Reserve;
|
||
using SArray<size_t>::SetSize;
|
||
|
||
using SArray<size_t>::empty;
|
||
using SArray<size_t>::size;
|
||
using SArray<size_t>::reserve;
|
||
using SArray<size_t>::capacity;
|
||
using SArray<size_t>::begin;
|
||
using SArray<size_t>::end;
|
||
using SArray<size_t>::front;
|
||
using SArray<size_t>::back;
|
||
using SArray<size_t>::clear;
|
||
|
||
Type * Add( size_t ind, size_t * ); // \ru добавить элемент с упорядочиванием по массиву \en add element with sorting
|
||
size_t Add( Type * ent, size_t * ); // \ru добавить элемент с упорядочиванием по массиву \en add element with sorting
|
||
|
||
Type * operator [] ( size_t ) const;
|
||
size_t & operator () ( size_t ) const;
|
||
IMArray<Type> & operator = ( const IMArray<Type> & );
|
||
|
||
size_t Find ( const void *, size_t * ) const; // \ru найти элемент в упорядоченном массиве \en find an element in ordered array
|
||
size_t GetIndex ( size_t myIndex ) const;
|
||
size_t GetMyIndex( size_t parentIndex ) const;
|
||
|
||
void RemoveInd ( size_t delIndex, bool completely = true ); // \ru удалить элемент из массива \en delete an element from array
|
||
void RemoveObj ( const size_t & delObject, bool completely = true ); // \ru удалить элемент из массива \en delete an element from array
|
||
|
||
Type * ReindexInd( size_t ind, size_t * = nullptr ); // \ru заменить элемент с упорядочиванием по массиву \en replace element with sorting
|
||
size_t ReindexObj( Type * ent, size_t * = nullptr ); // \ru заменить элемент с упорядочиванием по массиву \en replace element with sorting
|
||
|
||
Type * ReindexMyInd( size_t ); // \ru заменить элемент с упорядочиванием по массиву \en replace element with sorting
|
||
|
||
bool Exchange ( size_t ind1, size_t ind2 ); // \ru поменять местами по индексам в папином массиве \en swap by indices in the parent array
|
||
void ReindexAll (); // \ru перестроить индексный массив \en reconstruct the index array
|
||
|
||
bool ReductionObj( const size_t & delObject ); // \ru понижение всех индексов > delObject \en decrease of all indices greater than 'delObject'
|
||
|
||
TEMPLATE_FRIEND Type * add_to_array TEMPLATE_SUFFIX ( IMArray<Type> &, size_t ind, size_t * );
|
||
TEMPLATE_FRIEND size_t add_to_array TEMPLATE_SUFFIX ( IMArray<Type> &, Type * el, size_t * );
|
||
TEMPLATE_FRIEND size_t find_in_array TEMPLATE_SUFFIX ( const IMArray<Type> &, const void *, size_t * );
|
||
TEMPLATE_FRIEND void array_remove_ind TEMPLATE_SUFFIX ( IMArray<Type> &, size_t delIndex, bool completely );
|
||
TEMPLATE_FRIEND void array_remove_obj TEMPLATE_SUFFIX ( IMArray<Type> &, const size_t & delObj, bool completely );
|
||
TEMPLATE_FRIEND size_t find_my_index TEMPLATE_SUFFIX ( const IMArray<Type> &, size_t );
|
||
TEMPLATE_FRIEND Type * reindex_array_obj TEMPLATE_SUFFIX ( IMArray<Type> &, size_t ind, size_t * myIndex );
|
||
TEMPLATE_FRIEND size_t reindex_array_obj TEMPLATE_SUFFIX ( IMArray<Type> &, Type* el, size_t * myIndex );
|
||
TEMPLATE_FRIEND Type * reindex_array_ind TEMPLATE_SUFFIX ( IMArray<Type> &, size_t myIndex );
|
||
TEMPLATE_FRIEND bool exchange_to_array TEMPLATE_SUFFIX ( IMArray<Type> &, size_t ind1, size_t ind2 );
|
||
TEMPLATE_FRIEND void reindexall_to_array TEMPLATE_SUFFIX ( IMArray<Type> & );
|
||
TEMPLATE_FRIEND void array_reduction_obj TEMPLATE_SUFFIX ( IMArray<Type> &arr, const size_t & delObject );
|
||
|
||
private:
|
||
IMArray( const IMArray<Type> & ); // \ru запрещено !!! \en forbidden !!!
|
||
TEMPLATE_FRIEND reader& CALL_DECLARATION operator >> TEMPLATE_SUFFIX ( reader& in, IMArray<Type> & ref );
|
||
TEMPLATE_FRIEND writer& CALL_DECLARATION operator << TEMPLATE_SUFFIX ( writer& out, const IMArray<Type> & ref );
|
||
|
||
|
||
#ifdef __DEBUG_MEMORY_ALLOCATE_FREE_
|
||
public:
|
||
void * operator new ( size_t );
|
||
void operator delete ( void *, size_t );
|
||
#endif // __DEBUG_MEMORY_ALLOCATE_FREE_
|
||
};
|
||
|
||
|
||
#ifdef __DEBUG_MEMORY_ALLOCATE_FREE_
|
||
//------------------------------------------------------------------------------
|
||
// \ru Перегрузка оператора new. \en Overloading of the "new" operator.
|
||
// ---
|
||
template <class Type>
|
||
inline void * IMArray<Type>::operator new( size_t size ) {
|
||
return ::Allocate( size, typeid(IMArray<Type>).name() );
|
||
}
|
||
|
||
//------------------------------------------------------------------------------
|
||
// \ru Перегрузка оператора delete. \en Overloading of the "delete" operator.
|
||
// ---
|
||
template <class Type>
|
||
inline void IMArray<Type>::operator delete ( void * ptr, size_t size ) {
|
||
::Free( ptr, size, typeid(IMArray<Type>).name() );
|
||
}
|
||
#endif // __DEBUG_MEMORY_ALLOCATE_FREE_
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru конструктор массива \en constructor of an array
|
||
// ---
|
||
template <class Type>
|
||
inline IMArray<Type>::IMArray( PArray< Type > & arr, Compare_t c_t, Compare_v c_v, size_t maxCnt, uint16 delt )
|
||
: SArray< size_t >( maxCnt, delt ), array(arr), compT(c_t), compV(c_v) {}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru добавить объект по индексу в PAarray \en add an object by the index in PArray
|
||
// ---
|
||
template <class Type>
|
||
inline Type* IMArray<Type>::Add( size_t ind, size_t * myIndex ) {
|
||
return add_to_array( *this, ind, myIndex );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru добавить объект, объект в PArray должен быть \en add an object, the object in PArray should exist
|
||
// ---
|
||
template <class Type>
|
||
inline size_t IMArray<Type>::Add( Type * el, size_t * myIndex ) {
|
||
return add_to_array( *this, el, myIndex );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru удалить объект по индексу \en delete an object by index
|
||
// \ru completely = true - с понижением всех индексов > delIndex \en completely = true - with decrease of all indices greater than delIndex
|
||
// ---
|
||
template <class Type>
|
||
inline void IMArray<Type>::RemoveInd( size_t delIndex, bool completely ) {
|
||
array_remove_ind( *this, delIndex, completely );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru удалить объект \en delete an object
|
||
// \ru completely = true - с понижением всех индексов > delIndex \en completely = true - with decrease of all indices greater than delIndex
|
||
// ---
|
||
template <class Type>
|
||
inline void IMArray<Type>::RemoveObj( const size_t & delObject, bool completely ){
|
||
array_remove_obj( *this, delObject, completely );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru понижение всех индексов > delObject \en decrease of all indices greater than 'delObject'
|
||
// ---
|
||
template <class Type>
|
||
inline bool IMArray<Type>::ReductionObj( const size_t & delObject ) {
|
||
// \ru АВВ К12 Результат нужен только из этой функции \en АВВ К12 Only the result of this function is required
|
||
// \ru АВВ К12 array_reduction_obj сделал void-ной для ускорения \en АВВ К12 array_reduction_obj is void for acceleration
|
||
// \ru АВВ К12 return array_reduction_obj( *this, delObject ); \en АВВ К12 return array_reduction_obj( *this, delObject );
|
||
bool res = false;
|
||
size_t * parr = (size_t *)GetAddr();
|
||
size_t * end = parr + count;
|
||
|
||
while ( parr < end )
|
||
{
|
||
if ( *parr > delObject )
|
||
{
|
||
--(*parr);
|
||
res = true;
|
||
}
|
||
parr++;
|
||
}
|
||
|
||
return res;
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru переупорядочить объект по индексу в PArray \en reorder an object by the index in PArray
|
||
// \ru функция возвращает указатель на объект и индекс объекта в IMArray \en the function returns a pointer to the object and an index of the object in IMArray
|
||
// ---
|
||
template <class Type>
|
||
inline Type* IMArray<Type>::ReindexInd( size_t ind, size_t * myIndex ) {
|
||
return reindex_array_obj( *this, ind, myIndex );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru переупорядочить объект \en reorder an object
|
||
// \ru функция возвращает индекс объекта в PArray и индекс объекта в IMArray \en the function returns an index of the object in PArray and an index of the object in IMArray
|
||
// ---
|
||
template <class Type>
|
||
inline size_t IMArray<Type>::ReindexObj( Type * ent, size_t * myIndex ) {
|
||
return reindex_array_obj( *this, ent, myIndex );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru переупорядочить объект \en reorder an object
|
||
// \ru функция возвращает указатель на объект \en the function returns a pointer to the object
|
||
// ---
|
||
template <class Type>
|
||
inline Type * IMArray<Type>::ReindexMyInd( size_t myIndex ) {
|
||
return reindex_array_ind( *this, myIndex );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru поменять идексы в PArray местами \en swap indices in PArray
|
||
// ---
|
||
template <class Type>
|
||
inline bool IMArray<Type>::Exchange ( size_t ind1, size_t ind2 ) {
|
||
return exchange_to_array( *this, ind1, ind2 );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru переупорядочить весь массив \en reorder the whole array
|
||
// ---
|
||
template <class Type>
|
||
inline void IMArray<Type>::ReindexAll() {
|
||
reindexall_to_array( *this );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru оператор индексирования \en indexing operator
|
||
// ---
|
||
template <class Type>
|
||
inline Type* IMArray<Type>::operator [] ( size_t ind ) const {
|
||
return array[ SArray < size_t >::operator []( ind ) ];
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru оператор присвоения \en assignment operator
|
||
// ---
|
||
template <class Type>
|
||
inline IMArray<Type>& IMArray<Type>::operator = ( const IMArray<Type> & o ) {
|
||
SArray< size_t >::operator = ( o );
|
||
return *this;
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru найти объект удовлетворяющий условию \en find an object satisfying the condition
|
||
// ---
|
||
template <class Type>
|
||
inline size_t IMArray<Type>::Find( const void * val, size_t * myIndex ) const {
|
||
return find_in_array( *this, val, myIndex );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru получить индекс объекта в PArray по иедексу в IMArray \en get an index of object in PArray by the index in IMArray
|
||
// ---
|
||
template <class Type>
|
||
inline size_t IMArray<Type>::GetIndex( size_t myIndex ) const {
|
||
return SArray< size_t >::operator[] (myIndex);
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru получить индекс объекта в IMArray по индексу в PArray (перебор) \en get an index of object in PArray by the index in IMArray (full search)
|
||
// ---
|
||
template <class Type>
|
||
inline size_t IMArray<Type>::GetMyIndex( size_t parentIndex ) const {
|
||
return find_my_index( *this, parentIndex );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru оператор приведения \en adduction operator
|
||
// ---
|
||
template <class Type>
|
||
inline size_t & IMArray<Type>::operator ()( size_t myIndex ) const {
|
||
return SArray< size_t >::operator[] ( myIndex );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru добавить объект с упорядочиванием \en add an object with sorting
|
||
// ---
|
||
template <class Type>
|
||
Type * add_to_array( IMArray<Type> & arr, size_t ind, size_t * myIndex ) {
|
||
PRECONDITION( ind < arr.array.Count() );
|
||
|
||
Type * el = 0;
|
||
size_t mcIArr = SYS_MAX_T; // \ru текущий индекс в IMArray \en the current index in IMArray
|
||
|
||
if ( ind < arr.array.Count() ) {
|
||
el = arr.array[ind];
|
||
|
||
if ( el ) {
|
||
|
||
if ( !arr.count ) {
|
||
arr.SArray< size_t >::Add( ind );
|
||
mcIArr = 0;
|
||
}
|
||
else {
|
||
size_t ml = 0;
|
||
mcIArr = ml;
|
||
size_t mcPArr = arr.GetIndex( mcIArr ); // \ru текущий индекс в PArray \en the current index in PArray
|
||
|
||
// \ru проверяем первый эл. \en check the first element
|
||
int resL = ( el->*arr.compT )( arr.array[mcPArr] );
|
||
|
||
// \ru если элемент меньше первого, вставляем перед первым \en if an element is less than the first element then place it before the first element
|
||
if ( resL < 0 )
|
||
arr.InsertInd( mcIArr, ind );
|
||
else {
|
||
size_t mr = arr.count - 1;
|
||
mcIArr = mr;
|
||
mcPArr = arr.GetIndex( mcIArr );
|
||
|
||
// \ru проверяем последний эл. \en check the last element
|
||
int resR = !mcIArr ? resL : ( el->*arr.compT )( arr.array[mcPArr] );
|
||
|
||
// \ru если один объект в массиве или эл. больше или равен последнему, \en if one object in the array or an element is not less than the last element,
|
||
// \ru должны попасть сюда \en should be here
|
||
if ( !mcIArr || resR >= 0 ) {
|
||
arr.SArray< size_t >::Add( ind );
|
||
mcIArr = mr + 1;
|
||
}
|
||
else {
|
||
if ( arr.count == 2 )
|
||
arr.InsertInd( mcIArr, ind );
|
||
else {
|
||
|
||
// \ru сюда попадаем если resL >= 0 и resR < 0 \en this is the case when resL >= 0 and resR < 0
|
||
while ( ml + 1 < mr ) { // \ru пока не нашли - ищем \en seek until do not find
|
||
|
||
if ( !resL ) {
|
||
mcIArr = ml;
|
||
|
||
// 68759 do {
|
||
// mcIArr++;
|
||
// mcPArr = arr.GetIndex( mcIArr );
|
||
// } while ( (el->*arr.compT)( arr.array[mcPArr] ) == 0 );
|
||
mcIArr++;
|
||
mcPArr = arr.GetIndex( mcIArr );
|
||
|
||
break;
|
||
}
|
||
else {
|
||
size_t md = ( ml + mr ) / 2;
|
||
mcPArr = arr.GetIndex( md );
|
||
|
||
int res = ( el->*arr.compT )( arr.array[mcPArr] );
|
||
|
||
if ( res > 0 )
|
||
ml = md;
|
||
else if ( res < 0 ) {
|
||
mr = md;
|
||
mcIArr = md;
|
||
}
|
||
else {
|
||
resL = res; //res = 0
|
||
mcIArr = md + 1; // \ru если ml + 1 < mr не выполнится объект должен добавиться после md \en if ml + 1 is not less than mr then the object should be added after md
|
||
ml = md;
|
||
}
|
||
}
|
||
}
|
||
|
||
arr.InsertInd( mcIArr, ind );
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if ( myIndex )
|
||
*myIndex = mcIArr;
|
||
|
||
return el;
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru добавить объект с упорядочиванием \en add an object with sorting
|
||
// \ru получить индекс объекта в PArray \en get an index of the object in PArray
|
||
// ---
|
||
template <class Type>
|
||
size_t add_to_array( IMArray<Type> & arr, Type * el, size_t * myIndex ) {
|
||
size_t ind = SYS_MAX_T;
|
||
ptrdiff_t mi = arr.array.MaxIndex();
|
||
|
||
if ( mi >= 0 ) {
|
||
|
||
if ( arr.array[mi] == el )
|
||
ind = mi;
|
||
else
|
||
ind = arr.array.FindIt(el);
|
||
}
|
||
|
||
if ( ind == SYS_MAX_T ) {
|
||
|
||
if ( myIndex )
|
||
*myIndex = SYS_MAX_T;
|
||
}
|
||
else
|
||
add_to_array( arr, ind, myIndex );
|
||
|
||
return ind;
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru найти объект в массиве, удовлетворяющий условию \en find an object in array, satisfying the condition
|
||
// \ru поиск ведется методом половинных делений \en a search is performed by the bisection method
|
||
// ---
|
||
template <class Type>
|
||
size_t find_in_array( const IMArray<Type> & arr, const void * val, size_t * myIndex ) {
|
||
// \ru общий случай - элементов больше двух \en the common case - the number of elements is more than two
|
||
int res = 1;
|
||
|
||
size_t mcIArr; // \ru текущий индекс в IMArray \en the current index in IMArray
|
||
size_t mcPArr; // \ru текущий индекс в PArray \en the current index in PArray
|
||
|
||
if ( arr.count > 3 ) {
|
||
size_t mr = arr.count - 1;
|
||
|
||
size_t mxc = mr;
|
||
size_t ml = 0;
|
||
|
||
while ( ml + 1 < mr ) { // \ru пока не нашли - ищем \en seek until do not find
|
||
mcIArr = ( ml + mr ) / 2;
|
||
mcPArr = arr.GetIndex( mcIArr );
|
||
res = (arr.array[mcPArr]->*arr.compV)( val );
|
||
|
||
if ( res == 1 )
|
||
mr = mcIArr;
|
||
else if ( res == - 1 )
|
||
ml = mcIArr;
|
||
else
|
||
break;
|
||
}
|
||
|
||
if ( res ) {
|
||
// \ru проверка по границам \en check by bounds
|
||
mcIArr = 0;
|
||
mcPArr = arr.GetIndex( mcIArr );
|
||
res = (arr.array[mcPArr]->*arr.compV)( val );
|
||
|
||
if ( res ) {
|
||
mcIArr = mxc;
|
||
mcPArr = arr.GetIndex( mcIArr );
|
||
res = (arr.array[mcPArr]->*arr.compV)( val );
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
|
||
for( mcIArr = 0; mcIArr < arr.count; mcIArr++ ) {
|
||
mcPArr = arr.GetIndex( mcIArr );
|
||
res = (arr.array[mcPArr]->*arr.compV)( val );
|
||
|
||
if ( res >= 0 )
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ( res ) {
|
||
mcIArr = SYS_MAX_T;
|
||
mcPArr = SYS_MAX_T;
|
||
}
|
||
|
||
if ( myIndex )
|
||
*myIndex = mcIArr;
|
||
|
||
return mcPArr;
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru удалить объект по индексу \en delete an object by index
|
||
// \ru completely = true - с понижением всех индексов > delIndex \en completely = true - with decrease of all indices greater than delIndex
|
||
// ---
|
||
template <class Type>
|
||
void array_remove_ind( IMArray<Type> & arr, size_t delIndex, bool completely ){
|
||
PRECONDITION( delIndex < arr.count );
|
||
if ( delIndex < arr.count ) {
|
||
size_t arrayIndex = arr.GetIndex( delIndex ); //arr.parr[ delIndex ];
|
||
arr.SArray< size_t >::RemoveInd( delIndex );
|
||
if ( completely )
|
||
array_reduction_obj( arr, arrayIndex );
|
||
}
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru удалить объект \en delete an object
|
||
// \ru completely = true - с понижением всех индексов > delIndex \en completely = true - with decrease of all indices greater than delIndex
|
||
// ---
|
||
template <class Type>
|
||
void array_remove_obj( IMArray<Type> & arr, const size_t & delObject, bool completely ){
|
||
arr.SArray< size_t >::RemoveObj( delObject );
|
||
|
||
if ( completely )
|
||
array_reduction_obj( arr, delObject );
|
||
}
|
||
|
||
// \ru АВВ К12 //------------------------------------------------------------------------------- \en АВВ К12 //-------------------------------------------------------------------------------
|
||
// \ru АВВ К12 // понижение всех индексов > delObject \en АВВ К12 // decrease of all indices greater than delObject
|
||
// \ru АВВ К12 // --- \en АВВ К12 // ---
|
||
// \ru АВВ К12 template <class Type> \en АВВ К12 template <class Type>
|
||
// \ru АВВ К12 bool array_reduction_obj( IMArray<Type> & arr, const uint & delObject ){ \en АВВ К12 bool array_reduction_obj( IMArray<Type> & arr, const uint & delObject ){
|
||
// \ru АВВ К12 bool res = false; \en АВВ К12 bool res = false;
|
||
// \ru АВВ К12 const uint *parr = arr.GetAddr(); \en АВВ К12 const uint *parr = arr.GetAddr();
|
||
// \ru АВВ К12 \en АВВ К12
|
||
// \ru АВВ К12 for( uint i = 0; i < arr.count; i++ ) { \en АВВ К12 for( uint i = 0; i < arr.count; i++ ) {
|
||
// \ru АВВ К12 uint *parrI = (uint *)(parr + i); \en АВВ К12 uint *parrI = (uint *)(parr + i);
|
||
// \ru АВВ К12 \en АВВ К12
|
||
// \ru АВВ К12 if ( *parrI > delObject ){ \en АВВ К12 if ( *parrI > delObject ){
|
||
// \ru АВВ К12 (*parrI)--; \en АВВ К12 (*parrI)--;
|
||
// \ru АВВ К12 res = true; \en АВВ К12 res = true;
|
||
// \ru АВВ К12 } \en АВВ К12 }
|
||
// \ru АВВ К12 } \en АВВ К12 }
|
||
// \ru АВВ К12 return res; \en АВВ К12 return res;
|
||
// \ru АВВ К12 } \en АВВ К12 }
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru понижение всех индексов > delObject \en decrease of all indices greater than 'delObject'
|
||
// ---
|
||
template <class Type>
|
||
void array_reduction_obj( IMArray<Type> & arr, const size_t & delObject ){
|
||
size_t *parr = (size_t *)arr.GetAddr();
|
||
size_t *end = parr + arr.count;
|
||
|
||
while ( parr < end )
|
||
{
|
||
if ( *parr > delObject )
|
||
--(*parr);
|
||
|
||
parr++;
|
||
}
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru получить индекс объекта в IMArray по индексу в PArray \en get an index of object in PArray by the index in IMArray
|
||
// ---
|
||
template <class Type>
|
||
size_t find_my_index( const IMArray<Type> & arr, size_t parentIndex ) {
|
||
|
||
for ( size_t i = 0; i < arr.count; i++ )
|
||
|
||
if ( arr.GetIndex(i) == parentIndex )
|
||
return i;
|
||
|
||
return SYS_MAX_T;
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru переупорядочить объект в массиве \en reorder an object in the array
|
||
// ---
|
||
template <class Type>
|
||
size_t reindex_array_obj( IMArray<Type> & arr, Type * el, size_t * myIndex ) {
|
||
size_t ind = arr.array.FindIt(el);
|
||
|
||
if ( ind == SYS_MAX_T ) {
|
||
|
||
if ( myIndex )
|
||
*myIndex = SYS_MAX_T;
|
||
return ind;
|
||
}
|
||
|
||
reindex_array_obj( arr, ind, myIndex );
|
||
|
||
return ind;
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru переупорядочить объект в массиве \en reorder an object in the array
|
||
// ---
|
||
template <class Type>
|
||
Type* reindex_array_obj( IMArray<Type> & arr, size_t ind, size_t * myIndex ) {
|
||
arr.SArray< size_t >::RemoveObj( ind );
|
||
return add_to_array( arr, ind, myIndex );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru переупорядочить объект в массиве \en reorder an object in the array
|
||
// ---
|
||
template <class Type>
|
||
Type* reindex_array_ind( IMArray<Type> & arr, size_t myIndex ) {
|
||
size_t ind = arr.GetIndex( myIndex ); //arr.parr[ myIndex ];
|
||
arr.SArray< size_t >::RemoveInd( myIndex );
|
||
return add_to_array( arr, ind, 0 );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru переупорядочить весь массив \en reorder the whole array
|
||
// ---
|
||
template <class Type>
|
||
void reindexall_to_array( IMArray<Type> & arr ) {
|
||
|
||
arr.SArray< size_t >::Flush();
|
||
|
||
for( size_t i = 0; i < arr.array.Count(); i++ )
|
||
add_to_array( arr, i, 0 );
|
||
}
|
||
|
||
|
||
//-------------------------------------------------------------------------------
|
||
// \ru поменять идексы в PArray местами \en swap indices in PArray
|
||
// ---
|
||
template <class Type>
|
||
bool exchange_to_array( IMArray<Type> & arr, size_t ind1, size_t ind2 ) {
|
||
size_t myInd1 = arr.SArray< size_t >::FindIt( ind1 );
|
||
|
||
if ( !(myInd1 == SYS_MAX_T) ) {
|
||
size_t myInd2 = arr.SArray< size_t >::FindIt( ind2 );
|
||
|
||
if ( !(myInd2 == SYS_MAX_T) ) {
|
||
const size_t *parr = arr.GetAddr();
|
||
*(size_t *)(parr + myInd1) = ind2;
|
||
*(size_t *)(parr + myInd2) = ind1;
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
|
||
#endif // __TEMPL_IM_ARRAY_H
|