You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

112 lines
3.2KB

  1. /*
  2. * Scope Guard
  3. * Copyright (C) 2017 offa
  4. *
  5. * This file is part of Scope Guard.
  6. *
  7. * Scope Guard is free software: you can redistribute it and/or modify
  8. * it under the terms of the GNU General Public License as published by
  9. * the Free Software Foundation, either version 3 of the License, or
  10. * (at your option) any later version.
  11. *
  12. * Scope Guard is distributed in the hope that it will be useful,
  13. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. * GNU General Public License for more details.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * along with Scope Guard. If not, see <http://www.gnu.org/licenses/>.
  19. */
  20. #pragma once
  21. #include <utility>
  22. #include <type_traits>
  23. namespace sr
  24. {
  25. template<class EF>
  26. class scope_exit
  27. {
  28. public:
  29. template<class EFP,
  30. std::enable_if_t<std::is_constructible<EF, EFP>::value, int> = 0,
  31. std::enable_if_t<(!std::is_lvalue_reference<EFP>::value)
  32. && std::is_nothrow_constructible<EF, EFP>::value, int> = 0
  33. >
  34. explicit scope_exit(EFP&& exitFunction) : m_exitFunction(std::move(exitFunction)),
  35. m_execute_on_destruction(true)
  36. {
  37. }
  38. template<class EFP,
  39. std::enable_if_t<std::is_constructible<EF, EFP>::value, int> = 0,
  40. std::enable_if_t<std::is_lvalue_reference<EFP>::value, int> = 0
  41. >
  42. explicit scope_exit(EFP&& exitFunction) try : m_exitFunction(exitFunction),
  43. m_execute_on_destruction(true)
  44. {
  45. }
  46. catch( ... )
  47. {
  48. exitFunction();
  49. throw;
  50. }
  51. scope_exit(const scope_exit&) = delete;
  52. template<class T = EF,
  53. std::enable_if_t<std::is_nothrow_move_constructible<T>::value, int> = 0
  54. >
  55. scope_exit(scope_exit&& other) : m_exitFunction(std::move(other.m_exitFunction)),
  56. m_execute_on_destruction(other.m_execute_on_destruction)
  57. {
  58. other.release();
  59. }
  60. template<class T = EF,
  61. std::enable_if_t<!std::is_nothrow_move_constructible<T>::value, int> = 0
  62. >
  63. scope_exit(scope_exit&& other) : m_exitFunction(other.m_exitFunction),
  64. m_execute_on_destruction(other.m_execute_on_destruction)
  65. {
  66. other.release();
  67. }
  68. ~scope_exit() noexcept(true)
  69. {
  70. if( m_execute_on_destruction == true )
  71. {
  72. m_exitFunction();
  73. }
  74. }
  75. void release() noexcept
  76. {
  77. m_execute_on_destruction = false;
  78. }
  79. scope_exit& operator=(const scope_exit&) = delete;
  80. scope_exit& operator=(scope_exit&&) = delete;
  81. private:
  82. EF m_exitFunction;
  83. bool m_execute_on_destruction;
  84. };
  85. template<class EF>
  86. scope_exit<std::decay_t<EF>> make_scope_exit(EF&& exitFunction)
  87. {
  88. return scope_exit<std::decay_t<EF>>{std::forward<EF>(exitFunction)};
  89. }
  90. }