concurrent_dictionary.h

 
#ifndef _aspose_system_collections_concurrent_dictionary_h_
#define _aspose_system_collections_concurrent_dictionary_h_
 
#include <system/collections/dictionary.h>
#include <system/collections/keyvalue_pair.h>
 
namespace System {
namespace Collections {
namespace Concurrent {
 
template<class TKey, class TValue>
class ASPOSECPP_SHARED_CLASS ConcurrentDictionary : public System::Collections::Generic::Dictionary<TKey, TValue>
{
public:
    using ThisType = ConcurrentDictionary<TKey, TValue>;
    using BaseType = System::Collections::Generic::Dictionary<TKey, TValue>;
 
private:
    RTTI_INFO_TEMPLATE_CLASS(ThisType, System::BaseTypesInfo<BaseType>);
 
public:
    virtual void idx_set(const TKey& key, TValue value) override
    {
        LockContext __guard(this);
        BaseType::idx_set(key, value);
    }
    virtual SharedPtr<typename ThisType::KeyCollection> get_KeysInternal() const override
    {
        SharedPtr<typename ThisType::KeyCollection> keys;
        {
            LockContext __guard(const_cast<ThisType*>(this));
            keys = BaseType::get_KeysInternal();
        }
        return keys;
    }
protected:
    ~ConcurrentDictionary() override {}
 
    virtual SharedPtr<typename ThisType::ValueCollection> get_ValuesInternal() const override
    {
        SharedPtr<typename ThisType::ValueCollection> values;
        {
            LockContext __guard(const_cast<ThisType*>(this));
            values = BaseType::get_ValuesInternal();
        }
        return values;
    }
public:
    bool TryAdd(const TKey& key, const TValue& value)
    {
        bool result = false;
        {
            LockContext __guard(this);
            if (!BaseType::ContainsKey(key))
            {
                BaseType::Add(key, value);
                result = true;
            }
        }
        return result;
    }
    virtual void Add(const TKey& key, const TValue& value) override
    {
        LockContext __guard(this);
        BaseType::Add(key, value);
    }
    virtual void Clear() override
    {
        LockContext __guard(this);
        BaseType::Clear();
    }
    virtual void CopyTo(ArrayPtr<System::Collections::Generic::KeyValuePair<TKey, TValue>> arr, int index) override
    {
        LockContext __guard(this);
        BaseType::CopyTo(arr, index);
    }
    virtual bool Remove(const TKey& key) override
    {
        bool value = false;
        {
            LockContext __guard(this);
            value = BaseType::Remove(key);
        }
        return value;
    }
};
 
} // namespace ConcurrentGeneric
} // namespace Collections
} // namespace System
 
#endif // _aspose_system_collections_concurrent_dictionary_h_