rcman.h

#pragma once
#include "tool/macro.h"
#include <type_traits>
 
namespace tinker {
inline namespace v1 {
template <class E>
struct EnableEnumBitMask
{
   static constexpr bool value = false;
};
}
 
#define TINKER_ENABLE_ENUM_BITMASK(x)     \
   template <>                            \
   struct EnableEnumBitMask<x>            \
   {                                      \
      static constexpr bool value = true; \
   }
 
template <class E>
constexpr typename std::enable_if<EnableEnumBitMask<E>::value, E>::type
operator|(E lhs, E rhs)
{
   using ut = typename std::underlying_type<E>::type;
   return static_cast<E>(static_cast<ut>(lhs) | static_cast<ut>(rhs));
}
 
template <class E>
constexpr bool operator&(E lhs, E rhs)
{
   using ut = typename std::underlying_type<E>::type;
   return static_cast<bool>(static_cast<ut>(lhs) & static_cast<ut>(rhs));
}
 
enum class ResourceOperation
{
   DEALLOC = 0x001, 
   ALLOC = 0x002,   
   INIT = 0x004     
};
TINKER_ENABLE_ENUM_BITMASK(ResourceOperation);
using RcOp = ResourceOperation;
 
class ResourceManagement
{
private:
   void (*m_f)(RcOp); // pointer to function void fooData(RcOp);
   RcOp m_op;
 
public:
   ResourceManagement(void (*f)(RcOp), RcOp op);
   ~ResourceManagement();
};
 
using RcMan = ResourceManagement;
 
void deviceData(RcOp);
}
 
extern "C"
{
   struct Eng;
   struct EngGradVir;
   struct EngAlyz;
   struct EngGrad;
   struct Grad;
   struct GradVir;
}
 
namespace tinker {
struct calc
{
   static constexpr int xyz = 0x001;  
   static constexpr int vel = 0x002;  
   static constexpr int mass = 0x004; 
   static constexpr int traj = 0x008; 
 
   static constexpr int energy = 0x010; 
   static constexpr int grad = 0x020;   
   static constexpr int virial = 0x040; 
   static constexpr int analyz = 0x080; 
   static constexpr int md = 0x100;     
 
   static constexpr int vmask = energy + grad + virial + analyz;
   static constexpr int v0 = energy;
   static constexpr int v1 = energy + grad + virial;
   static constexpr int v3 = energy + analyz;
   static constexpr int v4 = energy + grad;
   static constexpr int v5 = grad;
   static constexpr int v6 = grad + virial;
 
   using V0 = Eng;
   using V1 = EngGradVir;
   using V3 = EngAlyz;
   using V4 = EngGrad;
   using V5 = Grad;
   using V6 = GradVir;
 
   template <int USE>
   class Vers
   {
   public:
      static constexpr int value = USE;
      static constexpr int e = USE & calc::energy;
      static constexpr int a = USE & calc::analyz;
      static constexpr int g = USE & calc::grad;
      static constexpr int v = USE & calc::virial;
      static_assert(v ? (bool)g : true, "If calc::virial, must calc::grad.");
      static_assert(a ? (bool)e : true, "If calc::analyz, must calc::energy.");
   };
};
}
 
extern "C"
{
   struct Eng : public tinker::calc::Vers<tinker::calc::v0>
   {};
   struct EngGradVir : public tinker::calc::Vers<tinker::calc::v1>
   {};
   struct EngAlyz : public tinker::calc::Vers<tinker::calc::v3>
   {};
   struct EngGrad : public tinker::calc::Vers<tinker::calc::v4>
   {};
   struct Grad : public tinker::calc::Vers<tinker::calc::v5>
   {};
   struct GradVir : public tinker::calc::Vers<tinker::calc::v6>
   {};
}
 
//====================================================================//
//                                                                    //
//                          Global Variables                          //
//                                                                    //
//====================================================================//
 
namespace tinker {
TINKER_EXTERN int rc_flag;
}