Register.h

См. документацию.

/*
 * CntmLib - Подсчет ссылок, потоки, синхронизация, асинхронные процедуры, события
 * Copyright (c) 2005, Овсеевич Роман, CntmLib@mail.ru
 * _______________________________________________________________________________
 * Разрешено свободное использование, копирование, распространение, изменение
 * (изменение сведений об авторских правах запрещено). Запрещена продажа и 
 * включение всей библиотеки или ее частей в другие библиотеки. В сведениях об
 * авторских правах на программу (или сведениях о программе, об авторах, 
 * использованных средствах разработки и т.д.) должна быть указана информация
 * о библиотеке CntmLib, ее авторе и, возможно, сайте или email'е.
 * Библиотека поставляется "как есть", без каких-либо гарантий со стороны автора.
 */ 

#ifndef CNTM_REGISTER_H
#define CNTM_REGISTER_H
#include <boost/utility.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <Cntm/Utils/IntTypes.h>
#include <Cntm/Utils/LinkedListItemBase.h>
#include <Cntm/SystemUtils/ObjectAllocateBuffer.h>

namespace Cntm
{

        /**
         * Контейнерный класс перечня значений, хранящихся во внешних источниках. Данный перечень содержит только ссылки на зарегистрированные в нем значения.
         * 
         * Для хранения значения используется класс эл-та внешнего перечня - Cntm::Register::Item (см. этот класс). При записи в него значения одновременно указывается и перечень, в котором будет зарегистрировано значение. При присвоении эл-ту перечня нового значения ссылка на старое значение удаляется из перечня, в котором оно было зарегистрировано, и происходит регистрация нового значения. При уничтожении эл-та производится удаление ссылки на знвчение из перечня.
         * 
         * Просмотр значений перечня осуществляется через перечислители (см. Cntm::Register::Enumerator). Для получения перечислителя используется метод GetEnumerator().
         * 
         * Класс перечня является шаблонным классом с 2 параметрами. Параметр ValueT определяет тип значений, с которыми будет осуществляться работа (которые будут добавляться и перечисляться). Параметр StoreT определяет тип, который будет использоваться при хранении значений в контейнере. При добавлении значение типа ValueT будет преобразовано к значению StoreT, в котором будет храниться, при перечислении наоборот. Если второй параметр не задан, то StoreT = ValueT. Должна обеспечиваться взаимная конвертация типов StoreT и ValueT. Если это условие не будет выполнено, то при компиляции шаблона Register будет выдано сообщение об ошибке. Типы StoreT и ValueT должны иметь конструкторы и операторы копирования. Тип ValueT доступен через Cntm::Register::Type.
         * 
         * Класс перечня обеспечивает многопоточность (объекты перечислителей составляют исключение). Т.е. операции получения перечислителей, работа с эл-тами и разными перечислителями синхронизированы, операции одного перечислителя - нет.
         * @author Овсеевич Р.
         * \ingroup Containers
         */
        template < typename ValueT, typename StoreT = ValueT >
        class Register: boost::noncopyable
        {
        public:

                typedef ValueT Type;

                class Enumerator;
                class Item;
                
                /**
                 * Класс для перечисления значений, хранящихся в перечне. Используется для перебора всех значений перечня.
                 *
                 * После создания перечислитель не содержит текущего значения. Перечисление начинается с первого вызова Next(). Цикл перечисления выглядит так:
                 * while (enum1.Next()) Process1(enum1.Current()).
                 *
                 * Изменения в контейнере не влияют на текущее состояние перечислителя. Если в перечне будет удалено текущее значение перечислителя, то оно по прежнему будет присутствовать в перечислителе, а следующим будет значение, которое было после текущего. Если будет удалено значение после текущего, то оно уже не будет перечислено. Если будет удалено значение перед текущим, то при повторном перечислении оно уже не будет перечислено.
                 * 
                 * Перечислители бывают 2 видов: динамически включающие добавленные в перечень эл-ты и не включающие. В первом случае если после создания перечислителя в перечень будет добавлено новое значение, то оно будет перечислено. Во втором случае перечисляются только те эл-ты, которые находились в перечне на момент создания перечислителя (пример: если на момент создания перечислителя перечень был пуст, а после в него добавили новые эл-ты, то перечислитель не вернет ни одного значения).
                 *
                 * Для доступа к значениям одного перечня можно использовать сразу несколько перечислителей.
                 *
                 * Данный класс не является многопоточным. Чтобы получить доступ к эл-там перечня из разных потоков одновременно, следует создать перечислители для каждого потока.
                 * @author Овсеевич Р.
                 * \ingroup Containers
                 */
                class Enumerator: LinkedListItemBase
                {
                public:

