src/apps/debugger/target_host_interface/TargetHostInterfaceRoster.cpp

   1 /*
   2  * Copyright 2016, Rene Gollent, rene@gollent.com.
   3  * Distributed under the terms of the MIT License.
   4  */
   5 #include "TargetHostInterfaceRoster.h"
   6
   7 #include <new>
   8
   9 #include <AutoDeleter.h>
  10 #include <AutoLocker.h>
  11
  12 #include "LocalTargetHostInterfaceInfo.h"
  13 #include "TargetHostInterface.h"
  14 #include "TargetHostInterfaceInfo.h"
  15
  16
  17 /*static*/ TargetHostInterfaceRoster*
  18         TargetHostInterfaceRoster::sDefaultInstance = NULL;
  19
  20
  21 TargetHostInterfaceRoster::TargetHostInterfaceRoster()
  22         :
  23         fLock(),
  24         fInterfaceInfos(20, false),
  25         fActiveInterfaces(20, false)
  26 {
  27 }
  28
  29
  30 TargetHostInterfaceRoster::~TargetHostInterfaceRoster()
  31 {
  32 }
  33
  34
  35 /*static*/ TargetHostInterfaceRoster*
  36 TargetHostInterfaceRoster::Default()
  37 {
  38         return sDefaultInstance;
  39 }
  40
  41
  42 /*static*/ status_t
  43 TargetHostInterfaceRoster::CreateDefault()
  44 {
  45         if (sDefaultInstance != NULL)
  46                 return B_OK;
  47
  48         TargetHostInterfaceRoster* roster
  49                 = new(std::nothrow) TargetHostInterfaceRoster;
  50         if (roster == NULL)
  51                 return B_NO_MEMORY;
  52         ObjectDeleter<TargetHostInterfaceRoster> rosterDeleter(roster);
  53
  54         status_t error = roster->Init();
  55         if (error != B_OK)
  56                 return error;
  57
  58         error = roster->RegisterInterfaceInfos();
  59         if (error != B_OK)
  60                 return error;
  61
  62         sDefaultInstance = rosterDeleter.Detach();
  63         return B_OK;
  64 }
  65
  66
  67 /*static*/ void
  68 TargetHostInterfaceRoster::DeleteDefault()
  69 {
  70         TargetHostInterfaceRoster* roster = sDefaultInstance;
  71         sDefaultInstance = NULL;
  72         delete roster;
  73 }
  74
  75
  76 status_t
  77 TargetHostInterfaceRoster::Init()
  78 {
  79         return fLock.InitCheck();
  80 }
  81
  82
  83 status_t
  84 TargetHostInterfaceRoster::RegisterInterfaceInfos()
  85 {
  86         TargetHostInterfaceInfo* info = NULL;
  87         BReference<TargetHostInterfaceInfo> interfaceReference;
  88
  89         #undef REGISTER_INTERFACE_INFO
  90         #define REGISTER_INTERFACE_INFO(type) \
  91                 info = new(std::nothrow) type##TargetHostInterfaceInfo; \
  92                 if (info == NULL) \
  93                         return B_NO_MEMORY; \
  94                 interfaceReference.SetTo(info, true); \
  95                 if (!fInterfaceInfos.AddItem(info)) \
  96                         return B_NO_MEMORY; \
  97                 interfaceReference.Detach();
  98
  99         REGISTER_INTERFACE_INFO(Local)
 100
 101         return B_OK;
 102 }
 103
 104
 105 int32
 106 TargetHostInterfaceRoster::CountInterfaceInfos() const
 107 {
 108         return fInterfaceInfos.CountItems();
 109 }
 110
 111
 112 TargetHostInterfaceInfo*
 113 TargetHostInterfaceRoster::InterfaceInfoAt(int32 index) const
 114 {
 115         return fInterfaceInfos.ItemAt(index);
 116 }
 117
 118
 119 status_t
 120 TargetHostInterfaceRoster::CreateInterface(TargetHostInterfaceInfo* info,
 121         Settings* settings, TargetHostInterface*& _interface)
 122 {
 123         // TODO: this should eventually verify that an active interface with
 124         // matching settings/type doesn't already exist, and if so, return that
 125         // directly rather than instantiating a new one, since i.e. the interface
 126         // for the local host only requires one instance.
 127         AutoLocker<TargetHostInterfaceRoster> locker(this);
 128         TargetHostInterface* interface;
 129         status_t error = info->CreateInterface(settings, interface);
 130         if (error != B_OK)
 131                 return error;
 132
 133         error = interface->Run();
 134         if (error < B_OK || !fActiveInterfaces.AddItem(interface)) {
 135                 delete interface;
 136                 return B_NO_MEMORY;
 137         }
 138
 139         _interface = interface;
 140         return B_OK;
 141 }
 142
 143
 144 int32
 145 TargetHostInterfaceRoster::CountActiveInterfaces() const
 146 {
 147         return fActiveInterfaces.CountItems();
 148 }
 149
 150
 151 TargetHostInterface*
 152 TargetHostInterfaceRoster::ActiveInterfaceAt(int32 index) const
 153 {
 154         return fActiveInterfaces.ItemAt(index);
 155 }
 156
 157
 158 int32
 159 TargetHostInterfaceRoster::CountRunningTeamDebuggers() const
 160 {
 161         int32 total = 0;
 162         for (int32 i = 0; TargetHostInterface* interface = ActiveInterfaceAt(i);
 163                 i++) {
 164                 total += interface->CountTeamDebuggers();
 165         }
 166
 167         return total;
 168 }