XrdClOptional.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2011-2017 by European Organization for Nuclear Research (CERN)
// Author: 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 __XRD_CL_OPTIONAL_HH__
#define __XRD_CL_OPTIONAL_HH__
 
#include <utility>
 
namespace XrdCl
{
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  static struct None{ } none;
 
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  template<typename T>
  class Optional
  {
    public:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Optional( const T& t ) : optional( false )
      {
        new( &memory.value ) T( t );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Optional( const None& n = none ) : optional( true )
      {
        (void)n;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Optional( const Optional& opt ) : optional( opt.optional )
      {
        if( !optional ) new( &memory.value ) T( opt.memory.value );
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Optional( Optional && opt ) : optional( opt.optional )
      {
        if( !optional ) new( &memory.value ) T( std::move( opt.memory.value ) );
      }
 
      //------------------------------------------------------------------------
      // Destructor
      //------------------------------------------------------------------------
      ~Optional()
      {
        if( optional ) memory.value.~T();
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Optional& operator=( const Optional& opt )
      {
        if( this != &opt )
        {
          optional = opt.optional;
          if( !optional ) memory.value = opt.memory.value;
        }
        return *this;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      Optional& operator=( Optional&& opt )
      {
        if( this != &opt )
        {
          optional = opt.optional;
          if( !optional ) memory.value = std::move( opt.memory.value );
        }
        return *this;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      operator bool() const
      {
        return optional;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      T& operator*()
      {
        return memory.value;
      }
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const T& operator*() const
      {
        return memory.value;
      }
 
    private:
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool optional;
 
      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      union Storage
      {
        //----------------------------------------------------------------------
        //----------------------------------------------------------------------
        T value;
        //----------------------------------------------------------------------
        //----------------------------------------------------------------------
        inline Storage(){ }
        //----------------------------------------------------------------------
        // Destructor
        //----------------------------------------------------------------------
        inline ~Storage(){ };
      } memory; //> memory storage for the optional variable
  };
}
 
#endif // __XRD_CL_OPTIONAL_HH__