el::base::utils::RegistryWithPred< T_Ptr, Pred > Class Template Reference

A pointer registry mechanism to manage memory and provide search functionalities. (predicate version). More...

#include <easylogging++.h>

Inheritance diagram for el::base::utils::RegistryWithPred< T_Ptr, Pred >:

Collaboration diagram for el::base::utils::RegistryWithPred< T_Ptr, Pred >:

Public Types
typedef RegistryWithPred< T_Ptr, Pred >::iterator	iterator
typedef RegistryWithPred< T_Ptr, Pred >::const_iterator	const_iterator
Public Types inherited from el::base::utils::AbstractRegistry< T_Ptr, std::vector< T_Ptr * > >
typedef std::vector< T_Ptr * >::iterator	iterator
typedef std::vector< T_Ptr * >::const_iterator	const_iterator

Public Member Functions
	RegistryWithPred (void)
virtual	~RegistryWithPred (void)
	RegistryWithPred (const RegistryWithPred &sr)
	Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor.
RegistryWithPred &	operator= (const RegistryWithPred &sr)
	Assignment operator that unregisters all the existing registeries and deeply copies each of repo element.
Public Member Functions inherited from el::base::utils::AbstractRegistry< T_Ptr, std::vector< T_Ptr * > >
	AbstractRegistry (void)
	Default constructor.
bool	operator== (const AbstractRegistry< T_Ptr, std::vector< T_Ptr * > > &other)
bool	operator!= (const AbstractRegistry< T_Ptr, std::vector< T_Ptr * > > &other)
AbstractRegistry &	operator= (AbstractRegistry &&sr)
	Assignment move operator.
virtual	~AbstractRegistry (void)
virtual iterator	begin (void) ELPP_FINAL
virtual iterator	end (void) ELPP_FINAL
virtual const_iterator	cbegin (void) const ELPP_FINAL
virtual const_iterator	cend (void) const ELPP_FINAL
virtual bool	empty (void) const ELPP_FINAL
virtual std::size_t	size (void) const ELPP_FINAL
virtual std::vector< T_Ptr * > &	list (void) ELPP_FINAL
	Returns underlying container by reference.
Public Member Functions inherited from el::base::threading::ThreadSafe
virtual void	acquireLock (void) ELPP_FINAL
virtual void	releaseLock (void) ELPP_FINAL
virtual base::threading::Mutex &	lock (void) ELPP_FINAL

Protected Member Functions
virtual void	unregisterAll (void) ELPP_FINAL
	Unregisters all the pointers from current repository.
virtual void	unregister (T_Ptr *&ptr) ELPP_FINAL
virtual void	registerNew (T_Ptr *ptr) ELPP_FINAL
template<typename T, typename T2>
T_Ptr *	get (const T &arg1, const T2 arg2)
	Gets pointer from repository with speicifed arguments. Arguments are passed to predicate in order to validate pointer.
Protected Member Functions inherited from el::base::utils::AbstractRegistry< T_Ptr, std::vector< T_Ptr * > >
void	reinitDeepCopy (const AbstractRegistry< T_Ptr, std::vector< T_Ptr * > > &sr)
Protected Member Functions inherited from el::base::threading::ThreadSafe
	ThreadSafe (void)
virtual	~ThreadSafe (void)

Friends
base::type::ostream_t &	operator<< (base::type::ostream_t &os, const RegistryWithPred &sr)

Detailed Description

template<typename T_Ptr, typename Pred>
class el::base::utils::RegistryWithPred< T_Ptr, Pred >

A pointer registry mechanism to manage memory and provide search functionalities. (predicate version).

@detail NOTE: This is thread-unsafe implementation of AbstractRegistry<T_Ptr, Container>. Any implementation of this class should be made thread-safe explicitly

Definition at line 1469 of file easylogging++.h.

Member Typedef Documentation

const_iterator

template<typename T_Ptr, typename Pred>

typedef RegistryWithPred<T_Ptr,Pred>::const_iterator el::base::utils::RegistryWithPred< T_Ptr, Pred >::const_iterator

Definition at line 1472 of file easylogging++.h.

iterator

template<typename T_Ptr, typename Pred>

