template<class T1>
class FelineTemplateBase
{
	FelineTemplateBase<T1>(T1&& _default, std::string _name)	{ }
};

template<class T1>
class PropertyFelineTest : public FelineTemplateBase<T1>
{
	PropertyFelineTest<T1>(T1&& _default, std::string _name, void *_validator = nullptr) :
		super(std::forward<T1>(_default), std::move(_name))
	{

	}
};

#include <iostream>
#include <string>
#include <functional>

namespace prop {
template <class T>
class _Base
{
private:
    T m_Value;
    std::string m_Name;

protected:
    template <class T1>
    void _setValue(T1&& _value)
    {
        m_Value = std::forward<T1>(_value);
    }

public:
    template <class T1>
    _Base(std::string _name, T1&& _value) :
        m_Value(std::forward<T1>(_value)),
        m_Name(std::move(_name))
    {}
    
    const T& operator *() const
    {
        return m_Value;
    }
};

template <class T>
class Property : public _Base<T>
{
private:
    using super = _Base<T>;
    using Validator = std::function<bool(T)>;
    Validator m_Validator;
    
public:
    template <class T1>
    Property(std::string _name, T1&& _value, Validator _validator = nullptr) :
        super(std::move(_name), std::forward<T1>(_value)),
        m_Validator(_validator)
    {}
    
    Property& operator =(const Property& _other) = default;
    template <class T1>
    Property& operator =(T1&& _value)
    {
        if (!m_Validator || m_Validator(_value))
            super::_setValue(std::forward<T1>(_value));
        return *this;
    }
};
}

int main()
{
    prop::Property<int> p{ "test", 0, [](auto _v){
        if (_v <= 0)
        {
            std::cout << "not allowed\n";
            return false;
        }
        return true;
    }};
    
    p = -1;
    p = 5;
    std::cout << *p;
}