utilities.hh

Go to the documentation of this file.

/*
 * Scroom - Generic viewer for 2D data
 * Copyright (C) 2009-2022 Kees-Jan Dijkzeul
 *
 * SPDX-License-Identifier: LGPL-2.1
 */
 
#pragma once
 
#include <boost/enable_shared_from_this.hpp>
#include <boost/thread.hpp>
 
namespace Scroom::Utils
{
  class Base : public boost::enable_shared_from_this<Base>
  {
  public:
    Base()                       = default;
    Base(const Base&)            = delete;
    Base(Base&&)                 = delete;
    Base& operator=(const Base&) = delete;
    Base& operator=(Base&&)      = delete;
    virtual ~Base()              = default;
 
    template <typename R>
    boost::shared_ptr<R> shared_from_this();
 
    template <typename R>
    boost::shared_ptr<R const> shared_from_this() const;
  };
 
  template <typename F>
  class on_scope_exit
  {
  public:
    explicit on_scope_exit(F f_)
      : f(std::move(f_))
    {
    }
    on_scope_exit(const on_scope_exit&)            = delete;
    on_scope_exit(on_scope_exit&&)                 = delete;
    on_scope_exit& operator=(const on_scope_exit&) = delete;
    on_scope_exit& operator=(on_scope_exit&&)      = delete;
 
    ~on_scope_exit() { f(); }
 
  private:
    F f;
  };
 
  template <typename F>
  boost::shared_ptr<void> on_destruction(F f)
  {
    return boost::make_shared<on_scope_exit<F>>(std::move(f));
  }
 
  template <typename F>
  class optional_cleanup
  {
  public:
    explicit optional_cleanup(F f_)
      : f(std::move(f_))
    {
    }
    optional_cleanup(const optional_cleanup&)            = delete;
    optional_cleanup(optional_cleanup&&)                 = delete;
    optional_cleanup& operator=(const optional_cleanup&) = delete;
    optional_cleanup& operator=(optional_cleanup&&)      = delete;
 
    ~optional_cleanup()
    {
      if(cleanup)
      {
        f();
      }
    }
 
    void cancel() { cleanup = false; }
 
  private:
    bool cleanup{true};
    F    f;
  };
 
  template <typename R>
  boost::shared_ptr<R> Base::shared_from_this()
  {
    return boost::dynamic_pointer_cast<R, Base>(boost::enable_shared_from_this<Base>::shared_from_this());
  }
 
  template <typename R>
  boost::shared_ptr<R const> Base::shared_from_this() const
  {
    return boost::dynamic_pointer_cast<R const, Base const>(boost::enable_shared_from_this<Base>::shared_from_this());
  }
 
 
  void dumpCounts();
 
 
  class Count
  {
  public:
    using Ptr = boost::shared_ptr<Count>;
 
  public:
    const std::string name;
    boost::mutex      mut;
    long              count{0};
 
  public:
    static Ptr create(const std::string& name);
    void       ping()
    { /* dumpCounts(); */
    }
    void inc()
    {
      boost::unique_lock<boost::mutex> const lock(mut);
      ++count;
      ping();
    }
    void dec()
    {
      boost::unique_lock<boost::mutex> const lock(mut);
      --count;
      ping();
    }
 
  private:
    explicit Count(std::string name);
  };
 
 
  class Counter
  {
  public:
  private:
    std::list<Count::Ptr> counts;
    boost::mutex          mut;
 
  private:
    Counter();
 
  public:
    static Counter*       instance();
    void                  registerCount(const Count::Ptr& count);
    void                  unregisterCount(const Count::Ptr& count);
    void                  dump();
    std::list<Count::Ptr> getCounts();
  };
 
 
  template <class C>
  class Counted
  {
  private:
    Count::Ptr data;
 
  public:
    static Count::Ptr count_instance()
    {
      static Count::Ptr const instance = Count::create(typeid(C).name());
      return instance;
    }
 
    Counted()
      : data(count_instance())
    {
      data->inc();
    }
 
    Counted(const Counted& /*unused*/)
      : data(count_instance())
    {
      data->inc();
    }
 
    Counted(Counted&& /*unused*/)
      : data(count_instance())
    {
      data->inc();
    }
 
    Counted& operator=(const Counted&) = default;
    Counted& operator=(Counted&&)      = default;
 
    virtual ~Counted() { data->dec(); }
  };
} // namespace Scroom::Utils