Changeset - r121:91c0fed3181e
« 120:137278
122:35840c »
gravatar
alpar (Alpar Juttner)
alpar@cs.elte.hu
Change SubNoCounter to NoSubCounter
0 1 0
default
1 file changed with 18 insertions and 18 deletions:
lemon/counter.h
18
18
↑ Collapse diff ↑
lemon/counter.h
Show white space 12 line context
... ... 
@@ -26,25 +26,25 @@
26 26 
///\file
27 27 
///\brief Tools for counting steps and events
28 28 

			




	29
	29
	
		
namespace lemon 


			




	30
	30
	
		
{


			




	31
	31
	
		

			




	32
	
	
		
  template<class P> class _SubNoCounter;


			




	
	32
	
		
  template<class P> class _NoSubCounter;


			




	33
	33
	
		

			




	34
	34
	
		
  template<class P>


			




	35
	35
	
		
  class _SubCounter 


			




	36
	36
	
		
  {


			




	37
	37
	
		
    P &_parent;


			




	38
	38
	
		
    std::string _title;


			




	39
	39
	
		
    std::ostream &_os;


			




	40
	40
	
		
    int count;


			




	41
	41
	
		
  public:


			




	42
	42
	
		

			




	43
	43
	
		
    typedef _SubCounter<_SubCounter<P> > SubCounter;


			




	44
	
	
		
    typedef _SubNoCounter<_SubCounter<P> > SubNoCounter;


			




	
	44
	
		
    typedef _NoSubCounter<_SubCounter<P> > NoSubCounter;


			




	45
	45
	
		

			




	46
	46
	
		
    _SubCounter(P &parent)


			




	47
	47
	
		
      : _parent(parent), _title(), _os(std::cerr), count(0) {}


			




	48
	48
	
		
    _SubCounter(P &parent,std::string title,std::ostream &os=std::cerr)


			




	49
	49
	
		
      : _parent(parent), _title(title), _os(os), count(0) {}


			




	50
	50
	
		
    _SubCounter(P &parent,const char *title,std::ostream &os=std::cerr)


			




	...
	...
	
		
@@ -61,35 +61,35 @@


			




	61
	61
	
		
    _SubCounter &operator-=(int c) { count-=c; return *this;}


			




	62
	62
	
		
    void reset(int c=0) {count=c;}


			




	63
	63
	
		
    operator int() {return count;}


			




	64
	64
	
		
  };


			




	65
	65
	
		

			




	66
	66
	
		
  template<class P>


			




	67
	
	
		
  class _SubNoCounter 


			




	
	67
	
		
  class _NoSubCounter 


			




	68
	68
	
		
  {


			




	69
	69
	
		
    P &_parent;


			




	70
	70
	
		
  public:


			




	71
	
	
		
    typedef _SubNoCounter<_SubNoCounter<P> > SubCounter;


			




	72
	
	
		
    typedef _SubNoCounter<_SubNoCounter<P> > SubNoCounter;


			




	
	71
	
		
    typedef _NoSubCounter<_NoSubCounter<P> > SubCounter;


			




	
	72
	
		
    typedef _NoSubCounter<_NoSubCounter<P> > NoSubCounter;


			




	73
	73
	
		
  


			




	74
	
	
		
    _SubNoCounter(P &parent) :_parent(parent) {}


			




	75
	
	
		
    _SubNoCounter(P &parent,std::string,std::ostream &) 


			




	
	74
	
		
    _NoSubCounter(P &parent) :_parent(parent) {}


			




	
	75
	
		
    _NoSubCounter(P &parent,std::string,std::ostream &) 


			




	76
	76
	
		
      :_parent(parent) {}


			




	77
	
	
		
    _SubNoCounter(P &parent,std::string) 


			




	
	77
	
		
    _NoSubCounter(P &parent,std::string) 


			




	78
	78
	
		
      :_parent(parent) {}


			




	79
	
	
		
    _SubNoCounter(P &parent,const char *,std::ostream &)


			




	
	79
	
		
    _NoSubCounter(P &parent,const char *,std::ostream &)


			




	80
	80
	
		
      :_parent(parent) {}


			




	81
	
	
		
    _SubNoCounter(P &parent,const char *)


			




	
	81
	
		
    _NoSubCounter(P &parent,const char *)


			




	82
	82
	
		
      :_parent(parent) {}


			




	83
	
	
		
    ~_SubNoCounter() {}


			




	84
	
	
		
    _SubNoCounter &operator++() { ++_parent; return *this;}


			




	
	83
	
		
    ~_NoSubCounter() {}


			




	
	84
	
		
    _NoSubCounter &operator++() { ++_parent; return *this;}


			




	85
	85
	
		
    int operator++(int) { _parent++; return 0;}


			




	86
	
	
		
    _SubNoCounter &operator--() { --_parent; return *this;}


			




	
	86
	
		
    _NoSubCounter &operator--() { --_parent; return *this;}


			




	87
	87
	
		
    int operator--(int) { _parent--; return 0;}


			




	88
	
	
		
    _SubNoCounter &operator+=(int c) { _parent+=c; return *this;}


			




	89
	
	
		
    _SubNoCounter &operator-=(int c) { _parent-=c; return *this;}


			




	
	88
	
		
    _NoSubCounter &operator+=(int c) { _parent+=c; return *this;}


			




	
	89
	
		
    _NoSubCounter &operator-=(int c) { _parent-=c; return *this;}


			




	90
	90
	
		
    void reset(int) {}


			




	91
	91
	
		
    void reset() {}


			




	92
	92
	
		
    operator int() {return 0;}


			




	93
	93
	
		
  };


			




	94
	94
	
		

			




	95
	95
	
		

			




	...
	...
	
		
@@ -114,13 +114,13 @@


			




	114
	114
	
		
    ///


			




	115
	115
	
		
    typedef _SubCounter<Counter> SubCounter;


			




	116
	116
	
		
    ///\e


			




	117
	117
	
		

			




	118
	118
	
		
    ///\todo document please.


			




	119
	119
	
		
    ///


			




	120
	
	
		
    typedef _SubNoCounter<Counter> SubNoCounter;


			




	
	120
	
		
    typedef _NoSubCounter<Counter> NoSubCounter;


			




	121
	121
	
		

			




	122
	122
	
		
    ///\e


			




	123
	123
	
		
    Counter() : _title(), _os(std::cerr), count(0) {}


			




	124
	124
	
		
    ///\e


			




	125
	125
	
		
    Counter(std::string title,std::ostream &os=std::cerr) 


			




	126
	126
	
		
      : _title(title), _os(os), count(0) {}


			




	...
	...
	
		
@@ -153,14 +153,14 @@


			




	153
	153
	
		

			




	154
	154
	
		
  ///'Do nothing' version of \ref Counter.


			




	155
	155
	
		
  ///\sa Counter


			




	156
	156
	
		
  class NoCounter


			




	157
	157
	
		
  {


			




	158
	158
	
		
  public:


			




	159
	
	
		
    typedef _SubNoCounter<NoCounter> SubCounter;


			




	160
	
	
		
    typedef _SubNoCounter<NoCounter> SubNoCounter;


			




	
	159
	
		
    typedef _NoSubCounter<NoCounter> SubCounter;


			




	
	160
	
		
    typedef _NoSubCounter<NoCounter> NoSubCounter;


			




	161
	161
	
		

			




	162
	162
	
		
    NoCounter() {}


			




	163
	163
	
		
    NoCounter(std::string,std::ostream &) {}


			




	164
	164
	
		
    NoCounter(const char *,std::ostream &) {}


			




	165
	165
	
		
    NoCounter(std::string) {}


			




	166
	166
	
		
    NoCounter(const char *) {}


			




        

    






    
    



    


    

     
    
0 comments (0 inline)