HandledList.h

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

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

#ifndef CNTM_HANDLEDLIST_H
#define CNTM_HANDLEDLIST_H
#include <list>
#include <boost/thread/recursive_mutex.hpp>
#include <Cntm/SystemUtils/AtomicUtils.h>
#include <Cntm/SystemUtils/ObjectAllocateBuffer.h>
#include <Cntm/SystemUtils/SyncUtils.h>
#include <Cntm/Exceptions.h>
#include <Cntm/Utils.h>

namespace Cntm
{

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

        private:
                
                friend class Enumerator;
                friend class Handle;
                friend class AddResult;
                
                typedef typename std::list < StoreT > ::iterator ItemId;
                
                /**
                 * Базовый класс для перечислителя эл-тов перечня. Содержит ссылки на предыдущий и следующий перечислители в цепочке перечислителей для определенного перечня.
                 * @author Овсеевич Р.
                 */
                class EnumeratorBase
                {
                protected:

                        friend class HandledList;
                        
                        /**
                         * Конструктор. Зацикливает ссылки на себя.
                         */
                        EnumeratorBase(): prev(this), next(this) {}
                        
                        /**
                         * Предыдущий перечислитель в цепочке перечислителей.
                         */
                        EnumeratorBase* PrevEnum() const { return prev; }
                        
                        /**
                         * Следующий перечислитель в цепочке перечислителей.
                         */
                        EnumeratorBase* NextEnum() const { return next; }
                        
                        /**
                         * Вставить данный перечислитель в 2-направленный список перед Enum.
                         */
                        void InsertAfter(EnumeratorBase* Enum)
                        {
                                Enum->next->prev = this;
                                next = Enum->next;
                                Enum->next = this;
                                prev = Enum;
                        }
                        
                        /**
                         * Изъять данный перечислитель из 2-направленного списка.
                         */
                        void Remove()
                        {
                                prev->next = next;
                                next->prev = prev;
                                prev = next = this;
                        }
                        
                private:
                
                        /**
                         * Предыдущий перечислитель в цепочке перечислителей.
                         */
                        EnumeratorBase* prev;
                        
                        /**
                         * Следующий перечислитель в цепочке перечислителей.
                         */
                        EnumeratorBase* next;                   
                };

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

                        /**
                         * Конструктор копирования. Создает точную копию перечислителя Src (полностью копирует его состояние: текущее значение Current() (если идет перечисление), текущую позицию, флаг Enumerated()).
                         */
                        Enumerator(const Enumerator& Src);
                        
                        /**
                         * Оператор присвоения нового значения. Производит сброс перечислителя и присвоение нового состояния (см. конструктор копирования).
                         */
                        Enumerator& operator = (const Enumerator& Src);
                        
                        /**
                         * Перейти к следующему эл-ту. Вызывает функцию Next(). См. функцию Next().
                         */
                        Enumerator& operator ++ () { Next(); return *this; }
                        
                        /**
                         * Деструктор.
                         */
                        ~Enumerator();
                        
                        /**
                         * Возвращает 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; }
                        
                        /**
                         * Возвращает текущее значение перечислителя. Значение доступно только после первого вызова Next() и до тех пор, пока Next(), в том числе и первый, возвращает true. Значение Current() доступно, пока установлен флаг Enumerated().
                         */
                        const Type& Current() const 
                        { 
                                return *(reinterpret_cast<const Type*>(currentBuffer.Place())); 
                        }
                        
                        /**
                         * При первом вызове после создания или сброса начинает перечисление. Если в перечне есть хотя бы 1 эл-т, то Current() будет содержать первый эл-т, флаг Enumerated() и возвращаемое значение будут равны true. Если значений нет, то значение Current() неопределено, а флаг Enumerated() и возвращаемое значение будут равны false.
                         * 
                         * При последующих вызовах будет производится считывание следующих значений. Если будет достигнут конец перечня, то значение Current() будет неопределено, а флаг Enumerated() и возвращаемое значение будут равны false.
                         */
                        bool Next();
                        
                        /**
                         * Сбросить перечислитель в исходное состояние, аналогичное состоянию после создания перечислителя.
                         */
                        void Reset();
                        
                protected:
                
                        friend class HandledList;
                        
