enums.hpp

#ifndef ENUMS_HPP
#define ENUMS_HPP
 
#include <cstdint>
#include <unordered_map>
 
 
namespace sys_sage {
 
 
    namespace ComponentType{
        using type = int32_t;
 
        constexpr type None = 1; 
        constexpr type Thread = 2; 
        constexpr type Core = 3; 
        constexpr type Cache = 4; 
        constexpr type Subdivision = 5; 
        constexpr type Numa = 6; 
        constexpr type Chip = 7; 
        constexpr type Memory = 8; 
        constexpr type Storage = 9; 
        constexpr type Node = 10; 
        constexpr type QuantumBackend = 11; 
        constexpr type AtomSite = 12; 
        constexpr type Qubit = 13; 
        constexpr type Topology = 14; 
        //SVTODO this should remain private???
        static const std::unordered_map<type, const char*> names = {
            {None, "GenericComponent"},
            {Thread, "HW_Thread"},
            {Core, "Core"},
            {Cache, "Cache"},
            {Subdivision, "Subdivision"},
            {Numa, "NUMA"},
            {Chip, "Chip"},
            {Memory, "Memory"},
            {Storage, "Storage"},
            {Node, "Node"},
            {QuantumBackend, "QuantumBackend"},
            {AtomSite, "AtomSite"},
            {Qubit, "Qubit"},
            {Topology, "Topology"}
        };
 
        inline const char* ToString(type rt) {
            auto it = names.find(rt);
            if (it != names.end()) return it->second;
            return "Unknown";
        }
    }
 
    namespace SubdivisionType {
        using type = int32_t;
 
        constexpr type None = 1; 
        constexpr type GpuSM = 2; 
    }
 
    namespace ChipType {
        using type = int32_t;
 
        constexpr type None = 1; 
        constexpr type Cpu = 2; 
        constexpr type CpuSocket = 3; 
        constexpr type Gpu = 4; 
    }
 
 
    namespace RelationType{
        using type = int32_t;
 
        constexpr type Any = -1;
        constexpr type Relation = 0;
        constexpr type DataPath = 1;
        constexpr type QuantumGate = 2;
        constexpr type CouplingMap = 3;
        constexpr type _num_relation_types = 4;
 
        constexpr type RelationTypeList [_num_relation_types] = {
            Relation, 
            DataPath, 
            QuantumGate, 
            CouplingMap
        };
 
        //SVTODO this should remain private???
        static const std::unordered_map<type, const char*> names = {
            {Any, "Any"},
            {Relation, "Relation"},
            {DataPath, "DataPath"},
            {QuantumGate, "QuantumGate"},
            {CouplingMap, "CouplingMap"}
        };
 
        inline const char* ToString(type rt) {
            auto it = names.find(rt);
            if (it != names.end()) return it->second;
            return "Unknown";
        }
    }
 
    namespace DataPathType{
        using type = int32_t;
 
        constexpr type Any = 1;
        constexpr type None = 0; 
        constexpr type Logical = 1; 
        constexpr type Physical = 2; 
        constexpr type Datatransfer = 3; 
        constexpr type L3CAT = 4; 
        constexpr type MIG = 5; 
        constexpr type C2C = 6; 
    }
    namespace DataPathDirection{
        using type = int32_t;
 
        constexpr type Any = 1;
        constexpr type Outgoing = 2; 
        constexpr type Incoming = 3; 
    }
 
    //SVTODO rename this to RelationOrientation? oriented x not oriented and include this also into general Relation, rather than just DataPath?
    namespace DataPathOrientation{
        using type = int32_t;
 
        constexpr type Oriented = 1; 
        constexpr type Bidirectional = 2; 
    }
    namespace QuantumGateType{
        using type = int32_t;
 
        constexpr type Unknown = 0; 
        constexpr type Id = 1; 
        constexpr type X = 2; 
        constexpr type Rz = 3; 
        constexpr type Cnot = 4; 
        constexpr type Sx = 5; 
        constexpr type Toffoli = 6; 
        //SVTODO this should remain private???
        static const std::unordered_map<type, const char*> names = {
            {Unknown, "Unknown"},
            {Id, "Id"},
            {X, "X"},
            {Rz, "Rz"},
            {Cnot, "Cnot"},
            {Sx, "Sx"},
            {Toffoli, "Toffoli"}
        };
 
        inline const char* ToString(type rt) {
            auto it = names.find(rt);
            if (it != names.end()) return it->second;
            return "Unknown";
        }
    }
 
 
}
#endif //ENUMS_HPP