containertypes.h

Go to the documentation of this file.

/*
 * This file is part of KDevelop
 * Copyright (C) 2011-2014 Sven Brauch <[email protected]>
 *
 * This program 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 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 Library General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef KDEVPLATFORM_CONTAINER_TYPES_H
#define KDEVPLATFORM_CONTAINER_TYPES_H
 
#include "structuretype.h"
#include "typesystemdata.h"
#include "typeutils.h"
#include "../duchainlock.h"
 
#include <language/languageexport.h>
 
namespace KDevelop {
class KDEVPLATFORMLANGUAGE_EXPORT ListTypeData
    : public KDevelop::StructureTypeData
{
public:
    ListTypeData()
        : KDevelop::StructureTypeData()
        , m_contentType() { }
 
    ListTypeData(const ListTypeData& rhs)
        : KDevelop::StructureTypeData(rhs)
        , m_contentType(rhs.m_contentType) { }
 
    explicit ListTypeData(const KDevelop::StructureTypeData& rhs)
        : KDevelop::StructureTypeData(rhs)
        , m_contentType() { }
 
    ~ListTypeData() = default;
 
    ListTypeData& operator=(const ListTypeData& rhs) = delete;
 
    IndexedType m_contentType;
};
 
class KDEVPLATFORMLANGUAGE_EXPORT ListType
    : public KDevelop::StructureType
{
public:
    using Ptr = TypePtr<ListType>;
 
    ListType();
    ListType(const ListType& rhs);
    explicit ListType(StructureTypeData& data);
 
    ListType& operator=(const ListType& rhs) = delete;
 
    template <typename LanguageUnsureType>
    void addContentType(const AbstractType::Ptr& typeToAdd)
    {
        auto newContentType = TypeUtils::mergeTypes<LanguageUnsureType>(contentType().abstractType(), typeToAdd);
        d_func_dynamic()->m_contentType = IndexedType(newContentType);
    }
 
    void replaceContentType(const AbstractType::Ptr& newType);
 
    IndexedType contentType() const;
 
    QString containerToString() const;
 
    QString toString() const override;
 
    AbstractType* clone() const override;
    uint hash() const override;
    bool equals(const AbstractType* rhs) const override;
 
    enum { Identity = 58 };
 
    using Data = ListTypeData;
 
protected:
    TYPE_DECLARE_DATA(ListType);
};
 
class KDEVPLATFORMLANGUAGE_EXPORT MapTypeData
    : public ListTypeData
{
public:
    MapTypeData()
        : ListTypeData()
        , m_keyType() { }
 
    MapTypeData(const MapTypeData& rhs)
        : ListTypeData(rhs)
        , m_keyType(rhs.m_keyType) { }
 
    explicit MapTypeData(const ListTypeData& rhs)
        : ListTypeData(rhs)
        , m_keyType() { }
 
    ~MapTypeData() = default;
 
    MapTypeData& operator=(const ListTypeData& rhs) = delete;
 
    IndexedType m_keyType;
};
 
class KDEVPLATFORMLANGUAGE_EXPORT MapType
    : public ListType
{
public:
    using Ptr = TypePtr<MapType>;
 
    MapType();
    MapType(const MapType& rhs);
    explicit MapType(ListTypeData& data);
 
    MapType& operator=(const MapType& rhs) = delete;
 
    template <typename LanguageUnsureType>
    void addKeyType(const AbstractType::Ptr& typeToAdd)
    {
        auto newKeyType = TypeUtils::mergeTypes<LanguageUnsureType>(keyType().abstractType(), typeToAdd);
        DUChainWriteLocker lock;
        d_func_dynamic()->m_keyType = IndexedType(newKeyType);
    }
 
    void replaceKeyType(const AbstractType::Ptr& newType);
 
    IndexedType keyType() const;
 
    QString toString() const override;
 
    AbstractType* clone() const override;
    uint hash() const override;
    bool equals(const AbstractType* rhs) const override;
 
    enum { Identity = 57 };
 
    using Data = MapTypeData;
 
protected:
    TYPE_DECLARE_DATA(MapType);
};
} // namespace KDevelop
 
#endif // KDEVPLATFORM_CONTAINER_TYPES_H