                        /**
                         * Конструктор. Используется перечнем для инициализации перечислителя.
                         */
                        Enumerator(HandledList* List);
                        
                        /**
                         * Указатель на перечислитель.
                         */
                        HandledList* List() const { return list; }
                        
                        /**
                         * Идентификатор текущего значения в списке эл-тов.
                         */
                        const ItemId& CurrentId() const { return currentId; }
                        
                        /**
                         * Идентификатор текущего значения в списке эл-тов.
                         */
                        ItemId& CurrentId() { return currentId; }
                        
                private:
                
                        /**
                         * Указатель на перечислитель.
                         */
                        HandledList* list;
                        
                        /**
                         * true - если идет перечисление, т.е. перечисление было начато и не достигнут конец перечня, иначе false.
                         */
                        bool enumerated;
                        
                        /**
                         * Буфер, в котором хранится текущее значение перечислителя. Значение доступно только после первого вызова Next() и до тех пор, пока Next(), в том числе и первый, возвращает true.
                         */
                        SpecUtils::ObjectAllocateBuffer<Type> currentBuffer;
                        
                        /**
                         * Идентификатор текущего значения в списке эл-тов.
                         */
                        ItemId currentId;               
                };


                /**
                 * Класс хэндла, отвечающий за присутствие связанного с ним значения в перечне. Когда в перечень добавляется новое значение с ним связывается хэндл. Когда такая связь уничтожается, значение, связанное с хэндлом удаляется из перечня. Это происходит когда хэндл уничтожается, когда ему присваивается новое значение или при вызове метода Release().
                 *
                 * При копировании хэндлов происходит дублирование значений в перечне, т.е. и принимающий и исходный хэндлы указывают на разные эл-ты в перечне, имеющие одинаковое значение.
                 *
                 * Класс обеспечивает многопоточность.
                 * @author Овсеевич Р.
                 */
                class Handle
                {
                public:
                
                        /**
                         * Конструктор по умолчанию. Создает пустой хэндл, который не связан ни с каким значением.
                         */
                        Handle(): list(NULL) {}
                        
                        /**
                         * Конструктор инициализации результатом операции Add. Хэнд связывается с добавленным значением.
                         */
                        Handle(const AddResult& Src): list(Src.List()), id(Src.Id()) {}
                        
                        /**
                         * Конструктор дублирования значения из другого хэндла. Перечень после дублирования будет содержать два одинаковых значения. Дублирование пустого значения приведет к тому, что хэнд не будет связан ни с каким значением.
                         */
                        Handle(const Handle& Src);

                        /**
                         * Деструктор. Если хэндл связан с каким либо значением, то это значение удаляется из перечня.
                         */
                        ~Handle() throw() { try { if (list) list->DeleteItem(id); } catch (...) { } }
                        
                        /**
                         * Оператор присвоения результата операции Add. Если хэндл был связан с каким либо значением, то оно удаляется из перечня, и хэнд связывается с новым значением.
                         */
                        Handle& operator = (const AddResult& Src);
                        
                        /**
                         * Оператор присвоения дубликата значения, связанного с хэндлом Src. Если хэндл был связан с каким либо значением, то оно удаляется из перечня, и хэнд связывается с дублированным значением хэндла Src. Перечень после дублирования будет содержать два одинаковых значения. Присвоение пустого значения приведет к тому, что хэнд не будет связан ни с каким значением.
                         */
                        Handle& operator = (const Handle& Src);
                        
                        /**
                         * Проверка, связан ли хэнд с каким либо значением. Возвращает true, если не связан и false - если связан.
                         */
                        bool IsReleased() const { return list; }
                        
                        /**
                         * Разорвать связь между хэндлом и значением в перечне, при этом значение из перечня удаляется. Если хэндл не связан со значением, то ни каких действий не выполняется.
                         */
                        void Release();

                private:

                        /**
                         * Перечень, в котором находится добавленный эл-т, или NULL, если AddResult не содержит значения.
                         */
                        HandledList* list;

                        /**
                         * Идентификатор добавленного значения в перечне.
                         */
                        ItemId id;

                        /**
                         * Войти в критическую секцию хэндла и вернуть текущий указатель на перечень. При этом указатель на перечень будет содержать специальное блокирующее значение.
                         */
                        HandledList* Enter()
                        {
                                return SpecUtils::FastWaitPtrNoEqualAndSet(&list, reinterpret_cast<HandledList*>(this));
                        }
                        
                        /**
                         * Выйти из критической секции хэндла и установить значение указателя на перечень.
                         */
                        void Leave(HandledList* UnlockValue)
                        {
                                list = UnlockValue;
                        }
                        
                        /**
                         * Атомарное копирование обоих полей хэндла в приемники.
                         */
                        void AtomicCopyTo(HandledList** DestList, StoreT* DestValue) const;
                        
                        /**
                         * Дублирование значения хэндла Src и запись новых значений в DestList и DestId. Если хэндл Src пуст, то *DestList = NULL, а *DestId не определен.
                         */
                        void Duplicate(const Handle& Src, HandledList** DestList, ItemId* DestId) const;

                        /**
                         * Атомарная установка новых значений List и Id, удаление значения, с которым был связан хэндл, из перечня (если связь была).
                         */
                        void SetNewValues(HandledList* List, const ItemId& Id);
                };


                /**
                 * Класс, инкапсулирующий результат добавления нового эл-та в перечень. Непосредственное использование этого класса не предусмотрено, он используется в качестве посредника между вызовом Add() и присвоением значения хэндлу HandledList::Handle.
                 *
                 * Особенность класса в том, что при копировании из него изымается значение, т.е., если его скопировать в Handle или другой AddResult, то он больше не содержит значения. Это ускоряет процедуру присвоения Handle.
                 *
                 * Если результат добавления не присвоен хэндлу, то оно автоматически удаляется из перечня.
                 *
                 * Класс обеспечивает многопоточность.
                 * @author Овсеевич Р.
                 */
                class AddResult
                {
                public:
                
                        /**
                         * Конструктор копирования. Уничтожает исходное значение в источнике.
                         *
                         * Исключение BadArgException, если Src не содержит значение (т.е. уже было кому-то присвоено).
                         */
                        AddResult(const AddResult& Src);

                        /**
                         * Деструктор. Если имеется значение, то оно удаляется из перечня.
                         */
                        ~AddResult() throw() { try { if (list) list->DeleteItem(id); } catch (...) { } }

                protected:
                
                        friend class HandledList;
                        friend class Handle;
                        
                        /**
                         * Конструктор инициализации. Используется операцией Add для создания результата.
                         */
                        AddResult(HandledList* List, const ItemId& Id):
                                list(List), id(Id) {}

                        /**
                         * Взять текущее значение указателя на перечень. При этом значение переходит в другое место, а сюда записывается NULL (в нарушение декларации const !!!).
                         */
                        HandledList* List() const
                        { 
                                return SpecUtils::AtomicSwapPtr(const_cast<HandledList**>(&list), (HandledList*)NULL);
                        }
                        
                        /**
                         * Считать идентификатор эл-та в перечне.
                         */
                        const ItemId& Id() const { return id; }
                        
                private:
                
                        /**
                         * Перечень, в котором находится добавленный эл-т, или NULL, если AddResult не содержит значения.
                         */
                        HandledList* list;

                        /**
                         * Идентификатор добавленного значения в перечне.
                         */
                        ItemId id;
                };


                /**
                 * Кол-во эл-тов в перечне. При использовании следует учитывать, что класс многопоточный, поэтому между вызывом Count() и следующей операцией кол-во эл-тов может измениться.
                 */
                uint Count() const
                {
                        boost::recursive_mutex::scoped_lock lock(mutex);
                        return items.count();
                }

                /**
                 * Проверяет, что кол-во эл-тов в перечне равно 0. При использовании следует учитывать, что класс многопоточный, поэтому между вызывом Count() и следующей операцией кол-во эл-тов может измениться.
                 */
                bool IsEmpty() const { return Count() == 0; }

                /**
                 * Добавить значение к перечню. Результат операции д.б. присвоен какому-либо хэндлу. Если результат не будет присвоен хэндлу, то добавленное значение будет удалено из перечня. 
                 */
                AddResult Add(const Type& Value) 
                { 
                        return AddResult(this, AddStoreValue(Value));
                }

                /**
                 * Получить объект перечислителя для доступа к эл-там. 
                 */
                Enumerator GetEnumerator() const 
                { 
                        return Enumerator(const_cast<HandledList*>(this));
                }
                
        private:

                /**
                 * Сохранить значение типа StoreT в списке. Операция синхронизирована. Вызывается хэндлом при дублировании. 
                 */
                ItemId AddStoreValue(const StoreT& Value);
                
                /**
                 * Удалить значение по его итератору из списка. Операция синхронизирована.  Вызывается хэндлом и результатом добавления. 
                 */
                void DeleteItem(const ItemId& Id);
                
                /**
                 * Добавить перечислитьль в цепочку перечислителей для данного перечня. Операция синхронизирована. Вызывается перечислителем. 
                 */
                void AddEnumerator(Enumerator* Enum);

                /**
                 * Удалить перечислитель из цепочки перечислителей для данного перечня. Операция синхронизирована. Вызывается перечислителем. 
                 */
                void DeleteEnumerator(Enumerator* Enum);
                
                /**
                 * Сбросить итератор эл-та в фиктивное значение. Операция синхронизирована. Вызывается перечислителем. 
                 */
                void ResetItemId(ItemId* DestId);
                
                /**
                 * Скопировать итератор из источника в приемник. Операция синхронизирована. Вызывается перечислителем. 
                 */
                void CopyItemId(const Enumerator& Src, ItemId* DestId);
                
                /**
                 * Получить первый эл-т при перечислении. Операция синхронизирована. Вызывается перечислителем. 
                 */
                bool FirstItem(ItemId* DestId, void* DestCurrentBuf);
                
                /**
                 * Получить следующий эл-т при перечислении. Операция синхронизирована. Вызывается перечислителем. 
                 */
                bool NextItem(ItemId* VarId, void* DestCurrentBuf);             
                
        private:
        
                /**
                 * Список, хранящий значения. 
                 */
                std::list<StoreT> items;
                
                /**
                 * Мьютекс, защищающий операции над перечнем. 
                 */
                boost::recursive_mutex mutex;
                
                /**
                 * Голова (фиктивный эл-т) двунаправленного связанного списка перечислителей данного перечня. 
                 */
                EnumeratorBase enumsHead;
                
                /**
                 * Вспомогательный метод при перечислении. 
                 */
                bool ReturnItem(const ItemId& Id, void* DestCurrentBuf);
        };

}


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

