count.hh 3.19 KB
Newer Older
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
// Copyright (C) 2007 EPITA Research and Development Laboratory
//
// This file is part of the Olena Library.  This library is free
// software; you can redistribute it and/or modify it under the terms
// of the GNU General Public License version 2 as published by the
// Free Software Foundation.
//
// This library 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 General Public License
// along with this library; see the file COPYING.  If not, write to
// the Free Software Foundation, 51 Franklin Street, Fifth Floor,
// Boston, MA 02111-1307, USA.
//
// As a special exception, you may use this file as part of a free
// software library without restriction.  Specifically, if other files
// instantiate templates or use macros or inline functions from this
// file, or you compile this file and link it with other files to
// produce an executable, this file does not by itself cause the
// resulting executable to be covered by the GNU General Public
// License.  This exception does not however invalidate any other
// reasons why the executable file might be covered by the GNU General
// Public License.

Thierry Geraud's avatar
Thierry Geraud committed
28
29
#ifndef MLN_ACCU_COUNT_HH
# define MLN_ACCU_COUNT_HH
30

Thierry Geraud's avatar
Thierry Geraud committed
31
/*! \file mln/accu/count.hh
32
 *
33
 * \brief Define an accumulator that counts.
34
35
 */

36
# include <mln/accu/internal/base.hh>
37
# include <mln/core/concept/meta_accumulator.hh>
38

39
40
41
42

namespace mln
{

43
  namespace accu
44
45
46
  {


47
48
49
50
    /*!
     * \brief Generic counter accumulator class.
     *
     * The parameter \a T is the type to be count.
51
     */
52
53
    template <typename T>
    struct count_ : public mln::accu::internal::base_< std::size_t , count_<T> >
54
    {
55
      typedef T argument;
56
      typedef std::size_t result; // FIXME: Up in Accumulator.
57

58
      count_();
59

60
      void init();
Matthieu Garrigues's avatar
Matthieu Garrigues committed
61
      // FIXME : should we add a take() without argument?
62
      void take(const argument&);
63
      void take(const count_<T>& other);
64

65
      std::size_t to_result() const;
66
      void set_value(std::size_t c);
Thierry Geraud's avatar
Thierry Geraud committed
67

68
69
    protected:

70
      std::size_t count__;
71
    };
72
73


74
75
76
    /*!
     * \brief Meta accumulator for count.
     */
77
78
    struct count : public Meta_Accumulator< count >
    {
79
      template <typename T>
80
81
      struct with
      {
82
	typedef count_<T> ret;
83
84
85
      };
    };

86
87
88

# ifndef MLN_INCLUDE_ONLY

89
    template <typename T>
90
    inline
91
    count_<T>::count_()
92
93
94
95
    {
      init();
    }

96
    template <typename T>
97
    inline
98
    void
99
    count_<T>::init()
100
    {
101
      count__ = 0;
102
103
    }

104
    template <typename T>
105
    inline
106
    void
107
    count_<T>::take(const argument&)
108
    {
109
      ++count__;
110
111
    }

112
    template <typename T>
113
    inline
114
    void
115
    count_<T>::take(const count_<T>& other)
116
    {
117
      count__ += other.count__;
118
119
    }

120
    template <typename T>
121
    inline
122
    std::size_t
123
    count_<T>::to_result() const
124
    {
125
      return count__;
126
127
    }

128
    template <typename T>
129
    inline
130
    void
131
    count_<T>::set_value(std::size_t c)
132
    {
133
      count__ = c;
134
135
    }

136
137
# endif // ! MLN_INCLUDE_ONLY

138
  } // end of namespace mln::accu
139
140
141
142

} // end of namespace mln


Thierry Geraud's avatar
Thierry Geraud committed
143
#endif // ! MLN_ACCU_COUNT_HH