summaryrefslogtreecommitdiff
path: root/contrib/utility/Utility/ReferenceCounting/Interface.hpp
blob: 9231860b84af5cc2952a734d30bbab2d3c237ced (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
// file      : Utility/ReferenceCounting/Interface.hpp
// author    : Boris Kolpackov <boris@kolpackov.net>
// copyright : Copyright (c) 2002-2003 Boris Kolpackov
// license   : http://kolpackov.net/license.html

#ifndef UTILITY_REFERENCE_COUNTING_INTERFACE_HPP
#define UTILITY_REFERENCE_COUNTING_INTERFACE_HPP

#include "Utility/ExH/Compound.hpp"
#include "Utility/ExH/System/Exception.hpp"
#include "Utility/ExH/Logic/Exception.hpp"
#include "Utility/ExH/Logic/DescriptiveException.hpp"

namespace Utility
{
  namespace ReferenceCounting
  {
    // Interface to a reference-countable object. Note that _remove_ref ()
    // member function has a no-throw semantic. Even though it can lead to
    // a diagnostic loss it was made no-throw because it has a destructor
    // semantic.

    class Interface
    {
    public:
      typedef
      unsigned long
      count_t;

      typedef
      ExH::System::Exception
      SystemException;

      class Exception_ {};
      typedef
      ExH::Compound<Exception_, ExH::Logic::DescriptiveException>
      Exception;

    public:
      virtual void
      add_ref () const throw (Exception, SystemException) = 0;

      virtual void
      remove_ref () const throw () = 0;

      virtual count_t
      refcount_value () const throw (Exception, SystemException) = 0;

    protected:
      Interface () throw ();

      virtual
      ~Interface () throw ();

    protected:
      virtual void
      add_ref_i () const throw (Exception, SystemException) = 0;

      virtual bool
      remove_ref_i () const throw (Exception, SystemException) = 0;

      virtual count_t
      refcount_value_i () const throw (Exception, SystemException) = 0;

    private:
      // Copy semanic is not supported.
      Interface (Interface const&) throw ();
      Interface&
      operator= (Interface const&) throw ();
    };

    template <typename Type>
    Type*
    add_ref (Type* ptr)
      throw (Interface::Exception, Interface::SystemException);
  }
}

#include "Utility/ReferenceCounting/Interface.tpp"
#include "Utility/ReferenceCounting/Interface.ipp"

#endif  // UTILITY_REFERENCE_COUNTING_INTERFACE_HPP

//$Id$