template < typename ValueT, typename StoreT >
Cntm::HandledList < ValueT, StoreT > ::Enumerator::Enumerator(const Enumerator& Src):
        EnumeratorBase(), list(Src.List()), enumerated(Src.Enumerated())
{
        if (enumerated)
                new(currentBuffer.Place()) Type(Src.Current()); // Если шло перечисление, то копируем текущее значение перечислителя.
        list->ResetItemId(&currentId);          // Сбрасываем значение ссылки на эл-т.
        list->AddEnumerator(this);                      // Подключаемся к перечню.
        list->CopyItemId(Src, &currentId);      // Устанавливаем настоящее значение ссылки на эл-т (синхронно с прочими операциями перечня).
}

template < typename ValueT, typename StoreT >
Cntm::HandledList < ValueT, StoreT > ::Enumerator::~Enumerator()
{
        try
        {
                try { list->DeleteEnumerator(this); } catch (...) {}
                Reset();
        }
        catch (...)
        {
        }
}                       
                        
template < typename ValueT, typename StoreT >
typename Cntm::HandledList < ValueT, StoreT > ::Enumerator&
        Cntm::HandledList < ValueT, StoreT > ::Enumerator::operator = (const Enumerator& Src)
{
        if (this == &Src) return *this;
        
        // Если исходный перечислитель связан с другим перечнем, то отключаемся от
        // старого перечня и подключаемся к новому.
        if (list != Src.List())
        {
                list->DeleteEnumerator(this);
                Reset();
                list = Src.List();
                list->ResetItemId(&currentId);
                list->AddEnumerator(this);
        }
        else
        {
                Reset();
        }
        
        // Копируем новые значения
        enumerated = Src.Enumerated();
        if (enumerated) 
                new(currentBuffer.Place()) Type(Src.Current()); // Если шло перечисление, то копируем текущее значение перечислителя.
        list->CopyItemId(Src, &currentId);
        
        return *this;
}

