src/main/decaf/util/concurrent/ConcurrentStlMap.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _DECAF_UTIL_CONCURRENTSTLMAP_H_
#define _DECAF_UTIL_CONCURRENTSTLMAP_H_

#include <map>
#include <vector>
#include <decaf/util/NoSuchElementException.h>
#include <decaf/util/concurrent/Synchronizable.h>
#include <decaf/util/concurrent/ConcurrentMap.h>
#include <decaf/util/concurrent/Mutex.h>
#include <decaf/util/Map.h>

namespace decaf{
namespace util{
namespace concurrent{

    template <typename K, typename V, typename COMPARATOR = std::less<K> >
    class ConcurrentStlMap : public ConcurrentMap<K, V, COMPARATOR> {
    private:

        std::map<K,V,COMPARATOR> valueMap;
        mutable concurrent::Mutex mutex;

    public:

        ConcurrentStlMap() : ConcurrentMap<K,V,COMPARATOR>(), valueMap(), mutex() {}

        ConcurrentStlMap( const ConcurrentStlMap& source ) :
            ConcurrentMap<K,V,COMPARATOR>(), valueMap(), mutex() {

            copy( source );
        }

        ConcurrentStlMap( const Map<K,V,COMPARATOR>& source ) :
            ConcurrentMap<K,V,COMPARATOR>(), valueMap(), mutex() {

            copy( source );
        }

        virtual ~ConcurrentStlMap() {}

        virtual bool equals( const ConcurrentStlMap& source ) const {
            synchronized( &mutex ) {
                return this->valueMap == source.valueMap;
            }

            return false;
        }

        virtual bool equals( const Map<K,V,COMPARATOR>& source ) const {

            synchronized( &mutex ) {
                std::vector<K> keys = source.keySet();

                typename std::vector<K>::const_iterator iter = keys.begin();
                for( ; iter != keys.end(); ++iter ) {
                    if( !this->containsKey( *iter ) ) {
                        return false;
                    }

                    if( !( this->get( *iter ) == source.get( *iter ) ) ) {
                        return false;
                    }
                }
            }

            return true;
        }

        virtual void copy( const ConcurrentStlMap& source ) {
            synchronized( &mutex ) {
                this->valueMap.clear();
                this->valueMap.insert( source.valueMap.begin(), source.valueMap.end() );
            }
        }

        virtual void copy( const Map<K,V,COMPARATOR>& source ) {
            synchronized( &mutex ) {
                this->clear();
                this->putAll( source );
            }
        }

        virtual void clear() throw( decaf::lang::exceptions::UnsupportedOperationException ) {
            synchronized( &mutex ) {
                valueMap.clear();
            }
        }

        virtual bool containsKey( const K& key ) const {
            typename std::map<K,V,COMPARATOR>::const_iterator iter;

            synchronized( &mutex ) {
                iter = valueMap.find(key);
                return iter != valueMap.end();
            }

            return false;
        }

        virtual bool containsValue( const V& value ) const {

            synchronized( &mutex ) {

                if( valueMap.empty() ){
                    return false;
                }

                typename std::map<K,V,COMPARATOR>::const_iterator iter = valueMap.begin();
                for( ; iter != valueMap.end(); ++iter ){
                    if( (*iter).second == value ) {
                        return true;
                    }
                }
            }

            return false;
        }

        virtual bool isEmpty() const {
            synchronized( &mutex ) {
                return valueMap.empty();
            }

            return true;
        }

        virtual int size() const {
            synchronized( &mutex ) {
                return (int)valueMap.size();
            }

            return 0;
        }

        virtual V& get( const K& key ) {

            typename std::map<K,V,COMPARATOR>::iterator iter;

            synchronized( &mutex ) {
                iter = valueMap.find( key );
                if( iter != valueMap.end() ){
                    return iter->second;
                }
            }

            throw NoSuchElementException(
                __FILE__, __LINE__, "Key does not exist in map" );
        }

