SourceFlags.h

Go to the documentation of this file.

/*
 * SourceFlags.h
 *
 *  Created on: Oct 19, 2018
 *      Author: Alejandro Alvarez Ayllon
 */

#ifndef _SEFRAMEWORK_SOURCE_SOURCEFLAGS_H_
#define _SEFRAMEWORK_SOURCE_SOURCEFLAGS_H_

#include <stdint.h>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#include <type_traits>

namespace SourceXtractor {

enum class Flags : int64_t {
  NONE              = 0,         
  BIASED            = 1ll << 0,  
  BLENDED           = 1ll << 1,  
  SATURATED         = 1ll << 2,  
  BOUNDARY          = 1ll << 3,  
  NEIGHBORS         = 1ll << 4,  
  OUTSIDE           = 1ll << 5,  
  PARTIAL_FIT       = 1ll << 6,  
  INSUFFICIENT_DATA = 1ll << 7,  
  ERROR             = 1ll << 10, 
  MEMORY            = 1ll << 11, 
  BAD_PROJECTION    = 1ll << 12, 
  DOWNSAMPLED       = 1ll << 13, 
  SENTINEL          = 1ll << 14, 
};

const std::map<Flags, std::string> FlagsStr = {
  {Flags::NONE, "NONE"},
  {Flags::BIASED, "BIASED"},
  {Flags::BLENDED, "BLENDED"},
  {Flags::BOUNDARY, "BOUNDARY"},
  {Flags::NEIGHBORS, "NEIGHBORS"},
  {Flags::OUTSIDE, "OUTSIDE"},
  {Flags::PARTIAL_FIT, "PARTIAL_FIT"},
  {Flags::INSUFFICIENT_DATA, "INSUFFICIENT_DATA"},
  {Flags::ERROR, "ERROR"},
  {Flags::MEMORY, "MEMORY"},
  {Flags::BAD_PROJECTION, "BAD_PROJECTION"},
  {Flags::DOWNSAMPLED, "DOWNSAMPLED"}
};


constexpr inline Flags operator|(const Flags &a, const Flags &b) {
  typedef typename std::underlying_type<Flags>::type base_int_t;
  return static_cast<Flags>(static_cast<base_int_t>(a) | static_cast<base_int_t>(b));
}

constexpr inline Flags operator&(const Flags &a, const Flags &b) {
  typedef typename std::underlying_type<Flags>::type base_int_t;
  return static_cast<Flags>(static_cast<base_int_t>(a) & static_cast<base_int_t>(b));
}

constexpr Flags operator*(const Flags &a, const bool b) {
  return b ? a : Flags::NONE;
}

inline Flags &operator|=(Flags &a, const Flags &b) {
  a = a | b;
  return a;
}

constexpr inline int64_t flags2long(const Flags &a) {
  return static_cast<int64_t>(a);
}

inline std::vector<int64_t> flags2long(const std::vector<Flags> &v) {
  std::vector<int64_t> vl;
  for (auto a : v) {
    vl.emplace_back(flags2long(a));
  }
  return vl;
}

inline std::ostream& operator<<(std::ostream& out, Flags flags) {
  std::underlying_type<Flags>::type i;
  bool some_printed = false;
  for (i = static_cast<decltype(i)>(Flags::BIASED);
       i < static_cast<decltype(i)>(Flags::SENTINEL); i <<= 1) {
    if ((flags & static_cast<Flags>(i)) != Flags::NONE) {
      if (some_printed)
        out << " | ";
      else
        out << "(";
      out << FlagsStr.at(static_cast<Flags>(i));
      some_printed = true;
    }
  }
  if (some_printed)
    out << ")";
  else
    out << "NONE";
  return out;
}

} // end SourceXtractor

#endif // _SEFRAMEWORK_SOURCE_SOURCEFLAGS_H_