.gitignore

*.o
*.so
*~
*.swp
*.gcno
*.gcda
*.gcov
*.log
.tup
test
demo

ptr_wrapper.hpp

#pragma once

#include <memory>

namespace ptrwrapper
{
  template < typename T >
  class Wrapper
  {
    public:
      typedef std::unique_ptr< T > OwningPtr;
      Wrapper( OwningPtr&& ownedPtr )
        : m_owned( std::move( ownedPtr ) )
        , m_wrapped( nullptr )
      {
      }

      Wrapper( T* value )
        : m_owned( nullptr )
        , m_wrapped( value )
      {
      }

      T& operator*()
      {
        return *( operator->() );
      }

      T* operator->()
      {
        return m_owned ?
          m_owned.get() :
          m_wrapped;
      }

    private:
      OwningPtr m_owned;
      T*        m_wrapped;
  };

  template < typename T >
  Wrapper< T > own( T* value )
  {
    return Wrapper< T >(
        std::unique_ptr< T >( value ) );
  }

  template < typename T >
  Wrapper< T > wrap( T* value )
  {
    return Wrapper< T >( value );
  }

}

test_wrapper.cpp

#include <igloo/igloo_alt.h>
using namespace igloo;

#include "ptr_wrapper.hpp"

namespace
{
  struct AStruct
  {
    AStruct( int item )
      : member( item )
    {
    }

    int member;
  };
}

Describe( ptr_wrapper )
{
  It ( can_own_objects )
  {
    auto wrapper( ptrwrapper::own( new AStruct( value ) ) );
    AssertThat( (*wrapper).member, Equals( value ) );
    AssertThat( wrapper->member, Equals( value ) );
  }

  It ( can_wrap_objects_without_owning_them )
  {
    AStruct stuff( value );
    auto wrapper( ptrwrapper::wrap( &stuff ) );
    AssertThat( (*wrapper).member, Equals( value ) );
    AssertThat( wrapper->member, Equals( value ) );

    ++wrapper->member;
    AssertThat( stuff.member, Equals( value + 1 ) );
  }

  const int value{ 10 };
};

int main()
{
  return TestRunner::RunAllTests();
}

Tupfile

PHOME=$(TUP_CWD)
CFLAGS+=-Wall -Wextra -pedantic -Werror -fPIC -std=c++11 -O2
INCLUDE_PATH+=-I$(PHOME)/include
LIBS=
EXTRADEP=

CXX=g++

!cpp = |> $(CXX) $(CFLAGS) $(INCLUDE_PATH) %f -c |> %B.o
!link_binary = |> $(CXX) $(CFLAGS) $(LIBPATH) %f -o %o |>
!run_test = | test |> valgrind --leak-check=full --show-reachable=yes ./test |>

: foreach *.cpp |> !cpp |> {test_objs}
: {test_objs} |> !link_binary |> test
: |> !run_test |>