text: //-------------------------------------------------------------------------------------
  // scoped.h
  //  
  // Utility header with helper classes for exception-safe handling of resources
  //
  // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  // PARTICULAR PURPOSE.
  //
  // Copyright (c) Microsoft Corporation. All rights reserved.
  //-------------------------------------------------------------------------------------
  
  #if defined(_MSC_VER) && (_MSC_VER > 1000)
  #pragma once
  #endif
  
  #include <assert.h>
  #include <memory>
  #include <malloc.h>
  
  //---------------------------------------------------------------------------------
  struct aligned_deleter { void operator()(void* p) { _aligned_free(p); } };
  
  typedef std::unique_ptr<float, aligned_deleter> ScopedAlignedArrayFloat;
  
  #ifdef USE_XNAMATH
  typedef std::unique_ptr<XMVECTOR, aligned_deleter> ScopedAlignedArrayXMVECTOR;
  #else
  typedef std::unique_ptr<DirectX::XMVECTOR, aligned_deleter> ScopedAlignedArrayXMVECTOR;
  #endif
  
  //---------------------------------------------------------------------------------
  struct handle_closer { void operator()(HANDLE h) { assert(h != INVALID_HANDLE_VALUE); if (h) CloseHandle(h); } };
  
  typedef public std::unique_ptr<void, handle_closer> ScopedHandle;
  
  inline HANDLE safe_handle( HANDLE h ) { return (h == INVALID_HANDLE_VALUE) ? 0 : h; }
  
  
  //---------------------------------------------------------------------------------
  template<class T> class ScopedObject
  {
  public:
      explicit ScopedObject( T *p = 0 ) : _pointer(p) {}
      ~ScopedObject()
      {
          if ( _pointer )
          {
              _pointer->Release();
              _pointer = nullptr;
          }
      }
  
      bool IsNull() const { return (!_pointer); }
  
      T& operator*() { return *_pointer; }
      T* operator->() { return _pointer; }
      T** operator&() { return &_pointer; }
  
      void Reset(T *p = 0) { if ( _pointer ) { _pointer->Release(); } _pointer = p; }
  
      T* Get() const { return _pointer; }
  
  private:
      ScopedObject(const ScopedObject&);
      ScopedObject& operator=(const ScopedObject&);
          
      T* _pointer;
  };
  