counter.h

Go to the documentation of this file.

// Copyright (C) 2006-2014 David Sugar, Tycho Softworks.
// Copyright (C) 2015 Cherokees of Idaho.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef _UCOMMON_COUNTER_H_
#define _UCOMMON_COUNTER_H_
 
#ifndef _UCOMMON_CONFIG_H_
#include <ucommon/platform.h>
#endif
 
namespace ucommon {
 
class __EXPORT counter
{
private:
    unsigned value, cycle;
 
public:
    counter();
 
    counter(unsigned limit);
 
    unsigned get(void);
 
    inline unsigned range(void) {
        return cycle;
    }
 
    inline unsigned operator*() {
        return get();
    }
 
    inline operator unsigned() {
        return get();
    }
 
    void operator=(unsigned value);
};
 
class __EXPORT SeqCounter : protected counter
{
private:
    void *item;
    size_t offset;
 
protected:
    SeqCounter(void *start, size_t size, unsigned count);
 
    void *get(void);
 
    void *get(unsigned idx);
 
public:
    inline void operator=(unsigned inc_offset) {
        counter::operator=(inc_offset);
    }
};
 
class __EXPORT toggle
{
private:
    bool value;
 
public:
    inline toggle() {
        value = false;
    }
 
    bool get(void);
 
    inline bool operator*() {
        return get();
    }
 
    inline void operator=(bool v) {
        value = v;
    }
 
    inline operator bool() {
        return value;
    }
};
 
template <class T>
class sequence : public SeqCounter
{
protected:
    inline T *get(unsigned idx) {
        return static_cast<T *>(SeqCounter::get(idx));
    }
 
public:
    inline sequence(T *array, unsigned size) :
        SeqCounter(array, sizeof(T), size) {}
 
    inline T* get(void) {
        return static_cast<T *>(SeqCounter::get());
    }
 
    inline T& operator*() {
        return reference_cast<T&>(SeqCounter::get());
    }
 
    inline operator T&() {
        return reference_cast<T&>(SeqCounter::get());
    }
 
    inline T& operator[](unsigned offset) {
        return reference_cast<T&>(get(offset));
    }
};
 
typedef counter counter_t;
 
typedef toggle toggle_t;
 
} // namespace ucommon
 
#endif