                        typedef ValueT Type;

                        /**
                         * Конструктор копирования. Создает точную копию перечислителя Src (полностью копирует его состояние: текущее значение Current() (если идет перечисление), текущую позицию, флаг Enumerated()).
                         * @param Src - исходный перечислитель.
                         */
                        Enumerator(const Enumerator& Src);

                        /**
                         * Деструктор.
                         */
                        ~Enumerator();

                        /**
                         * Оператор присвоения нового значения. Производит сброс перечислителя и присвоение нового состояния (см. конструктор копирования).
                         * @param Src - исходный перечислитель.
                         */
                        Enumerator& operator= (const Enumerator& Src);

                        /**
                         * Перейти к следующему эл-ту. Вызывает функцию Next(). См. функцию Next().
                         */
                        Enumerator& operator++ ()
                        {
                                Next();
                                return *this;
                        }

                        /**
                         * Возвращает Enumerated(). См. флаг Enumerated().
                         */
                        operator bool () const { return Enumerated(); }

                        /**
                         * Возвращает !Enumerated(). См. флаг Enumerated().
                         */
                        bool operator! () const { return !Enumerated(); }

                        /**
                         * Получить ссылку на текущее значение. См. Current().
                         */
                        const Type& operator* () const { return Current(); }

                        /**
                         * Получить адрес текущего значения для доступа к его членам. См. Current().
                         */
                        const Type* operator-> () const { return &Current(); }

                        /**
                         * Возвращает true - если идет перечисление, т.е. перечисление было начато и не достигнут конец перечня, иначе false.
                         */
                        bool Enumerated() const { return enumerated; }

                        /**
                         * Возвращает true - если текущее значение перечислителя можно использовать (оно инициализировано), иначе false.
                         */
                        bool CurrentAvailable() const { return currentAvailable; }

                        /**
                         * Возвращает текущее значение перечислителя. Значение доступно только после первого вызова Next() и до тех пор, пока Next(), в том числе и первый, возвращает true. Значение Current() доступно, пока установлен флаг Enumerated().
                         */
                        const Type& Current() const
                        {
                                return *(reinterpret_cast<const Type*>(currentBuffer.Place()));
                        }

                        /**
                         * Сбросить текущее значение перечислителя. После сброса текущее значение становится недоступным до следующего вызова Next(). При сбросе вызывается деструктор текущего значения. Сброс происходит, если текущее значение было инициализировано (если шло перечисление).
                         */
                        void ResetCurrent();
                        
                        /**
                         * При первом вызове после создания или сброса начинает перечисление. Если в перечне есть хотя бы 1 эл-т, то Current() будет содержать первый эл-т, флаг Enumerated() и возвращаемое значение будут равны true. Если значений нет, то значение Current() неопределено, а флаг Enumerated() и возвращаемое значение будут равны false.
                         *
                         * При последующих вызовах будет производится считывание следующих значений. Если будет достигнут конец перечня, то значение Current() будет неопределено, а флаг Enumerated() и возвращаемое значение будут равны false.
                         * 
                         * При возникновении исключений в конструкторе и деструкторе типа Type при инициализации текущего значения перечисление прекращается.
                         */
                        bool Next();

                        /**
                         * Сбросить перечислитель в исходное состояние, аналогичное состоянию после создания перечислителя.
                         */
                        void Reset();

                protected:

                        friend class Register;

                        /**
                         * Конструктор. Используется перечнем для инициализации перечислителя.
                         */
                        Enumerator(Register* Reg, bool DynamicExpanded);

                        /**
                         * Указатель на перечень.
                         */
                        Register* Reg() const { return reg; }

                        /**
                         * Указатель на текущий эл-т.
                         */
                        LinkedListItemBase* CurrentItem() const { return currentItem; }

                        /**
                         * Указатель на последний перечисляемый эл-т или NULL если перечислитель динамически включающий.
                         */
                        LinkedListItemBase* LastItem() const { return lastItem; }

                        /**
                         * Установить указатель на текущий эл-т.
                         */
                        void SetCurrentItem(LinkedListItemBase* Item) { currentItem = Item; }

                        /**
                         * Установить указатель на последний эл-т.
                         */
                        void SetLastItem(LinkedListItemBase* Item) { lastItem = Item; }

