kdganttconstraint.cpp

Go to the documentation of this file.

/****************************************************************************
**
** This file is part of the KD Chart library.
**
** SPDX-FileCopyrightText: 2001 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
**
** SPDX-License-Identifier: MIT
**
****************************************************************************/
 
#include "kdganttconstraint.h"
#include "kdganttconstraint_p.h"
 
#include <QDateTime>
 
using namespace KDGantt;
 
Constraint::Private::Private()
{
}
 
Constraint::Private::Private(const Private &other)
    : QSharedData(other)
    , start(other.start)
    , end(other.end)
    , type(other.type)
    , relationType(other.relationType)
    , data(other.data)
{
}
 
Constraint::Constraint(const QModelIndex &idx1,
                       const QModelIndex &idx2,
                       Constraint::Type type,
                       Constraint::RelationType relationType,
                       const DataMap &datamap)
    : d(new Private)
{
    d->start = idx1;
    d->end = idx2;
    d->type = type;
    d->relationType = relationType;
    d->data = datamap;
    Q_ASSERT_X(idx1 != idx2 || !idx1.isValid(), "Constraint::Constraint", "cannot create a constraint with idx1 == idx2");
}
 
Constraint::Constraint()
    : d(new Private)
{
}
 
Constraint::Constraint(const Constraint &other)
    : d(other.d)
{
}
 
Constraint::~Constraint()
{
}
 
Constraint &Constraint::operator=(const Constraint &other)
{
    d = other.d;
    return *this;
}
 
Constraint::Type Constraint::type() const
{
    return d->type;
}
 
Constraint::RelationType Constraint::relationType() const
{
    return d->relationType;
}
 
QModelIndex Constraint::startIndex() const
{
    return d->start;
}
 
QModelIndex Constraint::endIndex() const
{
    return d->end;
}
 
QVariant Constraint::data(int role) const
{
    return d->data.value(role);
}
 
void Constraint::setData(int role, const QVariant &value)
{
    d->data.insert(role, value);
}
 
void Constraint::setDataMap(const QMap<int, QVariant> &datamap)
{
    d->data = datamap;
}
 
QMap<int, QVariant> Constraint::dataMap() const
{
    return d->data;
}
 
bool Constraint::compareIndexes(const Constraint &other) const
{
    return (d->start == other.startIndex() || (!d->start.isValid() && !other.startIndex().isValid()))
        && (d->end == other.endIndex() || (!d->end.isValid() && !other.endIndex().isValid()));
}
 
bool Constraint::operator==(const Constraint &other) const
{
    if (d == other.d)
        return true;
    return (*d).equals(*(other.d));
}
 
uint Constraint::hash() const
{
    return ::qHash(d->start) ^ ::qHash(d->end) ^ ::qHash(static_cast<uint>(d->type));
}
 
#ifndef QT_NO_DEBUG_STREAM
 
QDebug operator<<(QDebug dbg, const Constraint &c)
{
    return c.debug(dbg);
}
 
QDebug Constraint::debug(QDebug dbg) const
{
    dbg << "KDGantt::Constraint[ start=" << d->start << "end=" << d->end << "relationType=" << d->relationType << "], data=" << d->data;
    return dbg;
}
 
#endif /* QT_NO_DEBUG_STREAM */
 
#ifndef KDAB_NO_UNIT_TESTS
 
#include <QStandardItemModel>
 
#include "unittest/test.h"
 
KDAB_SCOPED_UNITTEST_SIMPLE(KDGantt, Constraint, "test")
{
    QStandardItemModel dummyModel(100, 100);
    QModelIndex idx1 = dummyModel.index(7, 17, QModelIndex());
    QModelIndex idx2 = dummyModel.index(42, 17, QModelIndex());
 
    Constraint c1 = Constraint(QModelIndex(), QModelIndex(), Constraint::TypeSoft);
    Constraint c2 = Constraint(QModelIndex(), QModelIndex(), Constraint::TypeSoft);
    Constraint c3 = c2;
    Constraint c4(idx1, idx2);
    Constraint c5(idx2, idx1);
 
    assertTrue(c1 == c2);
    assertEqual(qHash(c1), qHash(c2));
    assertTrue(c1 == c3);
    assertEqual(qHash(c1), qHash(c3));
    assertTrue(c2 == c3);
    assertEqual(qHash(c2), qHash(c3));
 
    assertFalse(c2 == c4);
    assertNotEqual(qHash(c2), qHash(c4));
 
    assertFalse(c4 == c5);
 
    assertEqual(c3.type(), Constraint::TypeSoft);
 
    dummyModel.removeRow(8);
    assertFalse(c4 == c5);
}
 
#endif /* KDAB_NO_UNIT_TESTS */