generic_handler.hxx

// dawn/include/dawn/common/generic_handler.hxx
//
// SPDX-License-Identifier: Apache-2.0
//
 
#pragma once
 
#include <errno.h>
 
#include <algorithm>
#include <vector>
 
#include "dawn/common/descriptor.hxx"
#include "dawn/common/handler.hxx"
#include "dawn/common/objectid.hxx"
#include "dawn/debug.hxx"
 
namespace dawn
{
template<typename T>
class CGenericHandler : public CHandler
{
protected:
  std::vector<T *> objects;
  int allocError = OK;
 
  int registerObject(T *obj)
  {
    DAWNASSERT(obj != nullptr, "invalid input");
    for (const T *tmp : objects)
      {
        if (tmp->getIdV() == obj->getIdV())
          {
            DAWNERR("Duplicate object ID 0x%" PRIx32 "\n", obj->getIdV());
            delete obj;
            allocError = -EEXIST;
            return allocError;
          }
      }
    objects.push_back(obj);
    return OK;
  }
 
  virtual void onInitObject(T *obj)
  {
  }
 
  virtual void onStartObject(T *obj)
  {
  }
 
  virtual const char *getObjectTypeName() const
  {
    return "OBJECT";
  }
 
public:
  ~CGenericHandler()
  {
#ifdef CONFIG_DAWN_LIFECYCLE_TEARDOWN
    for (auto it = objects.rbegin(); it != objects.rend(); ++it)
      {
        T *obj = *it;
        DAWNINFO("STOP %s 0x%" PRIx32 "\n", getObjectTypeName(), obj->getIdV());
        obj->stop();
      }
 
    for (T *obj : objects)
      {
        DAWNINFO("delete 0x%" PRIx32 "\n", obj->getIdV());
        delete obj;
      }
 
    objects.clear();
#endif
  }
 
  int configureAll()
  {
    int ret;
 
    for (T *obj : objects)
      {
        DAWNINFO("CONFIG %s 0x%" PRIx32 "\n", getObjectTypeName(), obj->getIdV());
        ret = obj->configure();
        if (ret != OK)
          {
            DAWNERR("Failed to configure %s 0x%" PRIx32 " (error %d)\n",
                    getObjectTypeName(),
                    obj->getIdV(),
                    ret);
            return ret;
          }
      }
 
    return OK;
  }
 
  int initAll()
  {
    int ret;
 
    for (T *obj : objects)
      {
        DAWNINFO("INIT %s 0x%" PRIx32 "\n", getObjectTypeName(), obj->getIdV());
        ret = obj->init();
        if (ret != OK)
          {
            DAWNERR("Failed to init %s 0x%" PRIx32 " (error %d)\n",
                    getObjectTypeName(),
                    obj->getIdV(),
                    ret);
            return ret;
          }
        onInitObject(obj);
      }
 
    return OK;
  }
 
  int deinitAll()
  {
#ifdef CONFIG_DAWN_LIFECYCLE_TEARDOWN
    int ret;
    int tmp;
 
    ret = OK;
    for (auto it = objects.rbegin(); it != objects.rend(); ++it)
      {
        T *obj = *it;
        DAWNINFO("DEINIT %s 0x%" PRIx32 "\n", getObjectTypeName(), obj->getIdV());
        tmp = obj->deinit();
        if (tmp != OK)
          {
            DAWNERR("Failed to deinit %s 0x%" PRIx32 " (error %d)\n",
                    getObjectTypeName(),
                    obj->getIdV(),
                    tmp);
            if (ret == OK)
              {
                ret = tmp;
              }
          }
      }
 
    for (T *obj : objects)
      {
        DAWNINFO("delete %s 0x%" PRIx32 "\n", getObjectTypeName(), obj->getIdV());
        delete obj;
      }
 
    objects.clear();
 
    return ret;
#else
    return OK;
#endif
  }
 
  int startAll()
  {
    int ret;
 
    for (T *obj : objects)
      {
        onStartObject(obj);
        DAWNINFO("START %s 0x%" PRIx32 "\n", getObjectTypeName(), obj->getIdV());
        ret = obj->start();
        if (ret != OK)
          {
            DAWNERR("Failed to start %s 0x%" PRIx32 " (error %d)\n",
                    getObjectTypeName(),
                    obj->getIdV(),
                    ret);
            return ret;
          }
      }
 
    return OK;
  }
 
  int stopAll()
  {
#ifdef CONFIG_DAWN_LIFECYCLE_TEARDOWN
    int ret;
 
    for (auto it = objects.rbegin(); it != objects.rend(); ++it)
      {
        T *obj = *it;
        DAWNINFO("STOP %s 0x%" PRIx32 "\n", getObjectTypeName(), obj->getIdV());
        ret = obj->stop();
        if (ret != OK)
          {
            DAWNERR("Failed to stop %s 0x%" PRIx32 " (error %d)\n",
                    getObjectTypeName(),
                    obj->getIdV(),
                    ret);
            return ret;
          }
      }
 
    return OK;
#else
    return OK;
#endif
  }
 
  bool hasThread() const
  {
    return std::any_of(
      objects.begin(), objects.end(), [](const T *obj) { return obj->hasThread(); });
  }
 
  size_t getObjectCount() const
  {
    return objects.size();
  }
 
#ifdef CONFIG_DAWN_INSPECT
  const std::vector<T *> &getObjects() const
  {
    return objects;
  }
#endif // CONFIG_DAWN_INSPECT
 
  T *getObjectAt(size_t index) const
  {
    return (index < objects.size()) ? objects[index] : nullptr;
  }
 
  T *getObjectById(const SObjectId::UObjectId &id) const
  {
    auto it = std::find_if(
      objects.begin(), objects.end(), [&id](const T *obj) { return obj->getIdV() == id.v; });
    return (it != objects.end()) ? *it : nullptr;
  }
 
  int objalloc(CDescriptor &desc, CDescriptor::allocobj_func_t func)
  {
    allocError = OK;
    desc.alloc_objects(*this, func);
    return allocError;
  }
};
 
} // Namespace dawn