ErrorDefinition.h

Go to the documentation of this file.

 
#ifndef ETISS_ERRORDEFINITION_H_
#define ETISS_ERRORDEFINITION_H_
#include "etiss/Misc.h"
#include <iostream>
#include <string>
#include <vector>
 
#if defined(__GXX_EXPERIMENTAL_CXX0X) || __cplusplus >= 201103L // check if c++0x/c++11 is supported
#define ETISS_USE_CPP11 1
#else
#define ETISS_USE_CPP11 0
#endif
 
namespace etiss
{
 
namespace error
{
 
class Error
{
  public:
    const bool persistent_;
    int id_;
    std::string name_;
    Error(bool persistent, int id = -1, const std::string &name = "");
    virtual ~Error();
    virtual void apply(uint64_t &var) = 0;
    virtual void apply(uint32_t &var);
    virtual void apply(uint16_t &var);
    virtual void apply(uint8_t &var);
    virtual const std::vector<unsigned> affectedBits() = 0;
};
class Error {…};
 
class BitFlip : public Error
{
  private:
    std::vector<unsigned> flipped_positions;
    uint64_t flip;
 
  public:
    template <typename iterateableT>
    BitFlip(const iterateableT &positions, int id = -1, const std::string &name = "") : Error(false, id, name)
    {
        flip = 0;
        flipped_positions.resize(positions.size());
        for (typename iterateableT::const_iterator iter = positions.begin(); iter != positions.end(); ++iter)
        {
            flipped_positions.push_back(*iter);
            flip |= 1 << (*iter);
        }
    }
    BitFlip(const iterateableT &positions, int id = -1, const std::string &name = "") : Error(false, id, name) {…}
 
    virtual void apply(uint64_t &var);
 
    template <typename T>
    inline void fapply(T &var)
    {
        var = (T)(var ^ flip);
    }
    inline void fapply(T &var) {…}
 
    virtual const std::vector<unsigned> affectedBits();
};
class BitFlip : public Error {…};
 
class StuckHigh : public Error
{
  private:
    std::vector<unsigned> high_positions;
    uint64_t high;
 
  public:
    template <typename iterateableT>
    StuckHigh(const iterateableT &positions, int id = -1, const std::string &name = "") : Error(true, id, name)
    {
        high = 0;
        high_positions.resize(positions.size());
        for (typename iterateableT::const_iterator iter = positions.begin(); iter != positions.end(); ++iter)
        {
            high_positions.push_back(*iter);
            high |= 1 << (*iter);
        }
    }
    StuckHigh(const iterateableT &positions, int id = -1, const std::string &name = "") : Error(true, id, name) {…}
 
    virtual void apply(uint64_t &var);
 
    template <typename T>
    inline void fapply(T &var)
    {
        var = (T)(var | high);
    }
    inline void fapply(T &var) {…}
 
    virtual const std::vector<unsigned> affectedBits();
};
class StuckHigh : public Error {…};
 
class StuckLow : public Error
{
  private:
    std::vector<unsigned> low_positions;
    uint64_t low;
 
  public:
    template <typename iterateableT>
    StuckLow(const iterateableT &positions, int id = -1, const std::string &name = "") : Error(true, id, name)
    {
        low = 0;
        low_positions.resize(positions.size());
        for (typename iterateableT::const_iterator iter = positions.begin(); iter != positions.end(); ++iter)
        {
            low_positions.push_back(*iter);
            low |= 1 << (*iter);
        }
        low = ~low;
    }
    StuckLow(const iterateableT &positions, int id = -1, const std::string &name = "") : Error(true, id, name) {…}
 
    virtual void apply(uint64_t &var);
 
    template <typename T>
    inline void fapply(T &var)
    {
        var = (T)(var & low);
    }
    inline void fapply(T &var) {…}
 
    virtual const std::vector<unsigned> affectedBits();
};
class StuckLow : public Error {…};
 
} // namespace error
namespace error {…}
 
} // namespace etiss
 
#endif // ETISS_ERRORDEFINITION_H_