        virtual const V& get( const K& key ) const {

            typename std::map<K,V,COMPARATOR>::const_iterator iter;

            synchronized( &mutex ) {
                iter = valueMap.find( key );
                if( iter != valueMap.end() ){
                    return iter->second;
                }
            }

            throw NoSuchElementException(
                __FILE__, __LINE__, "Key does not exist in map" );
        }

        virtual void put( const K& key, const V& value ) {

            synchronized( &mutex ) {
                valueMap[key] = value;
            }
        }

        virtual void putAll( const ConcurrentStlMap<K,V,COMPARATOR>& other ) {

            synchronized( &mutex ) {
                this->valueMap.insert( other.valueMap.begin(), other.valueMap.end() );
            }
        }

        virtual void putAll( const Map<K,V,COMPARATOR>& other ) {

            synchronized( &mutex ) {
                std::vector<K> keys = other.keySet();

                typename std::vector<K>::const_iterator iter = keys.begin();
                for( ; iter != keys.end(); ++iter ) {
                    this->put( *iter, other.get( *iter ) );
                }
            }
        }

        virtual V remove( const K& key ) {

            V result;

            synchronized( &mutex ) {
                typename std::map<K,V,COMPARATOR>::iterator iter = valueMap.find( key );
                if( iter == valueMap.end() ) {
                    throw NoSuchElementException(
                        __FILE__, __LINE__, "Key is not present in this Map." );
                }

                result = iter->second;
                valueMap.erase( iter );
            }

            return result;
        }

        virtual std::vector<K> keySet() const {

            std::vector<K> keys( valueMap.size() );
            synchronized( &mutex ) {

                typename std::map<K,V,COMPARATOR>::const_iterator iter;
                iter=valueMap.begin();
                for( int ix=0; iter != valueMap.end(); ++iter, ++ix ){
                    keys[ix] = iter->first;
                }
            }

            return keys;
        }

        virtual std::vector<V> values() const {

            std::vector<V> values( valueMap.size() );
            synchronized( &mutex ) {

                typename std::map<K,V,COMPARATOR>::const_iterator iter;
                iter=valueMap.begin();
                for( int ix=0; iter != valueMap.end(); ++iter, ++ix ){
                    values[ix] = iter->second;
                }

            }
            return values;
        }

        bool putIfAbsent( const K& key, const V& value ) {

            synchronized( &mutex ) {
                if( !this->containsKey( key ) ) {
                    this->put( key, value );
                    return true;
                }
            }

            return false;
        }

        bool remove( const K& key, const V& value ) {
            synchronized( &mutex ) {
                if( this->containsKey( key ) && ( this->get( key ) == value ) ) {
                    this->remove( key );
                    return true;
                }
            }

            return false;
        }

        bool replace( const K& key, const V& oldValue, const V& newValue ) {
            synchronized( &mutex ) {
                if( this->containsKey( key ) && ( this->get( key ) == oldValue ) ) {
                    this->put( key, newValue );
                    return true;
                }
            }

            return false;
        }

        V replace( const K& key, const V& value ) {

            synchronized( &mutex ) {
                if( this->containsKey( key ) ) {
                    V result = this->get( key );
                    this->put( key, value );
                    return result;
                }
            }

            throw NoSuchElementException(
                __FILE__, __LINE__, "Value to Replace was not in the Map." );
        }

    public:

        virtual void lock() {
            mutex.lock();
        }

        virtual bool tryLock() {
            return mutex.tryLock();
        }

        virtual void unlock() {
            mutex.unlock();
        }

        virtual void wait() {
            mutex.wait();
        }

        virtual void wait( long long millisecs ) {
            mutex.wait( millisecs );
        }

        virtual void wait( long long millisecs, int nanos ) {
            mutex.wait( millisecs, nanos );
        }

        virtual void notify() {
            mutex.notify();
        }

        virtual void notifyAll() {
            mutex.notifyAll();
        }

    };

}}}

#endif /*_DECAF_UTIL_CONCURRENTSTLMAP_H_*/