attributerange.h

/* Evoplex <https://evoplex.org>
 * Copyright (C) 2016-present - Marcos Cardinot <marcos@cardinot.net>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef ATTRIBUTE_RANGE_H
#define ATTRIBUTE_RANGE_H

#include <functional>
#include <memory>
#include <vector>
#include <QHash>

#include "prg.h"
#include "value.h"

namespace evoplex {

class AttributeRange;
using AttributeRangePtr = std::shared_ptr<AttributeRange>;
using AttributesScope = QHash<QString, AttributeRangePtr>;

class AttributeRangeInterface
{
public:
    virtual ~AttributeRangeInterface() = default;

    virtual Value rand(PRG* prg) const = 0;

    virtual Value next(const Value& v) const = 0;

    virtual Value prev(const Value& v) const = 0;
};

class AttributeRange : public AttributeRangeInterface
{
public:
    enum Type {
        Invalid,        
        // IntervalOfValues
        Double_Range,   
        Int_Range,      
        Bool,           
        // SetOfValues
        Double_Set,     
        Int_Set,        
        String_Set,     
        // SingleValue
        String,         
        NonEmptyString, 
        DirPath,        
        FilePath,       
    };

    static AttributeRangePtr parse(int attrId, const QString& attrName,
                                   const QString& attrRangeStr);

    ~AttributeRange() override = default;

    Value validate(const QString& valueStr) const;

    inline bool isValid() const;
    inline int id() const;
    inline const QString& attrName() const;
    inline const QString& attrRangeStr() const;
    inline Type type() const;
    inline const Value& min() const;
    inline const Value& max() const;

protected:
    const int m_id;
    const QString m_attrName;
    const Type m_type;
    QString m_attrRangeStr;
    Value m_min;
    Value m_max;

    explicit AttributeRange(int id, const QString& attrName, Type type);

private:
    // assume that attrRangeStr is equal to 'int{ }' or 'double{ }'
    static AttributeRangePtr setOfValues(QString attrRangeStr, const int id,
                                         const QString& attrName);

    // assume that attrRangeStr is equal to 'int[min,max]' or 'double[min,max]'
    static AttributeRangePtr intervalOfValues(QString attrRangeStr, const int id,
                                              const QString& attrName);
};

class SingleValue : public AttributeRange
{
public:
    explicit SingleValue(int id, const QString& attrName, Type type);
    explicit SingleValue();

    ~SingleValue() override = default;

    inline Value rand(PRG*) const override;
    inline Value next(const Value& v) const override;
    inline Value prev(const Value& v) const override;
};

class IntervalOfValues : public AttributeRange
{
public:
    IntervalOfValues(int id, const QString& attrName, Type type,
                     const Value &min, const Value &max);

    ~IntervalOfValues() override = default;

    inline Value rand(PRG* prg) const override;
    inline Value next(const Value& v) const override;
    inline Value prev(const Value& v) const override;

private:
    std::function<Value(PRG*)> f_rand;
    std::function<Value(const Value&)> f_next;
    std::function<Value(const Value&)> f_prev;
};

class SetOfValues : public AttributeRange
{
public:
    SetOfValues(int id, const QString& attrName, Type type, Values values);

    ~SetOfValues() override = default;

    inline const Values& values() const;

    inline Value rand(PRG* prg) const override;
    Value next(const Value& v) const override;
    Value prev(const Value& v) const override;

private:
    Values m_values;
};

/***********************/

inline bool AttributeRange::isValid() const
{ return m_type != Invalid; }

inline int AttributeRange::id() const
{ return m_id; }

inline const QString& AttributeRange::attrName() const
{ return m_attrName; }

inline const QString& AttributeRange::attrRangeStr() const
{ return m_attrRangeStr; }

inline AttributeRange::Type AttributeRange::type() const
{ return m_type; }

inline const Value& AttributeRange::min() const
{ return m_min; }

inline const Value& AttributeRange::max() const
{ return m_max; }

/***********************/

inline Value SingleValue::rand(PRG* prg) const
{ return prg->bernoulli() ? m_max : m_min; }

inline Value SingleValue::next(const Value& val) const
{ return val; }

inline Value SingleValue::prev(const Value& val) const
{ return val; }

/***********************/

inline Value IntervalOfValues::rand(PRG* prg) const
{ return f_rand(prg); }

inline Value IntervalOfValues::next(const Value& val) const
{ return f_next(val); }

inline Value IntervalOfValues::prev(const Value& val) const
{ return f_prev(val); }

/***********************/

inline Value SetOfValues::rand(PRG* prg) const {
    if (m_values.empty()) return Value();
    return m_values.at(prg->uniform(m_values.size()-1));
}

inline const Values& SetOfValues::values() const
{ return m_values; }

} // evoplex
#endif // ATTRIBUTE_RANGE_H