indexedstring.h

Go to the documentation of this file.

/* This file is part of KDevelop

   Copyright 2008 David Nolden <[email protected]>

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of
   the License, or (at your option) any later version.

   This program 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
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef KDEVPLATFORM_INDEXED_STRING_H
#define KDEVPLATFORM_INDEXED_STRING_H

//krazy:excludeall=dpointer,inline

#include <QMetaType>
#include <QUrl>

#include "referencecounting.h"

#include "serializationexport.h"

namespace KDevelop {
class KDEVPLATFORMSERIALIZATION_EXPORT IndexedString
{
public:
    IndexedString();
    explicit IndexedString(const char* str, unsigned short length, unsigned int hash = 0);

    explicit IndexedString(const char* str);

    explicit IndexedString(char c);

    explicit IndexedString(const QString& str);

    explicit IndexedString(const QByteArray& str);

    IndexedString(IndexedString&& o) Q_DECL_NOEXCEPT
        : m_index(o.m_index)
    {
        o.m_index = 0;
    }

    static IndexedString fromIndex(unsigned int index)
    {
        IndexedString ret;
        ret.m_index = index;
        return ret;
    }

    static int lengthFromIndex(unsigned int index);

    IndexedString(const IndexedString&);

    ~IndexedString();

    explicit IndexedString(const QUrl& url);

    QUrl toUrl() const;

    inline unsigned int hash() const
    {
        return m_index;
    }

    inline unsigned int index() const
    {
        return m_index;
    }

    bool isEmpty() const
    {
        return m_index == 0;
    }

    int length() const;

    const char* c_str() const;

    QString str() const;

    QByteArray byteArray() const;

    IndexedString& operator=(const IndexedString&);

    IndexedString& operator=(IndexedString&& o) Q_DECL_NOEXCEPT
    {
        m_index = o.m_index;
        o.m_index = 0;
        return *this;
    }

    bool operator ==(const IndexedString& rhs) const
    {
        return m_index == rhs.m_index;
    }

    bool operator !=(const IndexedString& rhs) const
    {
        return m_index != rhs.m_index;
    }

    bool operator <(const IndexedString& rhs) const
    {
        return m_index < rhs.m_index;
    }

    struct RunningHash
    {
        enum {
            HashInitialValue = 5381
        };

        RunningHash()
        {
        }
        inline void append(const char c)
        {
            hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
        }
        inline void clear()
        {
            hash = HashInitialValue;
        }

        unsigned int hash = HashInitialValue;
    };

    static unsigned int hashString(const char* str, unsigned short length);

    static uint indexForString(const char* str, unsigned short length, uint hash = 0);
    static uint indexForString(const QString& str, uint hash = 0);

private:
    explicit IndexedString(bool);
    uint m_index = 0;
};

// the following function would need to be exported in case you'd remove the inline keyword.
inline uint qHash(const KDevelop::IndexedString& str)
{
    return str.index();
}
}

KDEVPLATFORMSERIALIZATION_EXPORT QDebug operator<<(QDebug s, const KDevelop::IndexedString& string);

Q_DECLARE_METATYPE(KDevelop::IndexedString)
Q_DECLARE_TYPEINFO(KDevelop::IndexedString, Q_MOVABLE_TYPE);

#endif