CreditSystem.h

#pragma once
 
#include <CesiumUtility/Library.h>
 
#include <cstdint>
#include <limits>
#include <memory>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace CesiumUtility {
 
class CreditSystem;

enum class CreditFilteringMode : uint8_t {
  None = 0,

  UniqueHtmlAndShowOnScreen = 1,

  UniqueHtml = 2
};

struct CESIUMUTILITY_API Credit {
public:
  bool operator==(const Credit& rhs) const noexcept {
    return this->_id == rhs._id && this->_generation == rhs._generation;
  }
 
private:
  uint32_t _id;
  uint32_t _generation;
 
  Credit(uint32_t id, uint32_t generation) noexcept
      : _id(id), _generation(generation) {}
 
  friend class CreditSystem;
  friend class CreditReferencer;
};

class CESIUMUTILITY_API CreditSource {
public:
  CreditSource(CreditSystem& creditSystem) noexcept;

  CreditSource(const std::shared_ptr<CreditSystem>& pCreditSystem) noexcept;
 
  ~CreditSource() noexcept;

  CreditSystem* getCreditSystem() noexcept;

  const CreditSystem* getCreditSystem() const noexcept;
 
private:
  void notifyCreditSystemDestroyed() noexcept;
 
  CreditSystem* _pCreditSystem;
 
  friend class CreditSystem;
};

struct CreditsSnapshot {
  std::vector<Credit> currentCredits;

  std::vector<Credit> removedCredits;
};

class CESIUMUTILITY_API CreditSystem final {
public:
  CreditSystem() noexcept = default;
  ~CreditSystem() noexcept;
 
  CreditSystem(const CreditSystem&) = delete;
  CreditSystem& operator=(const CreditSystem&) = delete;

  Credit createCredit(
      const CreditSource& source,
      std::string&& html,
      bool showOnScreen = false);

  Credit createCredit(
      const CreditSource& source,
      const std::string& html,
      bool showOnScreen = false);

  Credit createCredit(std::string&& html, bool showOnScreen = false);

  Credit createCredit(const std::string& html, bool showOnScreen = false);

  bool shouldBeShownOnScreen(Credit credit) const noexcept;

  void setShowOnScreen(Credit credit, bool showOnScreen) noexcept;

  const std::string& getHtml(Credit credit) const noexcept;

  const CreditSource* getCreditSource(Credit credit) const noexcept;

  bool addCreditReference(Credit credit);

  bool removeCreditReference(Credit credit);

  const CreditsSnapshot& getSnapshot(
      CreditFilteringMode filteringMode =
          CreditFilteringMode::UniqueHtml) noexcept;

  const CreditSource& getDefaultCreditSource() const noexcept;
 
private:
  struct CreditRecord {
    std::string html{};
    bool showOnScreen{false};
    int32_t referenceCount{0};
    bool shownLastSnapshot{0};
    uint32_t generation{0};
    const CreditSource* pSource{nullptr};
    uint32_t previousCreditWithSameHtml{INVALID_CREDIT_INDEX};
    uint32_t nextCreditWithSameHtml{INVALID_CREDIT_INDEX};
  };
 
  void addBulkReferences(
      const std::vector<int32_t>& references,
      const std::vector<uint32_t>& generations) noexcept;
  void releaseBulkReferences(
      const std::vector<int32_t>& references,
      const std::vector<uint32_t>& generations) noexcept;
 
  void createCreditSource(CreditSource& creditSource) noexcept;
  void destroyCreditSource(CreditSource& creditSource) noexcept;
 
  uint32_t filterCreditForSnapshot(
      CreditFilteringMode filteringMode,
      const CreditRecord& record) noexcept;
 
  const std::string INVALID_CREDIT_MESSAGE =
      "Error: Invalid Credit, cannot get HTML string.";
 
  static const uint32_t INVALID_CREDIT_INDEX{
      std::numeric_limits<uint32_t>::max()};
 
  std::vector<CreditSource*> _creditSources;
  std::vector<CreditRecord> _credits;
  CreditsSnapshot _snapshot;
  std::vector<int32_t> _referenceCountScratch;
 
  // These are credits that were shown in the last snapshot but whose
  // CreditSources have since been destroyed. They need to be reported in
  // removedCredits in the next snapshot.
  std::vector<Credit> _shownCreditsDestroyed;
 
  // Each entry in this vector is an index into _credits that is unused and can
  // be reused for a new credit.
  std::vector<size_t> _unusedCreditRecords;
 
  CreditSource _defaultCreditSource{*this};
 
  friend class CreditReferencer;
  friend class CreditSource;
};
} // namespace CesiumUtility