template < typename ValueT, typename StoreT >
bool Cntm::HandledList < ValueT, StoreT > ::Enumerator::Next()
{
        if (enumerated)
        {
                try
                {
                        reinterpret_cast<Type*>(currentBuffer.Place())->~Type();
                        enumerated = list->NextItem(&currentId, currentBuffer.Place()); // Получаем следующее значение.
                }
                catch (...)
                {
                        enumerated = false;
                        throw;
                }
        }
        else
        {
                enumerated = list->FirstItem(&currentId, currentBuffer.Place()); // Получаем первый эл-т.
        }
        
        return enumerated;
}

template < typename ValueT, typename StoreT >
void Cntm::HandledList < ValueT, StoreT > ::Enumerator::Reset()
{
        if (enumerated)
        {
                enumerated = false;
                reinterpret_cast<Type*>(currentBuffer.Place())->~Type();
                list->ResetItemId(&currentId);
        }
}

template < typename ValueT, typename StoreT >
Cntm::HandledList < ValueT, StoreT > ::Enumerator::Enumerator(HandledList* List):
        list(List), enumerated(false)
{
        list->ResetItemId(&currentId);
        list->AddEnumerator(this);
}


// Handle /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

template < typename ValueT, typename StoreT >
Cntm::HandledList < ValueT, StoreT > ::Handle::Handle(const Handle& Src)
{
        if (this != &Src) Duplicate(Src, &list, &id);
}

