dictionary.h

Go to the documentation of this file.

/*MT*
    
    MediaTomb - http://www.mediatomb.cc/
    
    dictionary.h - this file is part of MediaTomb.
    
    Copyright (C) 2005 Gena Batyan <bgeradz@mediatomb.cc>,
                       Sergey 'Jin' Bostandzhyan <jin@mediatomb.cc>
    
    Copyright (C) 2006-2010 Gena Batyan <bgeradz@mediatomb.cc>,
                            Sergey 'Jin' Bostandzhyan <jin@mediatomb.cc>,
                            Leonhard Wimmer <leo@mediatomb.cc>
    
    MediaTomb is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 2
    as published by the Free Software Foundation.
    
    MediaTomb is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    version 2 along with MediaTomb; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
    
    $Id: dictionary.h 2081 2010-03-23 20:18:00Z lww $
*/

#ifndef __DICTIONARY_H__
#define __DICTIONARY_H__

#include "zmmf/zmmf.h"
#include "sync.h"

class DictionaryElement : public zmm::Object
{
public:
    DictionaryElement(zmm::String key, zmm::String value);

    void setKey(zmm::String key);

    void setValue(zmm::String value);

    zmm::String getKey();

    zmm::String getValue();

protected:
    zmm::String key;
    zmm::String value;
};

class Dictionary : public zmm::Object
{
protected:
    zmm::Ref<zmm::Array<DictionaryElement> > elements;
    zmm::String _encode(char sep1, char sep2);
public:

    Dictionary();

    void put(zmm::String key, zmm::String value);

    zmm::String get(zmm::String key);

    int size();
    
    void remove(zmm::String key);
    
    zmm::String encode();

    zmm::String encodeSimple();

    void clear();
    
    void decode(zmm::String url);

    void decodeSimple(zmm::String url);

    zmm::Ref<Dictionary> clone();

    void merge(zmm::Ref<Dictionary> other);

    bool isSubsetOf(zmm::Ref<Dictionary> other);

    bool equals(zmm::Ref<Dictionary> other);

    zmm::Ref<zmm::Array<DictionaryElement> > getElements();

    inline void optimize() { elements->optimize(); }
};


class Dictionary_r : public Dictionary
{
public:
    Dictionary_r() : Dictionary()
    {
        mutex = zmm::Ref<Mutex>(new Mutex(true));
    }
    
    inline void put(zmm::String key, zmm::String value)
    {
        mutex->lock();
        Dictionary::put(key, value);
        mutex->unlock();
    }
    
    inline zmm::String get(zmm::String key)
    {
        mutex->lock();
        zmm::String ret = Dictionary::get(key);
        mutex->unlock();
        return ret;
    }
    
    inline void remove(zmm::String key)
    {
        mutex->lock();
        Dictionary::remove(key);
        mutex->unlock();
    }
    
    inline zmm::String encode()
    {
        mutex->lock();
        zmm::String ret = Dictionary::encode();
        mutex->unlock();
        return ret;
    }
    
    inline void clear()
    {
        mutex->lock();
        Dictionary::clear();
        mutex->unlock();
    }
    
    inline void decode(zmm::String url)
    {
        mutex->lock();
        Dictionary::decode(url);
        mutex->unlock();
    }
    
    inline zmm::Ref<Dictionary_r> clone()
    {
        mutex->lock();
        zmm::Ref<Dictionary_r> ret = RefCast(Dictionary::clone(), Dictionary_r);
        mutex->unlock();
        return ret;
    }
    
    inline bool isSubsetOf(zmm::Ref<Dictionary> other)
    {
        mutex->lock();
        bool ret = Dictionary::isSubsetOf(other);
        mutex->unlock();
        return ret;
    }
    
    inline bool equals(zmm::Ref<Dictionary> other)
    {
        mutex->lock();
        bool ret = Dictionary::equals(other);
        mutex->unlock();
        return ret;
    }                                                                         
    
    inline zmm::Ref<zmm::Array<DictionaryElement> > getElements()
    {
        mutex->lock();
        zmm::Ref<zmm::Array<DictionaryElement> > ret = Dictionary::getElements();
        mutex->unlock();
        return ret;
    }
    
    inline void optimize()
    {
        mutex->lock();
        Dictionary::optimize();
        mutex->unlock();
    }
    
protected:
    zmm::Ref<Mutex> mutex;
};

#endif // __DICTIONARY_H__

---