60 if( !aProperty.CmpNoCase( property->
Name() ) )
78 return it->second.m_allProperties;
92 return it->second.m_displayOrder;
106 return it->second.m_groupDisplayOrder;
112 if( aBase == aTarget )
115 auto classDesc =
m_classes.find( aBase );
120 const std::map<TYPE_ID, std::unique_ptr<TYPE_CAST_BASE>>& converters = classDesc->second.m_typeCasts;
121 auto converter = converters.find( aTarget );
123 if( converter == converters.end() )
124 return IsOfType( aBase, aTarget ) ? aSource :
nullptr;
126 return (*converter->second)( aSource );
132 const wxString&
name = aProperty->
Name();
141 if( !classDesc.
m_groups.count( aGroup ) )
144 classDesc.
m_groups.insert( aGroup );
153 const wxString& aGroup )
156 classDesc.
m_replaced.insert( std::make_pair( aBase, aName ) );
166 wxASSERT_MSG( classDesc.
m_typeCasts.count( derivedHash ) == 0, wxT(
"Such converter already exists" ) );
167 classDesc.
m_typeCasts.emplace( derivedHash, aCast );
173 wxASSERT_MSG( aDerived != aBase, wxT(
"Class cannot inherit from itself" ) );
180 wxT(
"You need to add a TYPE_CAST for classes inheriting from multiple bases" ) );
186 wxASSERT_MSG( aDerived != aBase, wxT(
"Class cannot mask from itself" ) );
197 wxASSERT_MSG( aDerived != aBase, wxT(
"Class cannot override from itself" ) );
208 wxASSERT_MSG( aDerived != aBase, wxT(
"Class cannot override from itself" ) );
226 return it->second( aItem );
242 return it->second( aItem );
250 if( aDerived == aBase )
253 auto derived =
m_classes.find( aDerived );
254 wxCHECK( derived !=
m_classes.end(),
false );
257 for(
const std::reference_wrapper<CLASS_DESC>& base : derived->second.m_bases )
259 if(
IsOfType( base.get().m_id, aBase ) )
269 for( std::pair<const TYPE_ID, CLASS_DESC>& classEntry :
m_classes )
270 classEntry.second.rebuild();
289 std::set<std::pair<size_t, wxString>> replaced;
290 std::set<std::pair<size_t, wxString>> masked;
297 std::vector<wxString> displayOrder;
298 std::set<wxString> groups;
301 [&]( std::set<wxString>& aSet, std::vector<wxString>& aResult )
303 auto collectGroupsRecursive =
304 [](
auto& aSelf, std::set<wxString>& aSetR, std::vector<wxString>& aResultR,
307 for(
const wxString&
group : aClassR.m_groupDisplayOrder )
309 if( !aSetR.count(
group ) )
311 aSetR.insert(
group );
312 aResultR.emplace_back(
group );
317 aSelf( aSelf, aSetR, aResultR, base );
320 collectGroupsRecursive( collectGroupsRecursive, aSet, aResult, *
this );
325 collectGroups( groups, displayOrder );
331 std::set<std::pair<size_t, wxString>>& aReplaced,
332 std::map<PROPERTY_BASE*, int>& aDisplayOrder,
333 std::set<std::pair<size_t, wxString>>& aMasked )
const
335 for(
const std::pair<size_t, wxString>& replacedEntry : m_replaced )
336 aReplaced.emplace( replacedEntry );
338 for(
const std::pair<size_t, wxString>& maskedEntry : m_maskedBaseProperties )
339 aMasked.emplace( maskedEntry );
345 int displayOrderStart = 0;
347 if( !aDisplayOrder.empty() )
349 int firstSoFar = std::min_element( aDisplayOrder.begin(), aDisplayOrder.end(),
350 [](
const std::pair<PROPERTY_BASE*, int>& aFirst,
351 const std::pair<PROPERTY_BASE*, int>& aSecond )
353 return aFirst.second < aSecond.second;
356 displayOrderStart = firstSoFar - m_ownProperties.size();
363 std::set<std::pair<size_t, wxString>>::key_type propertyKey = std::make_pair( property->OwnerHash(),
366 if( aReplaced.count( propertyKey ) )
370 if( aMasked.count( propertyKey ) )
373 aDisplayOrder[property] = displayOrderStart + idx++;
374 aResult.push_back( property );
378 for( std::reference_wrapper<CLASS_DESC> base : std::ranges::reverse_view( m_bases ) )
379 base.get().collectPropsRecur( aResult, aReplaced, aDisplayOrder, aMasked );
387 for( std::pair<const TYPE_ID, CLASS_DESC>& classEntry :
m_classes )
391 info.type = classEntry.first;
394 for(
PROPERTY_BASE* prop : classEntry.second.m_allProperties )
395 info.properties.push_back( prop );
397 rv.push_back(
info );
420 callListeners( objectClass.
m_id );
423 callListeners( superClass.
m_id );
430 return, wxT(
"Can't have more than one managed commit at a time!" ) );
439 wxT(
"Something went wrong: m_managedCommit already null!" ) );
Represent a set of changes (additions, deletions or modifications) of a data model (e....
Class that other classes need to inherit from, in order to be inspectable.
PROPERTY_BASE & SetGroup(const wxString &aGroup)
virtual size_t BaseHash() const =0
Return type-id of the Base class.
virtual bool Writeable(INSPECTABLE *aObject) const
bool Available(INSPECTABLE *aObject) const
Return true if aObject offers this PROPERTY.
const wxString & Name() const
virtual size_t OwnerHash() const =0
Return type-id of the Owner class.
~PROPERTY_COMMIT_HANDLER()
PROPERTY_COMMIT_HANDLER(COMMIT *aCommit)
Provide class metadata.Helper macro to map type hashes to names.
const std::vector< PROPERTY_BASE * > & GetProperties(TYPE_ID aType) const
Return all properties for a specific type.
bool m_dirty
Flag indicating that the list of properties needs to be rebuild (RebuildProperties())
CLASSES_INFO GetAllClasses()
std::vector< CLASS_INFO > CLASSES_INFO
void InheritsAfter(TYPE_ID aDerived, TYPE_ID aBase)
Declare an inheritance relationship between types.
bool IsWriteableFor(TYPE_ID aItemClass, PROPERTY_BASE *aProp, INSPECTABLE *aItem)
Checks overriden availability and original availability of a property, returns false if the property ...
void PropertyChanged(INSPECTABLE *aObject, PROPERTY_BASE *aProperty)
Callback to alert the notification system that a property has changed.
void Mask(TYPE_ID aDerived, TYPE_ID aBase, const wxString &aName)
Sets a base class property as masked in a derived class.
static PROPERTY_MANAGER & Instance()
PROPERTY_BASE & AddProperty(PROPERTY_BASE *aProperty, const wxString &aGroup=wxEmptyString)
Register a property.
void Rebuild()
Rebuild the list of all registered properties.
PROPERTY_BASE * GetProperty(TYPE_ID aType, const wxString &aProperty) const
Return a property for a specific type.
std::unordered_map< TYPE_ID, CLASS_DESC > m_classes
const void * TypeCast(const void *aSource, TYPE_ID aBase, TYPE_ID aTarget) const
Cast a type to another type.
CLASS_DESC & getClass(TYPE_ID aTypeId)
void RegisterType(TYPE_ID aType, const wxString &aName)
Associate a name with a type.
bool IsAvailableFor(TYPE_ID aItemClass, PROPERTY_BASE *aProp, INSPECTABLE *aItem)
Checks overriden availability and original availability of a property, returns false if the property ...
const std::map< PROPERTY_BASE *, int > & GetDisplayOrder(TYPE_ID aType) const
std::map< TYPE_ID, std::vector< PROPERTY_LISTENER > > m_listeners
void OverrideAvailability(TYPE_ID aDerived, TYPE_ID aBase, const wxString &aName, std::function< bool(INSPECTABLE *)> aFunc)
Sets an override availability functor for a base class property of a given derived class.
bool IsOfType(TYPE_ID aDerived, TYPE_ID aBase) const
Return true if aDerived is inherited from aBase.
PROPERTY_BASE & ReplaceProperty(size_t aBase, const wxString &aName, PROPERTY_BASE *aNew, const wxString &aGroup=wxEmptyString)
Replace an existing property for a specific type.
void OverrideWriteability(TYPE_ID aDerived, TYPE_ID aBase, const wxString &aName, std::function< bool(INSPECTABLE *)> aFunc)
Sets an override writeability functor for a base class property of a given derived class.
std::unordered_map< TYPE_ID, wxString > m_classNames
Map of all available types.
const std::vector< wxString > & GetGroupDisplayOrder(TYPE_ID aType) const
void AddTypeCast(TYPE_CAST_BASE *aCast)
Register a type converter.
virtual size_t BaseHash() const =0
virtual size_t DerivedHash() const =0
static const std::vector< PROPERTY_BASE * > EMPTY_PROP_LIST
static const std::map< PROPERTY_BASE *, int > EMPTY_PROP_DISPLAY_ORDER
std::vector< wxString > EMPTY_GROUP_DISPLAY_ORDER
std::function< void(INSPECTABLE *, PROPERTY_BASE *, COMMIT *)> PROPERTY_LISTENER
size_t TYPE_ID
Unique type identifier.
Returns metadata for a specific type.
std::vector< std::reference_wrapper< CLASS_DESC > > m_bases
Properties unique to this type (i.e. not inherited)
std::set< std::pair< size_t, wxString > > m_replaced
Recreates the list of properties.
std::vector< wxString > m_groupDisplayOrder
Non-owning list of classes's direct properties in display order.
std::map< std::pair< size_t, wxString >, std::function< bool(INSPECTABLE *)> > m_availabilityOverrides
Overrides for base class property writeable status.
std::map< std::pair< size_t, wxString >, std::function< bool(INSPECTABLE *)> > m_writeabilityOverrides
All properties (both unique to the type and inherited)
std::map< wxString, std::unique_ptr< PROPERTY_BASE > > m_ownProperties
Type converters available for this type.
std::vector< PROPERTY_BASE * > m_ownDisplayOrder
The property groups provided by this class.
std::set< std::pair< size_t, wxString > > m_maskedBaseProperties
Overrides for base class property availabilities.
std::map< PROPERTY_BASE *, int > m_displayOrder
List of property groups provided by this class in display order.
std::vector< PROPERTY_BASE * > m_allProperties
Compiled display order for all properties.
std::map< TYPE_ID, std::unique_ptr< TYPE_CAST_BASE > > m_typeCasts
Properties from bases that should be masked (hidden) on this subclass.
void collectPropsRecur(std::vector< PROPERTY_BASE * > &aResult, std::set< std::pair< size_t, wxString > > &aReplaced, std::map< PROPERTY_BASE *, int > &aDisplayOrder, std::set< std::pair< size_t, wxString > > &aMasked) const
void rebuild()
Traverses the class inheritance hierarchy bottom-to-top, gathering all properties available to a type...
const TYPE_ID m_id
Types after which this type inherits.
std::set< wxString > m_groups
Replaced properties (TYPE_ID / name)