template < typename ValueT, typename StoreT >
typename Cntm::HandledList < ValueT, StoreT > ::Handle& 
        Cntm::HandledList < ValueT, StoreT > ::Handle::operator = (const AddResult& Src)
{
        SetNewValues(Src.List(), Src.Id());
        
        return *this;
}

template < typename ValueT, typename StoreT >
typename Cntm::HandledList < ValueT, StoreT > ::Handle&
        Cntm::HandledList < ValueT, StoreT > ::Handle::operator = (const Handle& Src)
{
        if (this != &Src)
        {
                // Считывание новых парметров.
                HandledList*    newList;
                ItemId          newId;
                Duplicate(Src, &newList, &newId);

                // Установка новых параметров, удаление связанного эл-та.
                SetNewValues(newList, newId); 
        }
        
        return *this;
}

template < typename ValueT, typename StoreT >
void Cntm::HandledList < ValueT, StoreT > ::Handle::Release()
{
        // Обнуление указателя на перечень, удаление связанного эл-та.
        SetNewValues(NULL, id);
}

template < typename ValueT, typename StoreT >
inline void Cntm::HandledList < ValueT, StoreT > ::Handle::AtomicCopyTo
        (HandledList** DestList, StoreT * DestValue) const
{
        *DestList = const_cast<Handle*>(this)->Enter();
        try
        {
                if (*DestList) *DestValue = *id;
        }
        catch (...)
        {
                const_cast<Handle*>(this)->Leave(*DestList);
                throw;
        }

        const_cast<Handle*>(this)->Leave(*DestList);
}

template < typename ValueT, typename StoreT >
inline void Cntm::HandledList < ValueT, StoreT > ::Handle::Duplicate
        (const Handle& Src, HandledList** DestList, ItemId* DestId) const
{
        // Считывание парметров
        StoreT val;
        Src.AtomicCopyTo(DestList, &val);
        
        // Добавление нового значения
        if (*DestList) *DestId = (*DestList)->AddStoreValue(val); 
}
                        
template < typename ValueT, typename StoreT >
inline void Cntm::HandledList < ValueT, StoreT > ::Handle::SetNewValues
        (HandledList* List, const ItemId& Id)
{
        // Производим атомарный обмен значений. 
        ItemId oldId;
        HandledList* oldList = Enter();
        try
        {
                oldId = id;
                id = Id;
        }
        catch(...)
        {
                Leave(NULL); 
                throw;
        }

        Leave(List);
                
        // Удаляем старое значение из перечня
        if (oldList) oldList->DeleteItem(oldId);
}


// AddResult //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

