Projekt

Allgemein

Profil

« Zurück | Weiter » 

Revision ba6f6521

Von Christian Ehringfeld vor fast 10 Jahren hinzugefügt

  • ID ba6f6521ea77f1092bc9060b00862ef48c030ab4
  • Vorgänger 396a60d7
  • Nachfolger 1a3b37ba

example update, one_to_one implementation of EM is reallly bad!

Unterschiede anzeigen:

example/Example.pro
HEADERS += \
models/artikel.h \
models/person.h \
models/group.h
models/group.h \
models/pupil.h \
models/teacher.h
SOURCES += \
main.cpp \
models/artikel.cpp \
models/person.cpp \
models/group.cpp
models/group.cpp \
models/pupil.cpp \
models/teacher.cpp
unix:!macx: LIBS += -L$$PWD/../../build-EntityManager-Desktop-Debug -lCuteEntityManager
unix:INCLUDEPATH += $$PWD/../src
example/main.cpp
#include "../src/relation.h"
#include <QGenericReturnArgument>
#include "entityinstancefactory.h"
#include <exception>
#include "models/pupil.h"
/**
* create,remove und merge funktionieren
*/
using namespace CuteEntityManager;
int main(int argc, char *argv[]) {
// Q_UNUSED(argc) Q_UNUSED(argv)
// CuteEntityManager::EntityManager *e = new CuteEntityManager::EntityManager("QSQLITE",
// QDir::currentPath() + "/db.sqlite");
CuteEntityManager::EntityManager *e = new CuteEntityManager::EntityManager("QSQLITE",
QDir::currentPath() + "/db.sqlite");
// QSharedPointer<Artikel> a = QSharedPointer<Artikel>(new Artikel(20.0, "Müsli"));
// auto ep = a.dynamicCast<CuteEntityManager::Entity>();
// qDebug() << e;
......
// e->create(pptr);
//e->createTable(grp.dynamicCast<CuteEntityManager::Entity>());
QSharedPointer<Group> grp = QSharedPointer<Group>(new Group());
// QTime t;
// t.start();
// e->createTable(QSharedPointer<Artikel>(new Artikel()));
// for (int var = 0; var < 10; ++var) {
// QSharedPointer<Entity> a = QSharedPointer<Artikel>(new Artikel(var,QString("a")+QString::number(var)));
// e->save(a);
// }
// qDebug() << "Dauer:" << t.elapsed();
grp.data()->setTeacher(new Person("Test", "Test12345"));
grp.data()->setTeacherP(QSharedPointer<Person>(new Person("Max", "Mustermann")));
auto meta = grp.data()->getRelationProperties();
auto iterator = meta.constBegin();
while(iterator != meta.constEnd()) {
qDebug() << EntityInstanceFactory::extractEntityType(iterator.value().typeName());
//qDebug() << e.Type;
++iterator;
Pupil *p = new Pupil();
auto hash = p->getMetaProperties();
auto iterator = hash.constBegin();
while(iterator != hash.constEnd()) {
qDebug() << iterator.key() << " Value:" << iterator.value().read(p);
iterator++;
}
return 0;
}
example/models/artikel.cpp
}
Artikel::Artikel(QObject *parent) : Entity(parent)
{
}
Artikel::Artikel(double preis, QString name) : Entity(){
this->preis = preis;
this->name = name;
example/models/group.cpp
#include <QDebug>
Group::Group() : Entity() {
connect(this, SIGNAL(personsChanged()), this, SLOT(personChangedSlot()));
qDebug() << "Konstruktor!";
persons = QList<Person *>();
persons.append(new Person("Vera", "Geseke", Person::FEMALE, "Vera Geseke.jpg", "", "", QDate::currentDate()));
persons.append(new Person("Harry", "Hirsch", Person::MALE));
persons.append(new Person("Sibylle", "Mentzel", Person::FEMALE, "Sibylle Mentzel.jpg", "", "", QDate::currentDate()));
}
QList<Person *> Group::getPersons() const {
return persons;
QString Group::getName() const
{
return name;
}
void Group::setPersons(const QList<Person *> &value) {
qDebug() << "set!!!";
persons = value;
void Group::setName(const QString &value)
{
name = value;
}
QSharedPointer<Person> Group::getTeacherP() const {
return teacherP;
QSharedPointer<Teacher> Group::getTeacher() const
{
return teacher;
}
void Group::setTeacherP(const QSharedPointer<Person> &value) {
teacherP = value;
void Group::setTeacher(const QSharedPointer<Teacher> &value)
{
teacher = value;
}
Person *Group::getTeacher() const {
return teacher;
QList<QSharedPointer<Pupil> > Group::getPupils() const
{
return pupils;
}
void Group::setTeacher(Person *value) {
teacher = value;
void Group::setPupils(const QList<QSharedPointer<Pupil> > &value)
{
pupils = value;
}
QSharedPointer<Artikel> Group::getArtikel() const {
return artikel;
QList<QSharedPointer<Pupil> > Group::getClassPrefects() const
{
return classPrefects;
}
void Group::setArtikel(const QSharedPointer<Artikel> &value) {
artikel = value;
void Group::setClassPrefects(const QList<QSharedPointer<Pupil> > &value)
{
classPrefects = value;
}
QList<QSharedPointer<Person> > Group::getParentSpeakers() const
{
return parentSpeakers;
}
void Group::personChangedSlot() {
qDebug() << "changed!";
void Group::setParentSpeakers(const QList<QSharedPointer<Person> > &value)
{
parentSpeakers = value;
}
const QHash<QString, CuteEntityManager::Relation> Group::getRelations() const {
QHash<QString, CuteEntityManager::Relation> h = QHash<QString, CuteEntityManager::Relation>();
CuteEntityManager::Relation r = CuteEntityManager::Relation("artikel", CuteEntityManager::MANY_TO_ONE);
h.insert("artikel", r);
return h;
const QHash<QString, Relation> Group::getRelations() const
{
auto hash = Entity::getRelations();
hash.insert("teacher",Relation("teacher",MANY_TO_ONE,false));
hash.insert("pupils",Relation("pupils",MANY_TO_MANY));
hash.insert("classPrefects",Relation("classPrefects",MANY_TO_MANY));
hash.insert("parentSpeakers",Relation("parentSpeakers",MANY_TO_MANY));
return hash;
}
//void Group::appendPerson(QQmlListProperty<Person> *list, Person *p) {
// Group *group = qobject_cast<Group*>(list->object);
// if(group && p) {
// group->addPerson(p);
// emit group->personsChanged();
// }
//}
//int Group::personsCount(QQmlListProperty<Person>*list)
//{
// Group *group = qobject_cast<Group*>(list->object);
// if (group)
// return group->m_persons.count();
// return 0;
//}
//Person* Group::personAt(QQmlListProperty<Person> *list, int i)
//{
// Group *group = qobject_cast<Group*>(list->object);
// if (group)
// return group->m_persons.at(i);
// return 0;
//}
//void Group::personsClear(QQmlListProperty<Person> *list)
//{
// Group *group = qobject_cast<Group*>(list->object);
// if (group) {
// group->m_persons.clear();
// emit group->personsChanged();
// }
//}
example/models/group.h
#include <QList>
#include <QVariantList>
//#include <QQuickView>
#include "artikel.h"
#include <QSharedPointer>
#include <QHash>
#include <QString>
#include "relation.h"
using namespace CuteEntityManager;
class SeatingPlan;
class Teacher;
class Pupil;
class Person;
class Relation;
class Group: public CuteEntityManager::Entity {
Q_OBJECT
//Q_ENUMS(Gender)
//Q_PROPERTY(QList<Person*> persons READ getPersons)
// Q_PROPERTY(QList<Person*> persons READ get_persons WRITE set_persons RESET reset_persons)
// BR_PROPERTY(QList<Person*>, persons, QList<Person*>())
Q_PROPERTY(QList<Person*> persons READ getPersons WRITE setPersons NOTIFY personsChanged)
Q_PROPERTY(Person* teacher READ getTeacher WRITE setTeacher)
Q_PROPERTY(QSharedPointer<Person> teacherP READ getTeacherP WRITE setTeacherP)
Q_PROPERTY(QSharedPointer<Artikel> artikel READ getArtikel WRITE setArtikel)
Q_PROPERTY(QList<QSharedPointer<Pupil>> pupils READ getPupils WRITE setPupils
NOTIFY pupilsChanged)
Q_PROPERTY(QList<QSharedPointer<Pupil>> classPrefects READ getClassPrefects
WRITE setClassPrefects NOTIFY classPrefectsChanged)
Q_PROPERTY(QSharedPointer<Teacher> teacher READ getTeacher WRITE setTeacher
NOTIFY teacherChanged)
Q_PROPERTY(QString name READ getName WRITE setName NOTIFY nameChanged)
Q_PROPERTY(QList<QSharedPointer<Person> > parentSpeakers READ getParentSpeakers WRITE setParentSpeakers
NOTIFY parentSpeakersChanged)
signals:
void personsChanged();
public slots:
void personChangedSlot();
void pupilsChanged();
void nameChanged();
void teacherChanged();
void classPrefectsChanged();
void parentSpeakersChanged();
public:
virtual const QHash<QString, CuteEntityManager::Relation> getRelations() const;
// constructor
virtual const QHash<QString, Relation> getRelations() const;
Group();
// getters
// QQmlListProperty <Person> persons();
// static void appendPerson(QQmlListProperty<Person> *list, Person *p);
// static int personsCount(QQmlListProperty<Person>*list);
// static Person* personAt(QQmlListProperty<Person> *list, int i);
// static void personsClear(QQmlListProperty<Person> *list);
QList <Person *> classPrefects() {
return m_classPrefects;
}
QList <Person *> parentSpeakers() {
return m_parentSpeakers;
}
// setters
void removePerson(Person *p) {
persons.removeOne(p);
}
void addClassPrefect(Person *p) {
m_classPrefects.append(p);
}
void removeClassPrefect(Person *p) {
m_classPrefects.removeOne(p);
}
void addParentSpeaker(Person *p) {
m_parentSpeakers.append(p);
}
void removeParentSpeaker(Person *p) {
m_parentSpeakers.removeOne(p);
}
void addPerson(Person *p) {
persons.append(p);
}
QList<Person *> getPersons() const;
void setPersons(const QList<Person *> &value);
QSharedPointer<Person> getTeacherP() const;
void setTeacherP(const QSharedPointer<Person> &value);
Person *getTeacher() const;
void setTeacher(Person *value);
QSharedPointer<Artikel> getArtikel() const;
void setArtikel(const QSharedPointer<Artikel> &value);
protected:
// members
Person* teacher;
QSharedPointer<Person> teacherP;
QList<Person*> persons;
QSharedPointer<Artikel> artikel;
QList <Person *> m_classPrefects;
QList <Person *> m_parentSpeakers;
// PersonListModel* m_personListModel;
QString getName() const;
void setName(const QString &value);
QSharedPointer<Teacher> getTeacher() const;
void setTeacher(const QSharedPointer<Teacher> &value);
QList<QSharedPointer<Pupil> > getPupils() const;
void setPupils(const QList<QSharedPointer<Pupil> > &value);
QList<QSharedPointer<Pupil> > getClassPrefects() const;
void setClassPrefects(const QList<QSharedPointer<Pupil> > &value);
QList<QSharedPointer<Person> > getParentSpeakers() const;
void setParentSpeakers(const QList<QSharedPointer<Person> > &value);
private:
QString name;
QSharedPointer<Teacher> teacher;
QList<QSharedPointer<Pupil>> pupils;
QList<QSharedPointer<Pupil>> classPrefects;
QList<QSharedPointer<Person>> parentSpeakers;
// PersonListModel* m_personListModel;
};
#endif // GROUP_H
example/models/person.cpp
QString Person::toString()
{
return Entity::toString() + " " + this->firstName();
return Entity::toString() + " " + this->getFirstName();
}
Person::Person(QObject *parent) : Entity(parent)
......
setGender(gender);
setCustomPictureFileName(customPictureFileName);
}
QString Person::getCustomPictureFileName() const
{
return customPictureFileName;
}
void Person::setCustomPictureFileName(const QString &value)
{
customPictureFileName = value;
}
Gender Person::getGender() const
{
return gender;
}
void Person::setGender(const Gender &value)
{
gender = value;
}
QDate Person::getBirthday() const
{
return birthday;
}
void Person::setBirthday(const QDate &value)
{
birthday = value;
}
QString Person::getNickName() const
{
return nickName;
}
void Person::setNickName(const QString &value)
{
nickName = value;
}
QString Person::getNamePrefix() const
{
return namePrefix;
}
void Person::setNamePrefix(const QString &value)
{
namePrefix = value;
}
QString Person::getFamilyName() const
{
return familyName;
}
void Person::setFamilyName(const QString &value)
{
familyName = value;
}
QString Person::getFirstName() const
{
return firstName;
}
void Person::setFirstName(const QString &value)
{
firstName = value;
}
example/models/person.h
#include <QAbstractListModel>
#include <QDebug>
enum Gender {MALE, FEMALE, UNKNOWNGENDER};
Q_DECLARE_METATYPE(Gender)
class Person: public CuteEntityManager::Entity {
Q_OBJECT
Q_ENUMS(Gender)
//[1] We don't want the id to be set from QML
//[2] Notification via inherited signals is not allowed
Q_PROPERTY(QString firstName READ firstName WRITE setFirstName NOTIFY firstNameChanged)
Q_PROPERTY(QString familyName READ familyName WRITE setFamilyName NOTIFY familyNameChanged)
Q_PROPERTY(QString namePrefix READ namePrefix WRITE setNamePrefix NOTIFY namePrefixChanged)
Q_PROPERTY(QString nickName READ nickName WRITE setNickName NOTIFY nickNameChanged)
Q_PROPERTY(QString customPictureFileName READ customPictureFileName WRITE setCustomPictureFileName NOTIFY
customPictureFileNameChanged)
Q_PROPERTY(QDate birthday READ birthday WRITE setBirthday NOTIFY birthdayChanged)
Q_PROPERTY(Gender gender READ gender WRITE setGender NOTIFY genderChanged)
//Q_ENUMS(Gender)
Q_PROPERTY(QString firstName READ getFirstName WRITE setFirstName NOTIFY
firstNameChanged)
Q_PROPERTY(QString familyName READ getFamilyName WRITE setFamilyName NOTIFY
familyNameChanged)
Q_PROPERTY(QString namePrefix READ getNamePrefix WRITE setNamePrefix NOTIFY
namePrefixChanged)
Q_PROPERTY(QString nickName READ getNickName WRITE setNickName NOTIFY
nickNameChanged)
Q_PROPERTY(QString customPictureFileName READ getCustomPictureFileName WRITE
setCustomPictureFileName NOTIFY
customPictureFileNameChanged)
Q_PROPERTY(QDate birthday READ getBirthday WRITE setBirthday NOTIFY
birthdayChanged)
Q_PROPERTY(Gender gender READ getGender WRITE setGender NOTIFY genderChanged)
signals:
void firstNameChanged();
......
void genderChanged();
void customPictureFileNameChanged();
public slots:
void testSlot() {
qDebug() << "testslot clicked";
}
public:
QString toString();
enum Gender {MALE, FEMALE, UNKNOWNGENDER};
Person(QObject *parent=0);
Person(QObject *parent = 0);
Person(QString firstName,
QString familyName,
Gender gender = Person::UNKNOWNGENDER,
Gender gender = UNKNOWNGENDER,
QString customPictureFileName = QString(),
QString namePrefix = QString(),
QString nickName = QString(),
QDate birthday = QDate(),
QObject *parent = 0);
virtual ~Person() {}
QString getCustomPictureFileName() const;
void setCustomPictureFileName(const QString &value);
Gender getGender() const;
void setGender(const Gender &value);
bool isPresent(QDateTime date = QDateTime::currentDateTime());
QString fullName();
// getters
QString firstName() const {
return m_firstName;
}
QString familyName() const {
return m_familyName;
}
QString namePrefix() const {
return m_namePrefix;
}
QString nickName() const {
return m_nickName;
}
QDate birthday() const {
return m_birthday;
}
Gender gender() const {
return m_gender;
}
QString customPictureFileName() const {
return m_customPictureFileName;
}
// setters
void setFirstName(QString firstName) {
m_firstName = firstName;
emit firstNameChanged();
}
void setFamilyName(QString familyName) {
m_familyName = familyName;
emit familyNameChanged();
}
void setNamePrefix(QString namePrefix) {
m_namePrefix = namePrefix;
emit namePrefixChanged();
}
void setNickName(QString nickName) {
m_nickName = nickName;
emit nickNameChanged();
}
void setBirthday(QDate birthday) {
m_birthday = birthday;
emit birthdayChanged();
}
void setGender(Gender gender) {
m_gender = gender;
emit genderChanged();
}
void setCustomPictureFileName(QString fileName) {
m_customPictureFileName = fileName;
emit customPictureFileNameChanged();
}
QDate getBirthday() const;
void setBirthday(const QDate &value);
QString getNickName() const;
void setNickName(const QString &value);
QString getNamePrefix() const;
void setNamePrefix(const QString &value);
QString getFamilyName() const;
void setFamilyName(const QString &value);
QString getFirstName() const;
void setFirstName(const QString &value);
protected:
// members
QString m_firstName;
QString m_familyName;
QString m_namePrefix;
QString m_nickName;
QDate m_birthday;
Gender m_gender;
QString m_customPictureFileName;
QString firstName;
QString familyName;
QString namePrefix;
QString nickName;
QDate birthday;
Gender gender;
QString customPictureFileName;
};
Q_DECLARE_METATYPE(Person*)
Q_DECLARE_METATYPE(QList<Person*>)
#endif // PERSON_H
example/models/pupil.cpp
#include "pupil.h"
Pupil::Pupil() : Person() {
}
QSharedPointer<Person> Pupil::getParent() const
{
return parent;
}
void Pupil::setParent(const QSharedPointer<Person> &value)
{
parent = value;
}
QString Pupil::getName() const
{
return name;
}
void Pupil::setName(const QString &value)
{
name = value;
}
const QHash<QString, Relation> Pupil::getRelations() const {
auto hash = Person::getRelations();
hash.insert("parent", Relation("parent", ONE_TO_ONE));
hash.insert("groups", Relation("groups", ONE_TO_MANY, "teacher"));
return hash;
}
example/models/pupil.h
#ifndef PUPIL_H
#define PUPIL_H
#include "person.h"
#include "relation.h"
using namespace CuteEntityManager;
class Pupil : public Person
{
Q_OBJECT
// Q_PROPERTY(QSharedPointer<Person> parent READ getParent WRITE setParent NOTIFY
// parentChanged)
Q_PROPERTY(QString name READ getName WRITE setName NOTIFY nameChanged)
signals:
void parentChanged();
void nameChanged();
public:
Pupil();
virtual const QHash<QString, Relation> getRelations() const;
QSharedPointer<Person> getParent() const;
void setParent(const QSharedPointer<Person> &value);
QString getName() const;
void setName(const QString &value);
private:
QSharedPointer<Person> parent;
QString name;
};
#endif // PUPIL_H
example/models/teacher.cpp
#include "teacher.h"
Teacher::Teacher(QSharedPointer<Person> parent) : Person() {
this->parent = parent;
}
const QHash<QString, Relation> Teacher::getRelations() const {
auto hash = Person::getRelations();
hash.insert("parent", Relation("parent", ONE_TO_ONE));
hash.insert("groups", Relation("groups", ONE_TO_MANY, "teacher"));
return hash;
}
QList<QSharedPointer<Group> > Teacher::getGroups() const {
return groups;
}
void Teacher::setGroups(const QList<QSharedPointer<Group> > &value) {
groups = value;
}
QSharedPointer<Person> Teacher::getParent() const {
return parent;
}
void Teacher::setParent(const QSharedPointer<Person> &value) {
parent = value;
}
example/models/teacher.h
#ifndef TEACHER_H
#define TEACHER_H
#include "person.h"
#include "relation.h"
using namespace CuteEntityManager;
class Group;
class Teacher : public Person {
Q_OBJECT
Q_PROPERTY(QList<QSharedPointer<Group>> groups READ getGroups WRITE setGroups
NOTIFY groupsChanged)
Q_PROPERTY(QSharedPointer<Person> parent READ getParent WRITE setParent NOTIFY
parentChanged)
signals:
void groupsChanged();
void parentChanged();
public:
Teacher(QSharedPointer<Person> parent);
virtual const QHash<QString, Relation> getRelations() const;
QList<QSharedPointer<Group> > getGroups() const;
void setGroups(const QList<QSharedPointer<Group> > &value);
QSharedPointer<Person> getParent() const;
void setParent(const QSharedPointer<Person> &value);
private:
QList<QSharedPointer<Group>> groups;
QSharedPointer<Person> parent;
};
#endif // TEACHER_H

Auch abrufbar als: Unified diff