mirror of
https://review.haiku-os.org/haiku
synced 2025-02-12 00:28:19 +01:00
59ea286fac
* Since some types don't have names (e.g. pointer types or anonymous structs or
unions), each type does now also have a unique ID. The global type cache
registers types by ID and by name (if they have one). This fixes clashes of
types with empty names.
* Completely refactored the code dealing with variable values. Formerly we had
Variable and TypeComponentPath to navigate to a component, mapped to a
BVariant representing the value. Now we have:
* Interface Value with various subclasses (BoolValue, IntegerValue, etc.) to
represent a value, with the flexibility for more esoteric values.
* A tree of ValueNode+ValueNodeChild objects to represent the components of a
variable. On top of each ValueNodeChild sits a ValueNode representing the
value of the component, potentially having ValueNodeChild children. This
should allow casting a component value, simply by replacing its ValueNode.
* Interface ValueHandler and various implementations for the different value
types. It is basically a factory for classes allowing to format/display a
value.
* ValueHandlerRoster -- a registry for ValueHandlers, finding the best one
for a given value.
* Interface TypeHandler and various implementions for the different type
kinds (primitive, compound, address, etc.). It is basically a factory for
ValueNodes for that type.
* TypeHandlerRoster -- a registry for TypeHandlers, finding the best one
for a given type.
That's still a bit work in progress. It introduces at least one regression:
The VariablesView doesn't save/restore its state anymore. Will take a while
until that is added back.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33907 a95241bf-73f2-0310-859d-f6bbb57e9c96
76 lines
1.8 KiB
C++
76 lines
1.8 KiB
C++
/*
|
|
* Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
|
|
* Distributed under the terms of the MIT License.
|
|
*/
|
|
#ifndef VALUE_NODE_CONTAINER_H
|
|
#define VALUE_NODE_CONTAINER_H
|
|
|
|
|
|
#include <Locker.h>
|
|
|
|
#include <ObjectList.h>
|
|
#include <Referenceable.h>
|
|
|
|
|
|
class ValueNode;
|
|
class ValueNodeChild;
|
|
|
|
|
|
class ValueNodeContainer : public BReferenceable {
|
|
public:
|
|
class Listener;
|
|
|
|
public:
|
|
ValueNodeContainer();
|
|
virtual ~ValueNodeContainer();
|
|
|
|
status_t Init();
|
|
|
|
inline bool Lock() { return fLock.Lock(); }
|
|
inline void Unlock() { fLock.Unlock(); }
|
|
|
|
int32 CountChildren() const;
|
|
ValueNodeChild* ChildAt(int32 index) const;
|
|
bool AddChild(ValueNodeChild* child);
|
|
void RemoveChild(ValueNodeChild* child);
|
|
void RemoveAllChildren();
|
|
|
|
bool AddListener(Listener* listener);
|
|
void RemoveListener(Listener* listener);
|
|
|
|
// container must be locked
|
|
|
|
void NotifyValueNodeChanged(
|
|
ValueNodeChild* nodeChild,
|
|
ValueNode* oldNode, ValueNode* newNode);
|
|
void NotifyValueNodeChildrenCreated(ValueNode* node);
|
|
void NotifyValueNodeChildrenDeleted(ValueNode* node);
|
|
void NotifyValueNodeValueChanged(ValueNode* node);
|
|
|
|
private:
|
|
typedef BObjectList<ValueNodeChild> NodeChildList;
|
|
typedef BObjectList<Listener> ListenerList;
|
|
|
|
private:
|
|
BLocker fLock;
|
|
NodeChildList fChildren;
|
|
ListenerList fListeners;
|
|
};
|
|
|
|
|
|
class ValueNodeContainer::Listener {
|
|
public:
|
|
virtual ~Listener();
|
|
|
|
// container is locked
|
|
|
|
virtual void ValueNodeChanged(ValueNodeChild* nodeChild,
|
|
ValueNode* oldNode, ValueNode* newNode);
|
|
virtual void ValueNodeChildrenCreated(ValueNode* node);
|
|
virtual void ValueNodeChildrenDeleted(ValueNode* node);
|
|
virtual void ValueNodeValueChanged(ValueNode* node);
|
|
};
|
|
|
|
|
|
#endif // VALUE_NODE_CONTAINER_H
|