263 lines
8.8 KiB
Plaintext
263 lines
8.8 KiB
Plaintext
#ifndef OSGINTROSPECTION_PROPERTYINFO_
|
|
#define OSGINTROSPECTION_PROPERTYINFO_
|
|
|
|
#include <osgIntrospection/Export>
|
|
#include <osgIntrospection/Type>
|
|
#include <osgIntrospection/MethodInfo>
|
|
#include <osgIntrospection/Attributes>
|
|
|
|
#include <string>
|
|
#include <typeinfo>
|
|
#include <iosfwd>
|
|
#include <vector>
|
|
|
|
namespace osgIntrospection
|
|
{
|
|
|
|
/// This class keeps information about a class' property. A property is
|
|
/// defined by a name and a set of methods that store and retrieve
|
|
/// values. When the user wants to "get" the value of a property, the
|
|
/// getter method will be invoked and its value returned. When the user
|
|
/// wants to "set" the value of a property, the setter method will be
|
|
/// called. There are three kinds of property: simple (get/set), indexed
|
|
/// (get[i1, i2, ...]/set[i1, i2, ...]), and array (count/add/get[i]/
|
|
/// set[i]).
|
|
/// Objects of class PropertyInfo can't be modified once they have been
|
|
/// created, but they can be queried without restrictions. You can either
|
|
/// retrieve the accessor methods and invoke them manually, or you can
|
|
/// call getValue() / setValue() etc. methods to perform direct operations
|
|
/// on the property, given an instance of the declaring type to work on.
|
|
/// The latter technique is preferred because it checks for custom
|
|
/// attributes associated to the PropertyInfo object and passes control
|
|
/// to them when needed.
|
|
///
|
|
class OSGINTROSPECTION_EXPORT PropertyInfo: public CustomAttributeProvider
|
|
{
|
|
public:
|
|
/// Direct initialization constructor for simple and indexed
|
|
/// properties.
|
|
/// You must pass the Type object associated to the class that
|
|
/// declares the property, the Type object that describes the
|
|
/// type of the property's value, the property name and the
|
|
/// getter/setter methods. Either the setter or the getter can
|
|
/// be null, meaning a restricted access. If both are null, the
|
|
/// user is expected to add a custom accessor attribute to this
|
|
/// PropertyInfo object.
|
|
/// If the getter method has parameters, the property is considered
|
|
/// to be indexed. The same is true if the getter is null and the
|
|
/// setter has more than one parameter.
|
|
PropertyInfo(const Type &decltype, const Type &ptype, const std::string &name, const MethodInfo *getm, const MethodInfo *setm)
|
|
: CustomAttributeProvider(),
|
|
decltype_(decltype),
|
|
ptype_(ptype),
|
|
name_(name),
|
|
getm_(getm),
|
|
setm_(setm),
|
|
numm_(0),
|
|
addm_(0),
|
|
is_array_(false)
|
|
{
|
|
if (getm_)
|
|
{
|
|
for (ParameterInfoList::size_type i=0; i<getm_->getParameters().size(); ++i)
|
|
indices_.push_back(getm_->getParameters().at(i));
|
|
}
|
|
else
|
|
{
|
|
if (setm_)
|
|
{
|
|
for (ParameterInfoList::size_type i=0; i<(setm_->getParameters().size()-1); ++i)
|
|
indices_.push_back(setm_->getParameters().at(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Direct initialization constructor for "array" properties.
|
|
/// You must pass the Type object associated to the type that
|
|
/// declares the property, the Type object that describes the
|
|
/// type of the property's value, the property name and the
|
|
/// getter/setter/counter/adder methods.
|
|
PropertyInfo(const Type &decltype, const Type &ptype, const std::string &name, const MethodInfo *getm, const MethodInfo *setm, const MethodInfo *numm, const MethodInfo *addm)
|
|
: CustomAttributeProvider(),
|
|
decltype_(decltype),
|
|
ptype_(ptype),
|
|
name_(name),
|
|
getm_(getm),
|
|
setm_(setm),
|
|
numm_(numm),
|
|
addm_(addm),
|
|
is_array_(true)
|
|
{
|
|
}
|
|
|
|
/// Returns the number of indices
|
|
inline int getNumIndices() const
|
|
{
|
|
return static_cast<int>(getIndexParameters().size());
|
|
}
|
|
|
|
/// Returns the name of the property being described.
|
|
inline virtual const std::string &getName() const
|
|
{
|
|
return name_;
|
|
}
|
|
|
|
/// Returns the type that declares the property.
|
|
inline virtual const Type &getDeclaringType() const
|
|
{
|
|
return decltype_;
|
|
}
|
|
|
|
/// Returns the type of the reflected property.
|
|
inline const Type &getPropertyType() const
|
|
{
|
|
const PropertyTypeAttribute *pta = getAttribute<PropertyTypeAttribute>(false);
|
|
if (pta) return pta->getPropertyType();
|
|
return ptype_;
|
|
}
|
|
|
|
/// Returns the getter method.
|
|
inline const MethodInfo *getGetMethod() const
|
|
{
|
|
return getm_;
|
|
}
|
|
|
|
/// Returns the setter method.
|
|
inline const MethodInfo *getSetMethod() const
|
|
{
|
|
return setm_;
|
|
}
|
|
|
|
/// Returns the counter method.
|
|
inline const MethodInfo *getCountMethod() const
|
|
{
|
|
return numm_;
|
|
}
|
|
|
|
/// Returns the adder method.
|
|
inline const MethodInfo *getAddMethod() const
|
|
{
|
|
return addm_;
|
|
}
|
|
|
|
/// Returns whether the property's value can be retrieved.
|
|
inline bool canGet() const
|
|
{
|
|
return (getm_ != 0) || isDefined<CustomPropertyGetAttribute>(false);
|
|
}
|
|
|
|
/// Returns whether the property's value can be set.
|
|
inline bool canSet() const
|
|
{
|
|
return setm_ != 0 || isDefined<CustomPropertySetAttribute>(false);
|
|
}
|
|
|
|
/// Returns whether the property's array of values can be counted.
|
|
inline bool canCount() const
|
|
{
|
|
return numm_ != 0 || isDefined<CustomPropertyCountAttribute>(false);
|
|
}
|
|
|
|
/// Returns whether items can be added to the array property.
|
|
inline bool canAdd() const
|
|
{
|
|
return addm_ != 0 || isDefined<CustomPropertyAddAttribute>(false);
|
|
}
|
|
|
|
/// Returns whether the property is simple.
|
|
inline bool isSimple() const
|
|
{
|
|
return !isIndexed() && !isArray();
|
|
}
|
|
|
|
/// Returns whether the property is indexed.
|
|
inline bool isIndexed() const
|
|
{
|
|
return getNumIndices() > 0;
|
|
}
|
|
|
|
/// Returns whether the property is an array.
|
|
inline bool isArray() const
|
|
{
|
|
return is_array_;
|
|
}
|
|
|
|
/// Returns the list of index parameters.
|
|
/// If the property is not indexed, this list is empty. If neither
|
|
/// the get method nor the set method are defined, this list is
|
|
/// empty unless a custom indexing attribute is defined.
|
|
const ParameterInfoList &getIndexParameters() const;
|
|
|
|
/// Returns a list of valid values that can be used for the specified
|
|
/// index. If a custom indexing attribute is defined for this property,
|
|
/// then it will be queried for the index set, otherwise the index
|
|
/// will be treated as an enumeration and the set of enumeration
|
|
/// values will be returned.
|
|
void getIndexValueSet(int whichindex, const Value &instance, ValueList &values) const;
|
|
|
|
/// Invokes the getter method on the given instance and
|
|
/// returns the property's value. If a custom getter attribute
|
|
/// is defined, it will be invoked instead.
|
|
Value getValue(const Value &instance) const;
|
|
|
|
/// Invokes the setter method on the given instance and
|
|
/// sets the property's value. If a custom setter attribute
|
|
/// is defined, it will be invoked instead.
|
|
void setValue(Value &instance, const Value &value) const;
|
|
|
|
/// Invokes the getter method on the given instance passing a list
|
|
/// of indices and returns the indexed property's value. If a custom
|
|
/// getter attribute is defined, it will be invoked instead.
|
|
Value getIndexedValue(const Value &instance, ValueList &indices) const;
|
|
|
|
/// Invokes the setter method on the given instance passing a list
|
|
/// of indices and sets the indexed property's value. If a custom
|
|
/// setter attribute is defined, it will be invoked instead.
|
|
void setIndexedValue(Value &instance, ValueList &indices, const Value &value) const;
|
|
|
|
/// Invokes the counter method on the given instance and returns
|
|
/// the number of items of the array property. If a custom counter
|
|
/// attribute is defined, it will be invoked instead.
|
|
int getNumArrayItems(const Value &instance) const;
|
|
|
|
/// Invokes the getter method on the given instance and returns
|
|
/// the i-th item of the array property. If a custom getter attribute
|
|
/// us defined, it will be invoked instead.
|
|
Value getArrayItem(const Value &instance, int i) const;
|
|
|
|
/// Invokes the setter method on the given instance and sets
|
|
/// the i-th item of the array property. If a custom setter attribute
|
|
/// is defined, it will be invoked instead.
|
|
void setArrayItem(Value &instance, int i, const Value &value) const;
|
|
|
|
/// Invokes the adder method on the given instance and adds
|
|
/// an item to the array property. If a custom adder attribute is
|
|
/// defined, it will be invoked instead.
|
|
void addArrayItem(Value &instance, const Value &value) const;
|
|
|
|
/// Returns the default value associated to the reflected property.
|
|
/// If no default value has been specified, this method tries to
|
|
/// create an instance of the property type and then returns its
|
|
/// value. There are some attributes that change the behavior of
|
|
/// this method, for example NoDefaultValueAttribute.
|
|
Value getDefaultValue() const;
|
|
|
|
protected:
|
|
virtual void getInheritedProviders(CustomAttributeProviderList &providers) const;
|
|
|
|
private:
|
|
const Type &decltype_;
|
|
const Type &ptype_;
|
|
std::string name_;
|
|
const MethodInfo *getm_;
|
|
const MethodInfo *setm_;
|
|
const MethodInfo *numm_;
|
|
const MethodInfo *addm_;
|
|
ParameterInfoList indices_;
|
|
bool is_array_;
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|