src/kits/debugger/value/TypeHandlerRoster.cpp

   1 /*
   2  * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "TypeHandlerRoster.h"
   8
   9 #include <new>
  10
  11 #include <AutoDeleter.h>
  12 #include <AutoLocker.h>
  13
  14 #include "AddressValueNode.h"
  15 #include "ArrayValueNode.h"
  16 #include "CompoundValueNode.h"
  17 #include "BListTypeHandler.h"
  18 #include "BMessageTypeHandler.h"
  19 #include "CStringTypeHandler.h"
  20 #include "EnumerationValueNode.h"
  21 #include "PointerToMemberValueNode.h"
  22 #include "PrimitiveValueNode.h"
  23 #include "Type.h"
  24 #include "TypeHandler.h"
  25
  26
  27 // #pragma mark - BasicTypeHandler
  28
  29
  30 namespace {
  31
  32
  33 template<typename TypeClass, typename NodeClass>
  34 class BasicTypeHandler : public TypeHandler {
  35 public:
  36         virtual float SupportsType(Type* type)
  37         {
  38                 return dynamic_cast<TypeClass*>(type) != NULL ? 0.5f : 0;
  39         }
  40
  41         virtual status_t CreateValueNode(ValueNodeChild* nodeChild,
  42                 Type* type, ValueNode*& _node)
  43         {
  44                 TypeClass* supportedType = dynamic_cast<TypeClass*>(type);
  45                 if (supportedType == NULL)
  46                         return B_BAD_VALUE;
  47
  48                 ValueNode* node = new(std::nothrow) NodeClass(nodeChild, supportedType);
  49                 if (node == NULL)
  50                         return B_NO_MEMORY;
  51
  52                 _node = node;
  53                 return B_OK;
  54         }
  55 };
  56
  57
  58 }       // unnamed namespace
  59
  60
  61 // #pragma mark - TypeHandlerRoster
  62
  63
  64 /*static*/ TypeHandlerRoster* TypeHandlerRoster::sDefaultInstance = NULL;
  65
  66
  67 TypeHandlerRoster::TypeHandlerRoster()
  68         :
  69         fLock("type handler roster")
  70 {
  71 }
  72
  73
  74 TypeHandlerRoster::~TypeHandlerRoster()
  75 {
  76 }
  77
  78 /*static*/ TypeHandlerRoster*
  79 TypeHandlerRoster::Default()
  80 {
  81         return sDefaultInstance;
  82 }
  83
  84
  85 /*static*/ status_t
  86 TypeHandlerRoster::CreateDefault()
  87 {
  88         if (sDefaultInstance != NULL)
  89                 return B_OK;
  90
  91         TypeHandlerRoster* roster = new(std::nothrow) TypeHandlerRoster;
  92         if (roster == NULL)
  93                 return B_NO_MEMORY;
  94         ObjectDeleter<TypeHandlerRoster> rosterDeleter(roster);
  95
  96         status_t error = roster->Init();
  97         if (error != B_OK)
  98                 return error;
  99
 100         error = roster->RegisterDefaultHandlers();
 101         if (error != B_OK)
 102                 return error;
 103
 104         sDefaultInstance = rosterDeleter.Detach();
 105         return B_OK;
 106 }
 107
 108
 109 /*static*/ void
 110 TypeHandlerRoster::DeleteDefault()
 111 {
 112         TypeHandlerRoster* roster = sDefaultInstance;
 113         sDefaultInstance = NULL;
 114         delete roster;
 115 }
 116
 117
 118 status_t
 119 TypeHandlerRoster::Init()
 120 {
 121         return fLock.InitCheck();
 122 }
 123
 124
 125 status_t
 126 TypeHandlerRoster::RegisterDefaultHandlers()
 127 {
 128         TypeHandler* handler;
 129         BReference<TypeHandler> handlerReference;
 130
 131         #undef REGISTER_BASIC_HANDLER
 132         #define REGISTER_BASIC_HANDLER(name)                                            \
 133                 handler = new(std::nothrow)                                                             \
 134                         BasicTypeHandler<name##Type, name##ValueNode>();        \
 135                 handlerReference.SetTo(handler, true);                                  \
 136                 if (handler == NULL || !RegisterHandler(handler))               \
 137                         return B_NO_MEMORY;
 138
 139         REGISTER_BASIC_HANDLER(Address);
 140         REGISTER_BASIC_HANDLER(Array);
 141         REGISTER_BASIC_HANDLER(Compound);
 142         REGISTER_BASIC_HANDLER(Enumeration);
 143         REGISTER_BASIC_HANDLER(PointerToMember);
 144         REGISTER_BASIC_HANDLER(Primitive);
 145
 146         #undef REGISTER_SPECIALIZED_HANDLER
 147         #define REGISTER_SPECIALIZED_HANDLER(name)                                      \
 148                 handler = new(std::nothrow)                                                             \
 149                         name##TypeHandler();                                                            \
 150                 handlerReference.SetTo(handler, true);                                  \
 151                 if (handler == NULL || !RegisterHandler(handler))               \
 152                         return B_NO_MEMORY;
 153
 154         REGISTER_SPECIALIZED_HANDLER(CString);
 155         REGISTER_SPECIALIZED_HANDLER(BMessage);
 156         REGISTER_SPECIALIZED_HANDLER(BList);
 157
 158         return B_OK;
 159 }
 160
 161
 162 status_t
 163 TypeHandlerRoster::FindTypeHandler(ValueNodeChild* nodeChild, Type* type,
 164         TypeHandler*& _handler)
 165 {
 166         // find the best-supporting handler
 167         AutoLocker<BLocker> locker(fLock);
 168
 169         TypeHandler* bestHandler = NULL;
 170         float bestSupport = 0;
 171
 172         for (int32 i = 0; TypeHandler* handler = fTypeHandlers.ItemAt(i); i++) {
 173                 float support = handler->SupportsType(type);
 174                 if (support > 0 && support > bestSupport) {
 175                         bestHandler = handler;
 176                         bestSupport = support;
 177                 }
 178         }
 179
 180         if (bestHandler == NULL)
 181                 return B_ENTRY_NOT_FOUND;
 182
 183         bestHandler->AcquireReference();
 184         _handler = bestHandler;
 185         return B_OK;
 186 }
 187
 188
 189 status_t
 190 TypeHandlerRoster::CreateValueNode(ValueNodeChild* nodeChild, Type* type,
 191         ValueNode*& _node)
 192 {
 193         // find the best-supporting handler
 194         while (true) {
 195                 TypeHandler* handler;
 196                 status_t error = FindTypeHandler(nodeChild, type, handler);
 197                 if (error == B_OK) {
 198                         // let the handler create the node
 199                         BReference<TypeHandler> handlerReference(handler, true);
 200                         return handler->CreateValueNode(nodeChild, type, _node);
 201                 }
 202
 203                 // not found yet -- try to strip a modifier/typedef from the type
 204                 Type* nextType = type->ResolveRawType(true);
 205                 if (nextType == NULL || nextType == type)
 206                         return B_UNSUPPORTED;
 207
 208                 type = nextType;
 209         }
 210 }
 211
 212
 213 bool
 214 TypeHandlerRoster::RegisterHandler(TypeHandler* handler)
 215 {
 216         if (!fTypeHandlers.AddItem(handler))
 217                 return false;
 218
 219         handler->AcquireReference();
 220         return true;
 221 }
 222
 223
 224 void
 225 TypeHandlerRoster::UnregisterHandler(TypeHandler* handler)
 226 {
 227         if (fTypeHandlers.RemoveItem(handler))
 228                 handler->ReleaseReference();
 229 }