qa_macros.h

Go to the documentation of this file.

// QAlgorithm: a class for Qt/C++ implementing generic algorithm logic.
// Copyright (C) 2018  Filippo Santarelli
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// Contact me at: filippo2.santarelli@gmail.com
//

#ifndef _QA_MACRO
#define _QA_MACRO

#ifndef QA_IN

#define QA_IN "algin_"
#endif

#ifndef QA_OUT

#define QA_OUT "algout_"
#endif

#ifndef QA_PAR

#define QA_PAR "par_"
#endif

#ifndef QA_INPUT

#define QA_INPUT(Type, Name)                                                            \
Q_PROPERTY(Type algin_##Name MEMBER m_algin_##Name READ getIn##Name WRITE setIn##Name)  \
private:                                                                                \
    Type m_algin_##Name;                                                                \
public:                                                                                 \
    void setIn##Name (Type value){                                                      \
        this->m_algin_##Name = value;                                                   \
    }                                                                                   \
    Type getIn##Name () const{                                                          \
        return this->m_algin_##Name;                                                    \
    }                                                                                   \
    Type& getInRef##Name (){                                                            \
        return std::ref(this->m_algin_##Name);                                          \
    }                                                                                   \
    Type&& getInMove##Name (){                                                          \
        return std::move(this->m_algin_##Name);                                         \
    }
#endif

#ifndef QA_INPUT_LIST

#define QA_INPUT_LIST(Type, Name)                                           \
Q_PROPERTY(Type algin_##Name MEMBER m_algin_##Name WRITE setIn##Name)       \
private:                                                                    \
    Type m_algin_##Name;                                                    \
    QList<Type> m_listin_##Name;                                            \
public:                                                                     \
    void setIn##Name (Type value){                                          \
        this->m_algin_##Name = value;                                       \
        this->m_listin_##Name << value;                                     \
    }                                                                       \
    QList<Type> getIn##Name () const{                                       \
        return this->m_listin_##Name;                                       \
    }                                                                       \
    QList<Type>& getInRef##Name (){                                         \
        return std::ref(this->m_listin_##Name);                             \
    }                                                                       \
    QList<Type>&& getInMove##Name (){                                       \
        return std::move(this->m_listin_##Name);                            \
    }
#endif

#ifndef QA_INPUT_VEC

#define QA_INPUT_VEC(Type, Name)                                                \
Q_PROPERTY(Type algin_##Name MEMBER m_algin_##Name WRITE setIn##Name)           \
private:                                                                        \
    Type m_algin_##Name;                                                        \
    QVector<Type> m_vecin_##Name;                                               \
public:                                                                         \
    void setIn##Name (Type value){                                              \
        this->m_algin_##Name = value;                                           \
        this->m_vecin_##Name << value;                                          \
    }                                                                           \
    QVector<Type> getIn##Name () const{                                         \
        return this->m_vecin_##Name;                                            \
    }                                                                           \
    QVector<Type>& getInRef##Name (){                                           \
        return std::ref(this->m_vecin_##Name);                                  \
    }                                                                           \
    QVector<Type>&& getInMove##Name (){                                         \
        return std::move(this->m_vecin_##Name);                                 \
    }
#endif

#ifndef QA_OUTPUT
#define QA_OUTPUT(Type, Name)                                                                   \
Q_PROPERTY(Type algout_##Name MEMBER m_algout_##Name READ getOut##Name WRITE setOut##Name)      \
private:                                                                                        \
    Type m_algout_##Name;                                                                       \
protected:                                                                                      \
    void setOut##Name (Type value){                                                             \
        this->m_algout_##Name = value;                                                          \
    }                                                                                           \
public:                                                                                         \
    Type getOut##Name () const{                                                                 \
        return this->m_algout_##Name;                                                           \
    }                                                                                           \
    Type& getOutRef##Name (){                                                                   \
        return std::ref(this->m_algout_##Name);                                                 \
    }                                                                                           \
    Type&& getOutMove##Name (){                                                                 \
        return std::move(this->m_algout_##Name);                                                \
    }
#endif

#ifndef QA_PARAMETER

#define QA_PARAMETER(Type, Name, Default)                                                   \
Q_PROPERTY(Type par_##Name READ get##Name WRITE set##Name)                                  \
private:                                                                                    \
    Type par_##Name = Default;                                                              \
public:                                                                                     \
    void set##Name (Type value){                                                            \
    this->par_##Name = value;                                                               \
    }                                                                                       \
Type get##Name (){                                                                          \
    return this->par_##Name;                                                                \
}
#endif

#ifndef QA_CTOR_INHERIT
#define QA_CTOR_INHERIT                                                                     \
public:                                                                                     \
    using QAlgorithm::QAlgorithm;                                                           \
protected:                                                                                  \
    using QAlgorithm::setup;
#endif


#ifndef QA_IMPL_CREATE
#define QA_IMPL_CREATE(ClassName)                                                                   \
public:                                                                                             \
    static inline QSharedPointer<ClassName> create(QAPropertyMap parameters = QAPropertyMap(),      \
                                                    QObject* parent = Q_NULLPTR){                   \
        auto ptr = QSharedPointer<ClassName>(new ClassName(parent), &QObject::deleteLater);         \
        ptr->setup();                                                                               \
        if(!parameters.isEmpty()){                                                                  \
            ptr->setParameters(parameters);                                                         \
        }                                                                                           \
        ptr->init();                                                                                \
        return ptr;                                                                                 \
    }
#endif

#endif