mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-04 02:29:49 -06:00
195 lines
9.3 KiB
C++
195 lines
9.3 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2017 *
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
|
|
* software and associated documentation files (the "Software"), to deal in the Software *
|
|
* without restriction, including without limitation the rights to use, copy, modify, *
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
|
|
* permit persons to whom the Software is furnished to do so, subject to the following *
|
|
* conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included in all copies *
|
|
* or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
|
|
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
|
|
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
|
|
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
|
|
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
|
****************************************************************************************/
|
|
|
|
#ifndef __OPENSPACE_CORE___TEMPLATEPROPERTY___H__
|
|
#define __OPENSPACE_CORE___TEMPLATEPROPERTY___H__
|
|
|
|
#include <openspace/properties/property.h>
|
|
|
|
namespace openspace {
|
|
namespace properties {
|
|
|
|
/**
|
|
* This concrete subclass of Property handles a single parameter value that is of type
|
|
* <code>T</code>. It provides all the necessary methods to automatically access the
|
|
* value. One notable instantiation of this class is StringProperty, using
|
|
* <code>T = std::string</code> while NumericalProperty is a templated subclass dealing
|
|
* with numerical parameter types.
|
|
* The accessor operator and assignment operators are overloaded, so that the
|
|
* TemplateProperty can be used just in the same way as a regular member variable. In the
|
|
* case that these cannot not be used inline, the Property::get method will work.
|
|
* The default value for the stored value of this TemplateProperty is retrieved via a call
|
|
* to the PropertyDelegate::defaultValue method, providing the template parameter
|
|
* <code>T</code> as argument. When a new TemplateProperty is required, that method needs
|
|
* to be specialized for the new type or a compile-time error will occur
|
|
* (See https://github.com/OpenSpace/OpenSpace/wiki/Concepts-Properties).
|
|
* \tparam T The type of value that is stored in this TemplateProperty
|
|
* \see Property
|
|
* \see NumericalProperty
|
|
* \see PropertyDelegate
|
|
*/
|
|
template <typename T>
|
|
class TemplateProperty : public Property {
|
|
public:
|
|
typedef T ValueType;
|
|
|
|
/**
|
|
* The constructor initializing the TemplateProperty with the provided
|
|
* <code>identifier</code> and human-readable <code>guiName</code>. The default value
|
|
* for the stored type <code>T</code> is retrieved using the PropertyDelegate's
|
|
* PropertyDelegate::defaultValue method, which must be specialized for new types or
|
|
* a compile-error will occur.
|
|
* \param identifier The identifier that is used for this TemplateProperty
|
|
* \param guiName The human-readable GUI name for this TemplateProperty
|
|
*/
|
|
TemplateProperty(std::string identifier, std::string guiName,
|
|
Property::Visibility visibility = Visibility::User);
|
|
|
|
/**
|
|
* The constructor initializing the TemplateProperty with the provided
|
|
* <code>identifier</code>, human-readable <code>guiName</code> and provided
|
|
* <code>value</code>.
|
|
*/
|
|
TemplateProperty(std::string identifier, std::string guiName, T value,
|
|
Property::Visibility visibility = Visibility::User);
|
|
|
|
/**
|
|
* Returns the class name for this TemplateProperty. The default implementation makes
|
|
* a call to the PropertyDelegate::className method with the template parameter
|
|
* <code>T</code> as argument. For this to work, that method needs to be specialized
|
|
* to return the correct class name for the new template parameter T, or a
|
|
* compile-time error will occur.
|
|
* \return The class name for the TemplateProperty
|
|
*/
|
|
virtual std::string className() const override;
|
|
|
|
/**
|
|
* Returns the stored value packed into a ghoul::any object.
|
|
* \return The stored value packed into a ghoul::any object
|
|
*/
|
|
virtual ghoul::any get() const override;
|
|
|
|
/**
|
|
* Sets the value fro the provided ghoul::any object. If the types between
|
|
* <code>T</code> and <code>value</code> disagree, an error is logged and the stored
|
|
* value remains unchanged.
|
|
*/
|
|
virtual void set(ghoul::any value) override;
|
|
|
|
/**
|
|
* Returns the <code>std::type_info</code> describing the template parameter
|
|
* <code>T</code>. It can be used to test against a ghoul::any value before trying to
|
|
* assign it.
|
|
* \return The type info object describing the template parameter <code>T</code>
|
|
*/
|
|
virtual const std::type_info& type() const override;
|
|
|
|
/**
|
|
* This method encodes the stored value into a Lua object and pushes that object onto
|
|
* the stack. The encoding is performed by calling PropertyDelegate::toLuaValue with
|
|
* the template parameter <code>T</code> as an argument. This method has to be
|
|
* specialized for each new type, or a compile-time error will occur.
|
|
* \param state The Lua state onto which the encoded object will be pushed
|
|
* \return <code>true</code> if the encoding succeeded; <code>false</code> otherwise
|
|
*/
|
|
bool getLuaValue(lua_State* state) const override;
|
|
|
|
/**
|
|
* Sets the value of this TemplateProprty by decoding the object at the top of the Lua
|
|
* stack and, if successful, assigning it using the Property::set method. The decoding
|
|
* is performed by calling the PropertyDelegate::fromLuaValue with the template
|
|
* parameter <code>T</code> as argument. If the decoding is successful, the new value
|
|
* is set, otherwise it remains unchanged.
|
|
* \param state The Lua state from which the value will be decoded
|
|
* \return <code>true</code> if the decoding succeeded; <code>false</code> otherwise
|
|
*/
|
|
bool setLuaValue(lua_State* state) override;
|
|
|
|
/// \see Property::typeLua
|
|
int typeLua() const override;
|
|
|
|
bool getStringValue(std::string& value) const override;
|
|
|
|
bool setStringValue(std::string value) override;
|
|
|
|
/**
|
|
* Returns the description for this TemplateProperty as a Lua script that returns a
|
|
* table on execution
|
|
* \return The description for this TemplateProperty
|
|
*/
|
|
//virtual std::string description() override;
|
|
|
|
/**
|
|
* This operator allows the TemplateProperty to be used almost transparently as if it
|
|
* was of the type <code>T</code>. It makes assignments such as
|
|
* <code>T v = property;</code> possible by allowing implicit casts (even though,
|
|
* internally, not casts are performed. This method is next to zero overhead).
|
|
* \return The internal representation of the Property
|
|
*/
|
|
operator T();
|
|
|
|
/**
|
|
* This operator allows the TemplateProperty to be used almost transparently as if it
|
|
* was of the type <code>T</code>. It makes assignments such as
|
|
* <code>T v = property;</code> possible by allowing implicit casts (even though,
|
|
* internally, not casts are performed. This method is next to zero overhead).
|
|
* \return The internal representation of the Property
|
|
*/
|
|
operator T() const;
|
|
|
|
/**
|
|
* The assignment operator allows the TemplateProperty's value to be set without using
|
|
* the TemplateProperty::set method. It will be done internally by thos method and it
|
|
* allows assignments such as <code>prop = T(1)</code>.
|
|
* \param val The value that should be set.
|
|
*/
|
|
TemplateProperty<T>& operator=(T val);
|
|
|
|
/**
|
|
* These method sets the stored value to the provided value <code>val</code>,
|
|
* moving it into place. This move only happens if the provided value <code>val</code>
|
|
* is different from the stored value, which needs an operator== to exist for the type
|
|
* <code>T</code>. If the value are different, the listeners are notified.
|
|
* \param val The new value for this TemplateProperty
|
|
*/
|
|
virtual void setValue(T val);
|
|
|
|
/**
|
|
* Returns the currently stored value.
|
|
* \return The currently stored value
|
|
*/
|
|
T value() const;
|
|
|
|
protected:
|
|
/// The value that this TemplateProperty currently stores
|
|
T _value;
|
|
};
|
|
|
|
} // namespace properties
|
|
} // namespace openspace
|
|
|
|
#include "openspace/properties/templateproperty.inl"
|
|
|
|
#endif // __OPENSPACE_CORE___TEMPLATEPROPERTY___H__
|