                private:

                        /**
                         * Указатель на перечень.
                         */
                        Register* reg;

                        /**
                         * true - если идет перечисление, т.е. перечисление было начато и не достигнут конец перечня, иначе false.
                         */
                        bool enumerated;

                        /**
                         * true - если текущее значение перечислителя можно использовать (оно инициализировано), иначе false.
                         */
                        bool currentAvailable;

                        /**
                         * Буфер, в котором хранится текущее значение перечислителя. Значение доступно только после первого вызова Next() и до тех пор, пока Next(), в том числе и первый, возвращает true.
                         */
                        SpecUtils::ObjectAllocateBuffer<Type> currentBuffer;

                        /**
                         * Указатель на текущий эл-т.
                         */
                        LinkedListItemBase* currentItem;

                        /**
                         * Указатель на последний эл-т, который должен быть перечислен. Для динамически не включающих новые эл-ты перечислителей содержит указатель на последний эл-т (если указывает на голову, то ничего не будет перечислено), для включающих - NULL.
                         */
                        LinkedListItemBase* lastItem;
                };


                /**
                 * Класс эл-та перечня. Используется для управления хранением значения и наличием его в определенном перечне. При инициализации эл-та указывается значение, которое будет в нем хранится, и перечень, в котором это значение будет зарегистрировано. При установке нового значения старое уничтожается и изымается из перечня, в котором оно присутствовало, а эл-т сохраняет новое значение и регистрирует его в новом списке. При уничтожении эл-та происходит уничтожение значения и изъятие его из перечня (если значение было установлено).
                 * 
                 * Эл-т позволяет принудительно сбрасывать значение. При этом оно изымается из перечня и уничтожается.
                 * 
                 * Эл-т может быть пустым или содержать значение. Эл-т пуст после вызова конструктора по умолчанию, вызова Unassign() или присвоения пустого эл-та. Наличие значения можно определить методом Assigned().
                 * 
                 * Класс обеспечивает многопоточность.
                 * @author Овсеевич Р.
                 * \ingroup Containers
                 */
                class Item: LinkedListItemBase
                {
                public:

                        typedef ValueT Type;

                        /**
                         * Конструктор по умолчанию. Инициализирует перечень в NULL. Эл-т не содержит никакого значения, вызов метода Value() запрещен. 
                         */
                        Item(): reg(NULL) {}
                        
                        /**
                         * Конструктор инициализации. Сохраняет значение Value (преобразуя его к типу StoreT) и регистрирует его в перечне Reg. Если Reg равен NULL, то ни каких действий не выполняется.
                         * @param Reg - перечень, в котором будет зарегистрировано значение.
                         * @param Value - значение, которое будет зарегистрировано в перечне.
                         */
                        Item(Register* Reg, const Type& Value): reg(Reg)
                        {
                                boost::recursive_mutex::scoped_lock lock(Register::mutex);
                                if (reg)
                                {
                                        new(valueBuffer.Place()) StoreT(Value);
                                        reg->AddItem(this);
                                }
                        }
                        
                        /**
                         * Конструктор инициализации. Сохраняет значение Value (преобразуя его к типу StoreT) и регистрирует его в перечне Reg. Если Reg равен NULL, то ни каких действий не выполняется.
                         * @param Reg - перечень, в котором будет зарегистрировано значение.
                         * @param Value - значение, которое будет зарегистрировано в перечне.
                         */
                        Item(Register& Reg, const Type& Value): reg(&Reg)
                        {
                                boost::recursive_mutex::scoped_lock lock(Register::mutex);
                                if (reg)
                                {
                                        new(valueBuffer.Place()) StoreT(Value);
                                        reg->AddItem(this);
                                }
                        }
                        
                        /**
                         * Конструктор копирования. Копирует значение из исходного эл-та и регистрирует его в перечне, если исходный эл-т не пуст.
                         * @param Src - исходный эл-т.
                         */
                        Item(const Item& Src): reg(Src.Reg())
                        {
                                boost::recursive_mutex::scoped_lock lock(Register::mutex);
                                if (reg)
                                {
                                        new(valueBuffer.Place()) StoreT(Src.StoreValue());
                                        reg->AddItem(this);
                                }
                        }
                        
                        /**
                         * Деструктор. Если эл-т не пуст, то значение изымается из перечня и удаляется.
                         */
                        ~Item() 
                        {
                                Unassign(); 
                        }
                        