template < typename ValueT, typename StoreT >
Cntm::HandledList < ValueT, StoreT > ::AddResult::AddResult(const AddResult& Src):
        list(Src.List()), id(Src.Id())
{
        if (list == NULL) 
                throw BadArgException("Cntm::HandledList::AddResult::AddResult", "Пустой источник");
}


// HandledList ////////////////////////////////////////////////////////////////////////////////////////////////////////////////

template < typename ValueT, typename StoreT >
inline typename Cntm::HandledList < ValueT, StoreT > ::ItemId
        Cntm::HandledList < ValueT, StoreT > ::AddStoreValue(const StoreT& Value)
{
        boost::recursive_mutex::scoped_lock lock(mutex);        // Блокируем перечень.
        return items.insert(items.end(), Value);                        // Добавляем в конец.
}

template < typename ValueT, typename StoreT >
inline void Cntm::HandledList < ValueT, StoreT > ::DeleteItem(const ItemId& Id)
{
        // Блокируем перечень.
        boost::recursive_mutex::scoped_lock lock(mutex);

        // В цикле проходим по всем перечислителям. Если перечислитель указывает
        // на удаляемый эл-т, то уменьшаем итератор на 1, чтобы при вызове операции
        // Next перечислитель получил эл-т следующий за удаленным.
        for (EnumeratorBase* e = enumsHead.NextEnum(); e != &enumsHead; e = e->NextEnum())
                if (static_cast<Enumerator*>(e)->CurrentId() == Id)
                        --(static_cast<Enumerator*>(e)->CurrentId());
        
        // Удаляем из списка.
        items.erase(Id);
}

template < typename ValueT, typename StoreT >
inline void Cntm::HandledList < ValueT, StoreT > ::AddEnumerator(Enumerator* Enum)
{
        boost::recursive_mutex::scoped_lock lock(mutex); // Блокируем перечень.
        Enum->InsertAfter(&enumsHead); // Вставляем новый перечислитель в начало списка.
}

template < typename ValueT, typename StoreT >
inline void Cntm::HandledList < ValueT, StoreT > ::DeleteEnumerator(Enumerator* Enum)
{
        boost::recursive_mutex::scoped_lock lock(mutex); // Блокируем перечень.
        Enum->Remove(); // Удаляем перечислитель из списка перечислителей.
}

template < typename ValueT, typename StoreT >
inline void Cntm::HandledList < ValueT, StoreT > ::ResetItemId(ItemId* DestId)
{
        boost::recursive_mutex::scoped_lock lock(mutex); // Блокируем перечень.
        *DestId = items.end(); // Устанавливаем пустое значение.
}
                

template < typename ValueT, typename StoreT >
inline void Cntm::HandledList < ValueT, StoreT > ::CopyItemId(const Enumerator& Src, ItemId* DestId)
{
        boost::recursive_mutex::scoped_lock lock(mutex); // Блокируем перечень.
        *DestId = Src.CurrentId(); // Копируем итератор.
}

template < typename ValueT, typename StoreT >
inline bool Cntm::HandledList < ValueT, StoreT > ::FirstItem(ItemId* DestId, void* DestCurrentBuf)
{
        boost::recursive_mutex::scoped_lock lock(mutex); // Блокируем перечень.
        *DestId = items.begin(); // Берем первый эл-т.
        return ReturnItem(*DestId, DestCurrentBuf); // Возвращаем значения.
}

template < typename ValueT, typename StoreT >
inline bool Cntm::HandledList < ValueT, StoreT > ::NextItem(ItemId* VarId, void* DestCurrentBuf)
{
        boost::recursive_mutex::scoped_lock lock(mutex); // Блокируем перечень.
        ++(*VarId); // Переходим к следующему.
        return ReturnItem(*VarId, DestCurrentBuf); // Возвращаем значения.
}

template < typename ValueT, typename StoreT >
inline bool Cntm::HandledList < ValueT, StoreT > ::ReturnItem(const ItemId& Id, void* DestCurrentBuf)
{
        bool res = (Id != items.end()); // Текущий эл-т не вышел за пределы списка.
        if (res) new(DestCurrentBuf) Type(*Id); // Если не конец списка, присваиваем значение.
        return res;
}


#endif //CNTM_HANDLEDLIST_H

---