resourcedata.h

Go to the documentation of this file.

/*
 * This file is part of the Nepomuk KDE project.
 * Copyright (C) 2006-2010 Sebastian Trueg <trueg@kde.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#ifndef _NEPOMUK2_RESOURCE_DATA_H_
#define _NEPOMUK2_RESOURCE_DATA_H_

#include <QtCore/QString>
#include <QtCore/QList>
#include <QtCore/QHash>
#include <QtCore/QMutex>
#include <QtCore/QAtomicInt>
#include <QtCore/QSet>

#include "variant.h"
#include <kurl.h>

#include <soprano/statement.h>


namespace Nepomuk2 {

    class Resource;
    class ResourceManagerPrivate;

    class ResourceData
    {
    public:
        explicit ResourceData( const QUrl& uri, const QUrl& kickOffUri, const QUrl& type_, ResourceManagerPrivate* rm );
        ~ResourceData();

        inline bool ref(Nepomuk2::Resource* res) {
            // Caller must lock ResourceManager mutex
            m_resources.push_back( res );
            return m_ref.ref();
        }

        inline bool deref(Nepomuk2::Resource* res) {
            // Caller must lock ResourceManager mutex
            m_resources.removeAll( res );
            return m_ref.deref();
        }

        QList<Resource*> resources() const {
            // Caller must lock ResourceManager mutex
            return m_resources;
        }

        inline int cnt() const {
            return m_ref;
        }

        bool isFile();

        QUrl uri() const;

        QUrl type();

        QHash<QUrl, Variant> allProperties();

        bool hasProperty( const QUrl& uri );

        bool hasProperty( const QUrl& p, const Variant& v );

        Variant property( const QUrl& uri );

        void setProperty( const QUrl& uri, const Variant& value );

        void addProperty( const QUrl& uri, const Variant& value );

        void removeProperty( const QUrl& uri );

        bool store();

        bool load();

        void remove( bool recursive = true );

        bool exists();

        bool isValid() const;

        void determineUri();

        void invalidateCache();

        bool operator==( const ResourceData& other ) const;

        QDebug operator<<( QDebug dbg ) const;

        ResourceManagerPrivate* rm() const { return m_rm; }

        void updateKickOffLists( const QUrl& uri, const Variant& oldvariant, const Variant& newvariant );

        void propertyRemoved( const Types::Property &prop, const QVariant &value );
        void propertyAdded( const Types::Property &prop, const QVariant &value );

        void setWatchEnabled( bool status );
        bool watchEnabled();

        void resetAll();
    private:
        ResourceData(const ResourceData&); // = delete
        ResourceData& operator = (const ResourceData&); // = delete
        void updateUrlLists( const QUrl& oldUrl, const QUrl& newUrl );
        void updateIdentifierLists( const QString& oldIdentifier, const QString& newIdentifier );

        void addToWatcher();
        void removeFromWatcher();

        QList<Resource*> m_resources;

        KUrl m_uri;

        KUrl m_nieUrl;

        QString m_naoIdentifier;

        QUrl m_type;

        QAtomicInt m_ref;

        // Protect m_cache, m_cacheDirty but also m_uri, m_nieUrl, m_naoIdentifier, m_addedToWatcher.
        // Never lock the ResourceManager mutex after locking this one. Always before (or not at all).
        mutable QMutex m_dataMutex;

        QHash<QUrl, Variant> m_cache;

        bool m_cacheDirty;
        bool m_addedToWatcher;
        bool m_watchEnabled;

        ResourceManagerPrivate* m_rm;
    };
}

QDebug operator<<( QDebug dbg, const Nepomuk2::ResourceData& );

#endif