XrdClFwd.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2011-2017 by European Organization for Nuclear Research (CERN)
// Author: Krzysztof Jamrog <krzysztof.piotr.jamrog@cern.ch>,
//         Michal Simon <michal.simon@cern.ch>
//------------------------------------------------------------------------------
// This file is part of the XRootD software suite.
//
// XRootD is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// XRootD 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 Lesser General Public License
// along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
//
// In applying this licence, CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
//------------------------------------------------------------------------------
 
#ifndef SRC_XRDCL_XRDCLFWD_HH_
#define SRC_XRDCL_XRDCLFWD_HH_
 
#include <memory>
#include <stdexcept>
 
namespace XrdCl
{
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename T>
  struct FwdStorage
  {
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    FwdStorage() : ptr( nullptr ) { }
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    FwdStorage( const T &value ) : ptr( new( &storage.memory ) T( value ) )
    {
    }
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    FwdStorage& operator=( const T &value )
    {
      ptr = new( &storage.memory ) T( value );
      return *this;
    }
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    FwdStorage( T && value ) : ptr( new( &storage.memory ) T( std::move( value ) ) )
    {
    }
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    FwdStorage& operator=( T && value )
    {
      ptr = new( &storage.memory ) T( std::move( value ) );
      return *this;
    }
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    ~FwdStorage()
    {
      if( ptr ) ptr->~T();
    }
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    union Memory
    {
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Memory() { }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      ~Memory() { }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      T memory;
    };
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    Memory storage;
 
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    T *ptr;
  };
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename T>
  struct Fwd : protected std::shared_ptr<FwdStorage<T>>
  {
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    Fwd() : std::shared_ptr<FwdStorage<T>>( std::make_shared<FwdStorage<T>>() )
    {
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    Fwd( const Fwd &fwd ) : std::shared_ptr<FwdStorage<T>>( fwd )
    {
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    Fwd( Fwd && fwd ) : std::shared_ptr<FwdStorage<T>>( std::move( fwd ) )
    {
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    Fwd( std::shared_ptr<FwdStorage<T>> && ptr ) : std::shared_ptr<FwdStorage<T>>( std::move( ptr ) )
    {
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    explicit Fwd( const T &value )
    {
      *this->get() = value;
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    explicit Fwd( T &&value )
    {
      *this->get() = std::move( value );
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    Fwd& operator=( const T &value )
    {
      *this->get() = value;
      return *this;
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    Fwd& operator=( T && value )
    {
      *this->get() = std::move( value );
      return *this;
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    T& operator*() const
    {
      if( !bool( this->get()->ptr ) ) throw std::logic_error( "XrdCl::Fwd contains no value!" );
      return *this->get()->ptr;
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    T* operator->() const
    {
      if( !bool( this->get()->ptr ) ) throw std::logic_error( "XrdCl::Fwd contains no value!" );
      return this->get()->ptr;
    }
 
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    bool Valid() const
    {
      return bool( this->get()->ptr );
    }
  };
 
  //--------------------------------------------------------------------------
  // Utility function for creating forwardable objects
  //--------------------------------------------------------------------------
  template<typename T, typename... Args>
  inline std::shared_ptr<FwdStorage<T>> make_fwd( Args&&... args )
  {
    return std::make_shared<FwdStorage<T>>( std::forward<Args>( args )... );
  }
}
 
 
#endif /* SRC_XRDCL_XRDCLFWD_HH_ */