                        /**
                         * Оператор копирования. Если эл-т не пуст, то значение изымается из перечня и удаляется. После этого копирует значение из исходного эл-та и регистрирует его в перечне, если исходный эл-т не пуст.
                         * @param Src - исходный эл-т.
                         */
                        Item& operator= (const Item& Src);

                        /**
                         * Если эл-т содержит значение, то возвращает true иначе - false.
                         */
                        bool Assigned() const { return reg; }
                                
                        /**
                         * Возвращает значение, хранящееся в эл-те. Метод следует вызывать только когда в эл-те имеется значение (для определения наличия значение можно использовать Assigned()).            
                         */
                        Type Value() const
                        {
                                boost::recursive_mutex::scoped_lock lock(Register::mutex);
                                return StoreValue();
                        }
                        
                        /**
                         * Возвращает перечень, в котором зарегистрировано значение. Если эл-т не содержит значения, то возвращается NULL.
                         */
                        Register* Reg() const { return reg; }
                        
                        /**
                         * Установить новое значение. Если эл-т не пуст, то значение изымается из перечня и удаляется. После этого копирует значение из Value и регистрирует его в перечне Reg, если Reg не равен NULL.
                         * @param Reg - перечень, в котором будет зарегистрировано значение.
                         * @param Value - значение, которое будет зарегистрировано в перечне.
                         */
                        void Set(Register* Reg, const Type& Value);
                                                
                        /**
                         * Установить новое значение. Если эл-т не пуст, то значение изымается из перечня и удаляется. После этого копирует значение из Value и регистрирует его в перечне Reg, если Reg не равен NULL.
                         * @param Reg - перечень, в котором будет зарегистрировано значение.
                         * @param Value - значение, которое будет зарегистрировано в перечне.
                         */
                        void Set(Register& Reg, const Type& Value) { Set(&Reg, Value); }
                                                
                        /**
                         * Сброс значения. Если эл-т не пуст, то значение изымается из перечня и удаляется.
                         */
                        void Unassign();
                        
                private:
                        
                        friend class Register;
                        
                        /**
                         * Значение эл-та.
                         */
                         const StoreT& StoreValue() const
                         {
                                return *(reinterpret_cast<const StoreT*>(valueBuffer.Place()));
                         }
                        
                private:
                
                        /**
                         * Указатель на перечень.
                         */
                        Register* reg;

                        /**
                         * Буфер, в котором хранится значение эл-та.
                         */
                        SpecUtils::ObjectAllocateBuffer<StoreT> valueBuffer;

                        /**
                         * Значение эл-та.
                         */
                         StoreT& StoreValue()
                         {
                                return *(reinterpret_cast<StoreT*>(valueBuffer.Place()));
                         }
                };


                /**
                 * Возвращает true, если перечень пуст, в противном случае - false.
                 */
                bool IsEmpty() const { return itemsHead.IsSingle(); }

                /**
                 * Получить объект перечислителя для доступа к эл-там. 
                 * @param DynamicExpanded - true (значение по умолчанию) - перечислитель будет перечислять эл-ты, добавленные в перечень после создания перечислителя, false - перечислитель будет переслять только те эл-ты, которые были в перечне на момент создания перечислителя (удаленные эл-ты перечислитель не перечисляет в любом случае).
                 */
                Enumerator GetEnumerator(bool DynamicExpanded = true) const
                { 
                        return Enumerator(const_cast<Register*>(this), DynamicExpanded);
                }               
                
        private:

                friend class Enumerator;
                friend class Item;              

                /**
                 * Глобальная критическая секция для операций с перечнями, перечислителями и эл-тами данного типа. 
                 */
                static boost::recursive_mutex mutex;
                
                /**
                 * Возвращает головной (фиктивный) эл-т цепочки эл-тов. Вызывается перечислителем. 
                 */
                LinkedListItemBase* ItemsHead() { return &itemsHead; }

                /**
                 * Возвращает последний эл-т цепочки (перед головным эл-том) или головной (если эл-тов нет). Вызывается перечислителем. 
                 */
                LinkedListItemBase* LastItem() { return itemsHead.PrevItem(); }

                /**
                 * Зарегистрировать новый эл-т в цепочке эл-тов. Операция не синхронизирована. Вызывается эл-том. 
                 */
                void AddItem(Item* It)
                {
                        It->InsertBefore(ItemsHead()); // Добавляем в конец (перед головой кольцевого списка).
                }
                
                /**
                 * Удалить эл-т из цепочки эл-тов перечня. Проверить все перечислители. Операция не синхронизирована. Вызывается эл-том. 
                 */
                void DeleteItem(Item* It);
                
                /**
                 * Добавить перечислитьль в цепочку перечислителей для данного перечня. Операция не синхронизирована. Вызывается перечислителем. 
                 */
                void AddEnumerator(Enumerator* Enum)
                {
                        Enum->InsertAfter(&enumsHead); // Вставляем новый перечислитель в начало списка.
                }

                /**
                 * Удалить перечислитель из цепочки перечислителей для данного перечня. Операция не синхронизирована. Вызывается перечислителем. 
                 */
                void DeleteEnumerator(Enumerator* Enum)
                {
                        Enum->Remove(); // Удаляем перечислитель из списка перечислителей.
                }

                /**
                 * Перейти к следующему эл-ту. Операция не синхронизирована. Вызывается перечислителем. 
                 * 
                 * CurItem - указатель на переменную, содержащую текущий эл-т. CurBuffer - буфер, куда будет скопировано значение из эл-та.
                 * 
                 * После выполнения: если не конец перечня, то CurItem содержит указатель на следующий эл-т, CurBuffer - значение из эл-та, возвращаемое значение - true; если достигнут конец, то CurItem содержит NULL, CurBuffer не содержит никакого значения, возвращаемое значение - false.
                 */
                bool Next(LinkedListItemBase** CurItem, void* CurBuffer);
                        
        private:
        
                /**
                 * Голова (фиктивный эл-т) двунаправленного связанного списка перечислителей данного перечня. 
                 */
                LinkedListItemBase enumsHead;
                
                /**
                 * Голова (фиктивный эл-т) двунаправленного связанного списка эл-тов данного перечня. 
                 */
                LinkedListItemBase itemsHead;
        };

}


// Enumerator /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

template < typename ValueT, typename StoreT >
Cntm::Register < ValueT, StoreT > ::Enumerator::Enumerator(const Enumerator& Src) 
{
        boost::recursive_mutex::scoped_lock lock(Register::mutex);
        reg = Src.Reg();
        reg->AddEnumerator(this); // Подключаемся к перечню.
        enumerated = Src.Enumerated();
        currentAvailable = Src.CurrentAvailable();
        currentItem = Src.CurrentItem();
        lastItem = Src.LastItem();
        if (currentAvailable)
                new(currentBuffer.Place()) Type(Src.Current()); // Если текущее значение доступно, то копируем текущее значение перечислителя.
}

template < typename ValueT, typename StoreT >
Cntm::Register < ValueT, StoreT > ::Enumerator::~Enumerator()
{
        try { Reset(); } catch (...) {}
        boost::recursive_mutex::scoped_lock lock(Register::mutex);
        try { reg->DeleteEnumerator(this); } catch (...) {}
}                       
                        
template < typename ValueT, typename StoreT >
typename Cntm::Register < ValueT, StoreT > ::Enumerator&
        Cntm::Register < ValueT, StoreT > ::Enumerator::operator = (const Enumerator& Src)
{
        if (this == &Src) return *this;
        
        Reset();

        boost::recursive_mutex::scoped_lock lock(Register::mutex);

        // Если исходный перечислитель связан с другим перечнем, то отключаемся от
        // старого перечня и подключаемся к новому.
        if (reg != Src.Reg())
        {
                reg->DeleteEnumerator(this);
                reg = Src.Reg();
                reg->AddEnumerator(this);
        }
        
        // Копируем новые значения
        enumerated = Src.Enumerated();
        currentAvailable = Src.CurrentAvailable();
        currentItem = Src.CurrentItem();
        lastItem = Src.LastItem();
        if (currentAvailable)
                new(currentBuffer.Place()) Type(Src.Current()); // Если текущее значение доступно, то копируем текущее значение перечислителя.
        
        return *this;
}

template < typename ValueT, typename StoreT >
void Cntm::Register < ValueT, StoreT > ::Enumerator::ResetCurrent()
{
        if (!currentAvailable) return;
        currentAvailable = false;
        reinterpret_cast<Type*>(currentBuffer.Place())->~Type();
}       

