Class RegistryWithPred

include/thundersvm/util/log.h:1501–1585

/// should be made thread-safe explicitly
            template <typename T_Ptr, typename Pred>
            class RegistryWithPred : public AbstractRegistry<T_Ptr, std::vector<T_Ptr*>> {
            public:
                typedef typename RegistryWithPred<T_Ptr, Pred>::iterator iterator;
                typedef typename RegistryWithPred<T_Ptr, Pred>::const_iterator const_iterator;

                RegistryWithPred(void) {
                }

                virtual ~RegistryWithPred(void) {
                    unregisterAll();
                }

                /// @brief Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor.
                RegistryWithPred(const RegistryWithPred& sr) : AbstractRegistry<T_Ptr, std::vector<T_Ptr*>>() {
                    if (this == &sr) {
                        return;
                    }
                    this->reinitDeepCopy(sr);
                }

                /// @brief Assignment operator that unregisters all the existing registeries and deeply copies each of repo element
                /// @see unregisterAll()
                /// @see deepCopy(const AbstractRegistry&)
                RegistryWithPred& operator=(const RegistryWithPred& sr) {
                    if (this == &sr) {
                        return *this;
                    }
                    this->reinitDeepCopy(sr);
                    return *this;
                }

                friend base::type::ostream_t& operator<<(base::type::ostream_t& os, const RegistryWithPred& sr) {
                    for (const_iterator it = sr.list().begin(); it != sr.list().end(); ++it) {
                        os << ELPP_LITERAL("    ") << **it << ELPP_LITERAL("\n");
                    }
                    return os;
                }

            protected:
                virtual void unregisterAll(void) ELPP_FINAL {
                    if (!this->empty()) {
                        for (auto&& curr : this->list()) {
                            base::utils::safeDelete(curr);
                        }
                        this->list().clear();
                    }
                }

                virtual void unregister(T_Ptr*& ptr) ELPP_FINAL {
                    if (ptr) {
                        iterator iter = this->begin();
                        for (; iter != this->end(); ++iter) {
                            if (ptr == *iter) {
                                break;
                            }
                        }
                        if (iter != this->end() && *iter != nullptr) {
                            this->list().erase(iter);