headers/private/debugger/value/ValueNode.h

   1 /*
   2  * Copyright 2015, Rene Gollent, rene@gollent.com.
   3  * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
   4  * Distributed under the terms of the MIT License.
   5  */
   6 #ifndef VALUE_NODE_H
   7 #define VALUE_NODE_H
   8
   9
  10 #include <String.h>
  11
  12 #include <Referenceable.h>
  13
  14
  15 class TeamTypeInformation;
  16 class Type;
  17 class Value;
  18 class ValueLoader;
  19 class ValueLocation;
  20 class ValueNodeChild;
  21 class ValueNodeContainer;
  22
  23
  24 enum {
  25         VALUE_NODE_UNRESOLVED   = 1
  26 };
  27
  28
  29 class ValueNode : public BReferenceable {
  30 public:
  31                                                                 ValueNode(ValueNodeChild* nodeChild);
  32         virtual                                         ~ValueNode();
  33
  34                         ValueNodeChild*         NodeChild() const       { return fNodeChild; }
  35
  36         virtual const BString&          Name() const;
  37         virtual Type*                           GetType() const = 0;
  38
  39         virtual status_t                        ResolvedLocationAndValue(
  40                                                                         ValueLoader* valueLoader,
  41                                                                         ValueLocation*& _location,
  42                                                                         Value*& _value) = 0;
  43                                                                         // returns references, a NULL value can be
  44                                                                         // returned
  45
  46                         // locking required
  47
  48                         ValueNodeContainer*     Container() const
  49                                                                         { return fContainer; }
  50                         void                            SetContainer(ValueNodeContainer* container);
  51
  52                         virtual bool            ChildCreationNeedsValue() const
  53                                                                         { return false; }
  54                         bool                            ChildrenCreated() const
  55                                                                         { return fChildrenCreated; }
  56
  57         virtual status_t                        CreateChildren(TeamTypeInformation* info) = 0;
  58         virtual int32                           CountChildren() const = 0;
  59         virtual ValueNodeChild*         ChildAt(int32 index) const = 0;
  60
  61         // optional virtual hooks for container type value nodes such as
  62         // arrays that may contain a variable (and potentially quite large)
  63         // number of children. The calls below should be implemented for such
  64         // node types to allow the upper layers to be aware of this, and to be
  65         // able to request that only a subset of children be created.
  66         virtual bool                            IsRangedContainer() const;
  67         virtual bool                            IsContainerRangeFixed() const;
  68                                                                         // indicates that the user can't
  69                                                                         // arbitrarily go outside of the
  70                                                                         // specified/supported range.
  71         virtual void                            ClearChildren();
  72         virtual status_t                        CreateChildrenInRange(
  73                                                                         TeamTypeInformation* info,
  74                                                                         int32 lowIndex, int32 highIndex);
  75         virtual status_t                        SupportedChildRange(int32& lowIndex,
  76                                                                         int32& highIndex) const;
  77
  78                         status_t                        LocationAndValueResolutionState() const
  79                                                                         { return fLocationResolutionState; }
  80                         void                            SetLocationAndValue(ValueLocation* location,
  81                                                                         Value* value, status_t resolutionState);
  82                         ValueLocation*          Location() const        { return fLocation; }
  83                         Value*                          GetValue() const        { return fValue; }
  84                                                                         // immutable after SetLocationAndValue()
  85
  86 protected:
  87                         ValueNodeContainer*     fContainer;
  88                         ValueNodeChild*         fNodeChild;
  89                         ValueLocation*          fLocation;
  90                         Value*                          fValue;
  91                         status_t                        fLocationResolutionState;
  92                         bool                            fChildrenCreated;
  93 };
  94
  95
  96 class ValueNodeChild : public BReferenceable {
  97 public:
  98                                                                 ValueNodeChild();
  99         virtual                                         ~ValueNodeChild();
 100
 101         virtual const BString&          Name() const = 0;
 102         virtual Type*                           GetType() const = 0;
 103         virtual ValueNode*                      Parent() const = 0;
 104
 105         virtual bool                            IsInternal() const;
 106         virtual status_t                        CreateInternalNode(ValueNode*& _node);
 107
 108         virtual status_t                        ResolveLocation(ValueLoader* valueLoader,
 109                                                                         ValueLocation*& _location) = 0;
 110                                                                         // returns a reference
 111
 112                         // locking required
 113
 114                         ValueNodeContainer*     Container() const
 115                                                                         { return fContainer; }
 116                         void                            SetContainer(ValueNodeContainer* container);
 117
 118                         ValueNode*                      Node() const    { return fNode; }
 119                         void                            SetNode(ValueNode* node);
 120
 121                         status_t                        LocationResolutionState() const
 122                                                                         { return fLocationResolutionState; }
 123                         ValueLocation*          Location() const;
 124                                                                         // immutable after SetLocation()
 125                         void                            SetLocation(ValueLocation* location,
 126                                                                         status_t resolutionState);
 127
 128 protected:
 129                         ValueNodeContainer*     fContainer;
 130                         ValueNode*                      fNode;
 131                         ValueLocation*          fLocation;
 132                         status_t                        fLocationResolutionState;
 133 };
 134
 135
 136 class ChildlessValueNode : public ValueNode {
 137 public:
 138                                                                 ChildlessValueNode(ValueNodeChild* nodeChild);
 139
 140         virtual status_t                        CreateChildren(TeamTypeInformation* info);
 141         virtual int32                           CountChildren() const;
 142         virtual ValueNodeChild*         ChildAt(int32 index) const;
 143 };
 144
 145
 146 #endif  // VALUE_NODE_H