template < typename ValueT, typename StoreT >
bool Cntm::Register < ValueT, StoreT > ::Enumerator::Next()
{
        try
        {
                // Подготовка
                if (enumerated)
                {
                        ResetCurrent();
                }
                else    
                {
                        enumerated = true;
                        currentItem = reg->ItemsHead();
                }
                
                // Переход к следующему эл-ту
                boost::recursive_mutex::scoped_lock lock(Register::mutex);
                if (currentItem != lastItem)
                {
                        enumerated = currentAvailable = reg->Next(&currentItem, currentBuffer.Place());
                }
                else
                {
                        enumerated = false;
                        currentItem = NULL;
                }
        }
        catch (...)
        {
                enumerated = false;
                currentItem = NULL;
                throw;
        }
        
        return enumerated;
}

template < typename ValueT, typename StoreT >
void Cntm::Register < ValueT, StoreT > ::Enumerator::Reset()
{
        if (enumerated)
        {
                enumerated = false;
                currentItem = NULL;
                ResetCurrent();
        }
}

template < typename ValueT, typename StoreT >
Cntm::Register < ValueT, StoreT > ::Enumerator::Enumerator(Register* Reg, bool DynamicExpanded):
        reg(Reg), enumerated(false), currentAvailable(false), currentItem(NULL)
{
        boost::recursive_mutex::scoped_lock lock(Register::mutex);
        reg->AddEnumerator(this);
        lastItem = DynamicExpanded? NULL : reg->LastItem();
}


// Item ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

template < typename ValueT, typename StoreT >
typename Cntm::Register < ValueT, StoreT > ::Item&
        Cntm::Register < ValueT, StoreT > ::Item::operator= (const Item& Src)
{
        boost::recursive_mutex::scoped_lock lock(Register::mutex);
        Unassign();
        reg = Src.Reg();
        if (reg)
        {
                try
                {
                        new(valueBuffer.Place()) StoreT(Src.StoreValue());
                        try
                        {
                                reg->AddItem(this);
                        }
                        catch (...)
                        {
                                StoreValue().~StoreT();
                                throw;
                        }
                }
                catch (...)
                {
                        reg = NULL;
                        throw;
                }
        }
        return *this;
}

template < typename ValueT, typename StoreT >
void Cntm::Register < ValueT, StoreT > ::Item::Set(Register* Reg, const Type& Value)
{
        boost::recursive_mutex::scoped_lock lock(Register::mutex);
        Unassign();
        reg = Reg;
        if (reg)
        {
                try
                {
                        new(valueBuffer.Place()) StoreT(Value);
                        try
                        {
                                reg->AddItem(this);
                        }
                        catch (...)
                        {
                                StoreValue().~StoreT();
                                throw;
                        }
                }
                catch (...)
                {
                        reg = NULL;
                        throw;
                }
        }
}
                        
template < typename ValueT, typename StoreT >
void Cntm::Register < ValueT, StoreT > ::Item::Unassign()
{
        boost::recursive_mutex::scoped_lock lock(Register::mutex);
        if (reg)
        {
                try { StoreValue().~StoreT(); } catch (...) {}
                try { reg->DeleteItem(this); } catch (...) {}
                reg = NULL;
        }
}


// Register ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

template < typename ValueT, typename StoreT >
boost::recursive_mutex Cntm::Register < ValueT, StoreT > ::mutex;

template < typename ValueT, typename StoreT >
void Cntm::Register < ValueT, StoreT > ::DeleteItem(Item* It)
{
        // В цикле проходим по всем перечислителям. Если перечислитель указывает
        // на удаляемый эл-т, то делаем предыдущий эл-т текущим, чтобы при вызове 
        // операции Next перечислитель получил эл-т следующий за удаленным.
        for (LinkedListItemBase* e = enumsHead.NextItem(); e != &enumsHead; e = e->NextItem())
        {
                Enumerator* en = static_cast<Enumerator*>(e);
                if (en->CurrentItem() == It) en->SetCurrentItem(It->PrevItem());
                if (en->LastItem() == It) en->SetLastItem(It->PrevItem());
        }
        
        // Удаляем из списка.
        It->Remove();
}

template < typename ValueT, typename StoreT >
bool Cntm::Register < ValueT, StoreT > ::Next(LinkedListItemBase** CurItem, void* CurBuffer)
{
        bool res = (*CurItem = (*CurItem)->NextItem()) != ItemsHead();
        if (res)
                new(CurBuffer) Type(static_cast<Item*>(*CurItem)->StoreValue());
        else
                *CurItem = NULL;
        return res;
}

#endif //CNTM_REGISTER_H

---