typedef RegistryWithPred<T_Ptr,Pred>::iterator el::base::utils::RegistryWithPred< T_Ptr, Pred >::iterator

Definition at line 1471 of file easylogging++.h.

Constructor & Destructor Documentation

RegistryWithPred() [1/2]

template<typename T_Ptr, typename Pred>

el::base::utils::RegistryWithPred< T_Ptr, Pred >::RegistryWithPred ( void )

inline

Definition at line 1474 of file easylogging++.h.

                         {
  }

~RegistryWithPred()

template<typename T_Ptr, typename Pred>

virtual el::base::utils::RegistryWithPred< T_Ptr, Pred >::~RegistryWithPred ( void )

inlinevirtual

Definition at line 1477 of file easylogging++.h.

                                  {
    unregisterAll();
  }

RegistryWithPred() [2/2]

template<typename T_Ptr, typename Pred>

el::base::utils::RegistryWithPred< T_Ptr, Pred >::RegistryWithPred ( const RegistryWithPred< T_Ptr, Pred > & sr )

inline

Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor.

Definition at line 1482 of file easylogging++.h.

                                               : AbstractRegistry<T_Ptr, std::vector<T_Ptr*>>() {
    if (this == &sr) {
      return;
    }
    this->reinitDeepCopy(sr);
  }

Member Function Documentation

get()

template<typename T_Ptr, typename Pred>

template<typename T, typename T2>

T_Ptr * el::base::utils::RegistryWithPred< T_Ptr, Pred >::get ( const T & arg1, const T2 arg2 )

inlineprotected

Gets pointer from repository with speicifed arguments. Arguments are passed to predicate in order to validate pointer.

Definition at line 1539 of file easylogging++.h.

                                           {
    iterator iter = std::find_if(this->list().begin(), this->list().end(), Pred(arg1, arg2));
    if (iter != this->list().end() && *iter != nullptr) {
      return *iter;
    }
    return nullptr;
  }

operator=()

template<typename T_Ptr, typename Pred>

RegistryWithPred & el::base::utils::RegistryWithPred< T_Ptr, Pred >::operator= ( const RegistryWithPred< T_Ptr, Pred > & sr )

inline

Assignment operator that unregisters all the existing registeries and deeply copies each of repo element.

See also

unregisterAll()

deepCopy(const AbstractRegistry&)

Definition at line 1492 of file easylogging++.h.

                                                        {
    if (this == &sr) {
      return *this;
    }
    this->reinitDeepCopy(sr);
    return *this;
  }

registerNew()

template<typename T_Ptr, typename Pred>

virtual void el::base::utils::RegistryWithPred< T_Ptr, Pred >::registerNew ( T_Ptr * ptr )

inlineprotectedvirtual

Definition at line 1532 of file easylogging++.h.

                                                         {
    this->list().push_back(ptr);
  }

unregister()

template<typename T_Ptr, typename Pred>

virtual void el::base::utils::RegistryWithPred< T_Ptr, Pred >::unregister ( T_Ptr *& ptr )

inlineprotectedvirtual

Definition at line 1517 of file easylogging++.h.

                                                  {
    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);
        base::utils::safeDelete(*iter);
      }
    }
  }

unregisterAll()

template<typename T_Ptr, typename Pred>

virtual void el::base::utils::RegistryWithPred< T_Ptr, Pred >::unregisterAll ( void )

inlineprotectedvirtual

Unregisters all the pointers from current repository.

Implements el::base::utils::AbstractRegistry< T_Ptr, std::vector< T_Ptr * > >.

Definition at line 1508 of file easylogging++.h.

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

Friends And Related Symbol Documentation

operator<<

template<typename T_Ptr, typename Pred>

base::type::ostream_t & operator<< ( base::type::ostream_t & os, const RegistryWithPred< T_Ptr, Pred > & sr )

friend

Definition at line 1500 of file easylogging++.h.

                                                                                          {
    for (const_iterator it = sr.list().begin(); it != sr.list().end(); ++it) {
      os << ELPP_LITERAL("    ") << **it << ELPP_LITERAL("\n");
    }
    return os;
  }

---

The documentation for this class was generated from the following file:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/external/easylogging++/easylogging++.h