UT_ORMModelState.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_ORMModelState.h
 *
 * COMMENTS:
 *
 *
 */

#ifndef __UT_ORMMODELSTATE_H__
#define __UT_ORMMODELSTATE_H__

#include "UT_API.h"

#include "UT_Array.h"
#include "UT_Debug.h"
#include "UT_ORMColumn.h"
#include "UT_ORMConstraint.h"
#include "UT_StringHolder.h"
#include "UT_UniquePtr.h"

#include <SYS/SYS_Compiler.h>

class UT_ORMModelStateField : public UT_ORMColumn
{
public:
    using UT_ORMColumn::UT_ORMColumn;
};

class UT_API UT_ORMModelState
{
public:
    UT_ORMModelState() = default;
    UT_ORMModelState(
            const UT_StringHolder& table_name,
            const UT_Array<UT_ORMModelStateField>& fields)
        : myName(table_name), myTableName(table_name), myFields(fields)
    {
    }

    ~UT_ORMModelState() = default;
    UT_ORMModelState(const UT_ORMModelState& model) { *this = model; }
    UT_ORMModelState& operator=(const UT_ORMModelState& model)
    {
        *this = model.clone();
        return *this;
    }
    UT_ORMModelState(UT_ORMModelState&&) = default;
    UT_ORMModelState& operator=(UT_ORMModelState&&) = default;

    UT_ORMModelState clone() const;

    const UT_StringHolder& name() const { return myName; }
    const UT_StringHolder& tableName() const { return myTableName; }

    UT_ORMModelStateField* findField(const UT_StringRef& field_name)
    {
        for (auto&& field : myFields)
        {
            if (field.name() == field_name)
                return &field;
        }
        return nullptr;
    }
    const UT_ORMModelStateField* findField(const UT_StringRef& field_name) const
    {
        return SYSconst_cast(this)->findField(field_name);
    }
    bool hasField(const UT_StringRef& field_name) const
    {
        for (auto&& field : myFields)
        {
            if (field.name() == field_name)
                return true;
        }
        return false;
    }
    void removeField(const UT_StringRef& field_name)
    {
        for (int i = 0, s = myFields.size(); i < s; i++)
        {
            if (myFields[i].name() == field_name)
            {
                myFields.removeIndex(i);
                break;
            }
        }
    }
    void addField(const UT_ORMModelStateField& field)
    {
        if (!hasField(field.name()))
        {
            myFields.emplace_back(field);
        }
    }
    void renameField(
            const UT_StringHolder& from_name,
            const UT_StringHolder& to_name)
    {
        if (UT_ORMModelStateField* found_field = findField(from_name);
            found_field)
        {
            found_field->setName(to_name);
        }
    }
    void addConstraint(UT_UniquePtr<UT_IORMConstraint> constraint)
    {
        myConstraints.emplace_back(std::move(constraint));
    }
    const UT_Array<UT_ORMModelStateField>& fields() const { return myFields; }
    const UT_Array<UT_UniquePtr<UT_IORMConstraint>>& constraints() const
    {
        return myConstraints;
    }

    UT_StringHolder myName;
    UT_StringHolder myTableName;
    UT_Array<UT_ORMModelStateField> myFields;
    UT_Array<UT_UniquePtr<UT_IORMConstraint>> myConstraints;
};

#endif // __UT_ORMMODELSTATE_H__