RegisterCatalogue.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include "RegisterInfo.h"
#include "RegisterPath.h"
 
#include <boost/range/any_range.hpp>
#include <boost/shared_ptr.hpp>
 
namespace ChimeraTK {
 
  class BackendRegisterCatalogueBase;
  class const_RegisterCatalogueImplIterator;
 
  /********************************************************************************************************************/
 
  using HiddenRange = boost::any_range<BackendRegisterInfoBase, boost::forward_traversal_tag,
      const BackendRegisterInfoBase&, std::ptrdiff_t>;
 
  /********************************************************************************************************************/
 
  class RegisterCatalogue {
   public:
    explicit RegisterCatalogue(std::unique_ptr<BackendRegisterCatalogueBase>&& impl);
 
    RegisterCatalogue(const RegisterCatalogue& other);
    RegisterCatalogue(RegisterCatalogue&& other) noexcept;
    RegisterCatalogue& operator=(const RegisterCatalogue& other);
    RegisterCatalogue& operator=(RegisterCatalogue&& other) noexcept;
 
    ~RegisterCatalogue();
 
    [[nodiscard]] RegisterInfo getRegister(const RegisterPath& registerPathName) const;
 
    [[nodiscard]] bool hasRegister(const RegisterPath& registerPathName) const;
 
    [[nodiscard]] size_t getNumberOfRegisters() const;
 
    [[nodiscard]] const BackendRegisterCatalogueBase& getImpl() const;
 
    [[nodiscard]] HiddenRange hiddenRegisters() const;
 
    class const_iterator {
     public:
      explicit const_iterator(std::unique_ptr<const_RegisterCatalogueImplIterator> it);
 
      const_iterator(const const_iterator& other);
      const_iterator& operator=(const const_iterator& other);
 
      const_iterator(const_iterator&& other) noexcept;
      const_iterator& operator=(const_iterator&& other) noexcept;
 
      const_iterator& operator++();
      const_iterator operator++(int);
      const_iterator& operator--();
      const_iterator operator--(int);
      const BackendRegisterInfoBase& operator*();
      const BackendRegisterInfoBase* operator->();
      bool operator==(const const_iterator& rightHandSide) const;
      bool operator!=(const const_iterator& rightHandSide) const;
 
     protected:
      std::unique_ptr<const_RegisterCatalogueImplIterator> _impl;
    };
 
    [[nodiscard]] const_iterator begin() const;
    [[nodiscard]] const_iterator end() const;
 
   protected:
    std::unique_ptr<BackendRegisterCatalogueBase> _impl;
  };
 
  /********************************************************************************************************************/
 
  class const_RegisterCatalogueImplIterator {
   public:
    virtual ~const_RegisterCatalogueImplIterator() = default;
 
    virtual void increment() = 0;
 
    virtual void decrement() = 0;
 
    [[nodiscard]] virtual const BackendRegisterInfoBase* get() = 0;
 
    [[nodiscard]] virtual bool isEqual(
        const std::unique_ptr<const_RegisterCatalogueImplIterator>& rightHandSide) const = 0;
 
    [[nodiscard]] virtual std::unique_ptr<const_RegisterCatalogueImplIterator> clone() const = 0;
  };
 
  /********************************************************************************************************************/
 
} /* namespace ChimeraTK */