resourceholder.h

Go to the documentation of this file.

#ifndef ION_GFX_RESOURCEHOLDER_H_
#define ION_GFX_RESOURCEHOLDER_H_

#include <cstring>  // For NULL.
#include <vector>

#include "base/macros.h"
#include "ion/base/invalid.h"
#include "ion/base/lockguards.h"
#include "ion/base/logging.h"
#include "ion/base/notifier.h"
#include "ion/base/readwritelock.h"
#include "ion/base/stlalloc/allocunorderedmap.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/gfx/resourcebase.h"
#include "ion/port/atomic.h"

namespace ion {
namespace gfx {

class ION_API ResourceHolder : public base::Notifier {
 public:
  enum BaseChanges {
    kLabelChanged,
    kResourceChanged,
    kNumBaseChanges
  };

  void SetResource(size_t index, ResourceKey key, ResourceBase* resource) const;

  ResourceBase* GetResource(size_t index, ResourceKey key) const;

  int GetResourceCount() const {
    return resource_count_;
  }

  size_t GetGpuMemoryUsed() const {
    base::ReadLock read_lock(&lock_);
    base::ReadGuard guard(&read_lock);
    size_t total = 0U;
    for (const auto& group : resources_)
      for (const auto& entry : group)
        total += entry.second->GetGpuMemoryUsed();
    return total;
  }

  const std::string& GetLabel() const { return label_.Get(); }
  void SetLabel(const std::string& label) { label_.Set(label); }

  using Notifier::Notify;

 protected:
  class FieldBase {
   public:
    virtual ~FieldBase();

    int GetBit() const { return change_bit_; }

   protected:
    FieldBase(const int change_bit, ResourceHolder* holder)
        : change_bit_(change_bit),
          holder_(holder) {
      if (holder != NULL)
        holder->AddField(this);
    }

    void OnChanged() {
      if (holder_) {
        holder_->OnChanged(change_bit_);
        holder_->Notify();
      }
    }

    void OnChanged(const int bit) {
      if (holder_) {
        holder_->OnChanged(bit);
        holder_->Notify();
      }
    }

   private:
    int change_bit_;
    const ResourceHolder* holder_;

    DISALLOW_IMPLICIT_CONSTRUCTORS(FieldBase);
  };

  template <typename T>
  class Field : public FieldBase {
   public:
    Field(const int change_bit, const T& initial_value, ResourceHolder* holder)
        : FieldBase(change_bit, holder),
          value_(initial_value) {}

    Field(const Field& other)
        : FieldBase(other),
          value_(other.value_) {}

    ~Field() override {}

    virtual bool IsValid(const T& value) {
      return true;
    }

    const T& Get() const { return value_; }

    T* GetMutable() {
      OnChanged();
      return &value_;
    }

    bool Set(const T& value) {
      if (!IsValid(value)) {
        LOG(ERROR) << "***ION: invalid value passed to Field::Set()";
      } else if (value != value_) {
        value_ = value;
        OnChanged();
        return true;
      }
      return false;
    }

   private:
    T value_;
  };

  template <typename T>
  class RangedField : public Field<T> {
   public:
    RangedField(const int change_bit, const T& initial_value,
                const T& min_value, const T& max_value,
                ResourceHolder* holder)
        : Field<T>(change_bit, initial_value, holder),
          min_value_(min_value),
          max_value_(max_value) {
    }

    ~RangedField() override {}

    bool IsValid(const T& value) override {
      return value >= min_value_ && value <= max_value_;
    }

   private:
    const T min_value_;
    const T max_value_;

    DISALLOW_IMPLICIT_CONSTRUCTORS(RangedField);
  };

  template <typename T>
  class VectorField : public FieldBase {
   public:
    VectorField(const int change_bit_start, const size_t max_entries,
                ResourceHolder* holder)
        : FieldBase(change_bit_start, holder),
          max_entries_(max_entries),
          entries_(*holder) {
      DCHECK(holder != NULL);
      holder->AddField(this);
    }

    ~VectorField() override {}

    void Add(const T& value) {
      if (entries_.size() >= max_entries_) {
        LOG(ERROR) << "***ION: Too many entries added to VectorField"
                   << "with " << entries_.size() << " entries";
      } else {
        entries_.push_back(
            Entry(GetBit() + static_cast<int>(entries_.size()), value));
        OnChanged(entries_.back().bit);
      }
    }

    void Remove(size_t i) {
      if (i < entries_.size()) {
        entries_[i].value = entries_.back().value;
        entries_.resize(entries_.size() - 1U);
        if (!entries_.empty())
          OnChanged(entries_[i].bit);
      }
    }

    const T& Get(const size_t i) const {
      if (i < entries_.size()) {
        return entries_[i].value;
      } else {
        LogIndexError(i);
        return base::InvalidReference<T>();
      }
    }

    T* GetMutable(const size_t i) {
      if (i < entries_.size()) {
        OnChanged(entries_[i].bit);
        return &entries_[i].value;
      } else {
        LogIndexError(i);
        return NULL;
      }
    }

    bool Set(const size_t i, const T& value) {
      if (i < entries_.size()) {
        if (value != entries_[i].value) {
          entries_[i].value = value;
          OnChanged(entries_[i].bit);
          return true;
        }
      } else {
        LogIndexError(i);
      }
      return false;
    }

    size_t GetCount() const { return entries_.size(); }

   private:
    struct Entry {
      Entry() : bit(-1) {}
      Entry(int bit_in, const T& value_in)
          : bit(bit_in),
            value(value_in) {}
      int bit;
      T value;
    };

    void LogIndexError(const size_t i) const {
      LOG(ERROR) << "***ION: Invalid index " << i << " passed to VectorField "
                 << "with " << entries_.size() << " entries";
    }

    size_t max_entries_;
    base::AllocVector<Entry> entries_;

    DISALLOW_IMPLICIT_CONSTRUCTORS(VectorField);
  };

  ResourceHolder();

  ~ResourceHolder() override;

  void OnChanged(int bit) const {
    base::ReadLock read_lock(&lock_);
    base::ReadGuard guard(&read_lock);
    for (const auto& group : resources_)
      for (const auto& entry : group)
        entry.second->OnChanged(bit);
  }

 private:
  friend class FieldBase;
  friend class Renderer;

  void AddField(FieldBase* field) { fields_.push_back(field); }

  typedef base::AllocUnorderedMap<ResourceKey, ResourceBase*> ResourceGroup;

  mutable base::InlinedAllocVector<ResourceGroup, 1> resources_;
  mutable base::ReadWriteLock lock_;
  mutable std::atomic<int> resource_count_;

  base::AllocVector<FieldBase*> fields_;

  Field<std::string> label_;
};

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_RESOURCEHOLDER_H_