handle.h

Go to the documentation of this file.

/* Author(s)     : Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date : 2011-04-01
 * Last modified : 2018-07-17
 *
 * Copyright (C) 2011-2018 Francois Mauger <mauger@lpccaen.in2p3.fr>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 *
 * Description:
 *
 *  An serializable handle object referencing an object through
 *  a hiden shared pointer.
 *
 */
#ifndef DATATOOLS_HANDLE_H
#define DATATOOLS_HANDLE_H

// Standard Library:
#include <iostream>
#include <stdexcept>
#include <type_traits>

// Third Party:
// - Boost:
#include <boost/shared_ptr.hpp>
#include <boost/smart_ptr/make_shared.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/tracking.hpp>
#include <boost/serialization/shared_ptr.hpp>

// This Project:
#include <datatools/i_predicate.h>
#include <datatools/exception.h>

namespace datatools {

  template <typename T> struct handle_predicate;

  template <typename T>
  class handle
  {
  public:
    typedef T value_type;
    typedef value_type & reference_type;
    typedef handle_predicate<T> predicate_type;



    handle(T * held_ = nullptr)
      : _sp_(held_)
    {
      return;
    }


    template<typename Q,
             typename = std::enable_if<
               std::is_same<const Q, T>::value &&
               std::is_const<T>::value &&
               !std::is_const<Q>::value>>
      handle(Q* held = nullptr)
      : _sp_(const_cast<Q*>(held))
    {
      return;
    }

    handle(const boost::shared_ptr<T> & sp_)
      : _sp_(sp_)
    {
      return;
    }

    virtual ~handle()
    {
      _sp_.reset();
      return;
    }

    bool unique() const
    {
      return _sp_.unique();
    }

    // 2013-05-12 FM : Preserved until all client code use the corresponding 'operator bool'.
    bool has_data() const
    {
      return _sp_.get() != nullptr;
    }

    operator bool() const
    {
      return _sp_.get() != nullptr;
    }

    void swap(handle<T> & other_)
    {
      _sp_.swap(other_._sp_);
      return;
    }

    const T & get() const
    {
      DT_THROW_IF(_sp_.get() == nullptr, std::logic_error, "Handle holds no data!");
      return *_sp_;
    }

    // 2016-12-01, FM: original version is inhibited when T is const:
    // //! Return a non-const reference to the hosted instance.
    // T& grab() {
    //   if (_sp_) return *_sp_;
    //   DT_THROW_IF(true, std::logic_error, "Handle holds no data!");
    // }

    template<typename Q = T>
    typename std::enable_if<
      std::is_same<Q, T>::value &&
    !std::is_const<Q>::value &&
    !std::is_const<T>::value,
      Q&>::type grab()
    {
      DT_THROW_IF(_sp_.get() == nullptr, std::logic_error, "Handle holds no data!");
      return *_sp_;
    }

    T* operator->()
    {
      DT_THROW_IF(!_sp_, std::logic_error, "Handle holds no data!");
      return _sp_.get();
    }

    T const* operator->() const
    {
      DT_THROW_IF(!_sp_, std::logic_error, "Handle holds no data!");
      return _sp_.get();
    }


    T& operator*()
    {
      DT_THROW_IF(!_sp_, std::logic_error, "Handle holds no data!");
      return *(_sp_.get());
    }

    T const& operator*() const
    {
      DT_THROW_IF(!_sp_, std::logic_error, "Handle holds no data!");
      return *(_sp_.get());
    }

    void reset(T * elem_ = nullptr)
    {
      _sp_.reset(elem_);
      return;
    }

    template<typename Q = T>
    typename std::enable_if<
      std::is_same<Q, T>::value &&
    !std::is_const<Q>::value &&
    !std::is_const<T>::value,
      handle<const Q> >::type to_const() const
    {
      boost::shared_ptr<const T> csp = boost::const_pointer_cast<const T, T>(_sp_);
      return handle<const T>(csp);
    }

  private:

    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive & ar_, int /*version*/)
    {
      ar_ & boost::serialization::make_nvp("sp", _sp_);
      return;
    }

  private:

    boost::shared_ptr<T> _sp_; 

  };

  template <typename T, typename... Args>
  handle<T> make_handle(Args&& ... args)
  {
    // Use shared_ptr constructor for simplicity
    return handle<T>(boost::make_shared<T>(std::forward<Args>(args)...));
  }

  template <typename T>
  struct handle_predicate
    : public i_predicate<handle<T> >
  {
  public:
    handle_predicate(const i_predicate<T> & predicate_,
                     bool no_data_means_false_ = true)
      : _predicate_(predicate_)
      , _no_data_means_false_(no_data_means_false_)
    {
      return;
    }


    bool operator()(const handle<T> & handle_) const
    {
      if (! handle_) {
        if (_no_data_means_false_) return false;
        DT_THROW(std::logic_error, "Handle has no data !");
      }
      return _predicate_(handle_.get());
    }

  private:
    const i_predicate<T> & _predicate_; 
    bool _no_data_means_false_; 
  };

} // end of namespace datatools

// From "boost/serialization/shared_ptr.hpp" :
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace boost {
  namespace serialization{
    // don't track shared pointers
    template<class T>
    struct tracking_level< ::datatools::handle<T> > {
      typedef mpl::integral_c_tag tag;
#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
      typedef BOOST_DEDUCED_TYPENAME mpl::int_< ::boost::serialization::track_never> type;
#else
      typedef mpl::int_< ::boost::serialization::track_never> type;
#endif
#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570))
      BOOST_STATIC_CONSTANT(int, value = ::boost::serialization::track_never);
#else
      BOOST_STATIC_CONSTANT(int, value = type::value);
#endif
    };
  }}
#define BOOST_SERIALIZATION_DATATOOLS_HANDLE(T)
#else
// define macro to let users of these compilers do this
#define BOOST_SERIALIZATION_DATATOOLS_HANDLE(T)             \
  BOOST_SERIALIZATION_SHARED_PTR(T)                         \
  BOOST_CLASS_TRACKING(::datatools::handle< T >,            \
                       ::boost::serialization::track_never) \
  
#endif

#endif // DATATOOLS_HANDLE_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --