ScopeDatatypes.h

Go to the documentation of this file.

#pragma once
#include "ScopeDefines.h"

namespace scope {

enum ControllerReturnStatus {
    none = 0x0,
    stopped = 0x01,
    finished = 0x02,
    error = 0x04
};

enum FPUMoveDirection {
    left,
    right,
    up,
    down
};


template<class T>
class ScopeDatatypeBase {
public:
    typename T::Mode t;

public:
    static std::wstring NameOf(const typename T::Mode& _t) { return T::NameOf(_t); }

    static std::wstring NameOf(const uint32_t& _n) { return T::NameOf(_n); }


    ScopeDatatypeBase()
        : t(T::Mode(0)) { }

    ScopeDatatypeBase(const typename T::Mode& _t)
        : t(_t) { }

    ScopeDatatypeBase(const std::wstring& _str)
        : t(T::Mode(0)) {
        for ( uint32_t s = 0 ; s < T::S ; s++ ) {
            if ( _str == T::NameOf(s) ) {
                t = T::Mode(s);
                break;
            }
        }
    }

    ScopeDatatypeBase& operator=(const typename T::Mode& _t) { t = _t; return *this; }
    bool operator==(const ScopeDatatypeBase& _sdb) const { return t == static_cast<typename T::Mode>(_sdb); }
    bool operator==(const typename T::Mode& _t) const { return t == _t; }
    bool operator!=(const ScopeDatatypeBase& _sdb) const { return !(operator==(_sdb)); }
    bool operator!=(const typename T::Mode& _t) const { return !(operator==(_t)); }
    bool operator<(const ScopeDatatypeBase& _sdb) const { return t < static_cast<typename T::Mode>(_sdb); }
    bool operator>(const ScopeDatatypeBase& _sdb) const { return t > static_cast<typename T::Mode>(_sdb); }
    operator typename T::Mode() const { return t; }
    operator uint32_t() const { return static_cast<uint32_t>(t); }
    operator std::wstring() const { return T::NameOf(t); }
};

class ZDeviceHelper {
public:
    enum Mode {
        ZStage,
        FastZ
    };

    static const uint32_t S = 2;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names = { L"ZStage", L"FastZ" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<ZDeviceHelper> ZDevice;


class BehaviorModeHelper {
public:
    enum Mode {
        Gated
    };

    static const uint32_t S = 1;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names = { L"Gated" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<BehaviorModeHelper> BehaviorMode;


class DaqTimingHelper {
public:
    enum Mode  {
        OnboardClock,
        ReferenceClock,
        External
    };

    static const uint32_t S = 3;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names = { L"OnboardClock", L"ReferenceClock", L"External" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<DaqTimingHelper> DaqTiming;


class Uint16RangeHelper {
public:
    enum Mode {
        full,
        firsthalf,
        secondhalf,
        first4096
    };

    static const uint32_t S = 4;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names = { L"full", L"firsthalf", L"secondhalf", L"first4096" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<Uint16RangeHelper> Uint16Range;


uint16_t Uint16LowerBoundary(const Uint16Range& r);
uint16_t Uint16UpperBoundary(const Uint16Range& r);
class OutputsTypeHelper {
public:
    enum Mode {
        OutputsDAQmx,
        OutputsDAQmxLineClock,
        OutputsDAQmxSlave,
        OutputsDAQmxResonance
    };

    static const uint32_t S = 4;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names = { L"OutputsDAQmx", L"OutputsDAQmxLineClock", L"OutputsDAQmxSlave", L"OutputsDAQmxResonance" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<OutputsTypeHelper> OutputsType;


class InputsTypeHelper {
public:
    enum Mode {
        InputsDAQmx,
        InputsFPGA,
        InputsFPGAIO6587,
        InputsFPGADigitalDemultiplexer,
        InputsFPGAPhotonCounter,
        InputsFPGAIO5771,
        InputsFPGAIO5751,
        InputsFPGAAnalogDemultiplexer,
        InputsFPGAAnalogIntegrator,
        InputsFPGAResonanceScanner
    };

    static const uint32_t S = 10;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names =
            { L"InputsDAQmx"
            , L"InputsFPGA"
            , L"InputsFPGAIO6587"
            , L"InputsFPGADigitalDemultiplexer"
            , L"InputsFPGAPhotonCounter"
            , L"InputsFPGAIO5771"
            , L"InputsFPGAIO5751"
            , L"InputsFPGAAnalogDemultiplexer"
            , L"InputsFPGAAnalogIntegrator"
            , L"InputsFPGAResonanceScanner" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<InputsTypeHelper> InputsType;


class ScannerTypeHelper {
public:
    enum Mode {
        Regular,
        Resonance,
        AOD,
        Fiber
    };

    static const uint32_t S = 4;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names =
            { L"Regular"
            , L"Resonance"
            , L"AOD"
            , L"Fiber" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<ScannerTypeHelper> ScannerType;

class ScannerVectorTypeHelper {
public:
    enum Mode {
        Basic,
        Sawtooth,
        Bidirectional,
        Planehopper,
        LineStraight,
        ResonanceBiDi,
        ResonanceHopper
    };

    static const uint32_t S = 7;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names =
            { L"Basic"
            , L"Sawtooth"
            , L"Bidirectional"
            , L"Planehopper"
            , L"LineStraight"
            , L"ResonanceBiDi"
            , L"ResonanceHopper" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<ScannerVectorTypeHelper> ScannerVectorType;


class ScannerSupportedVectors {
public:
    static std::vector<ScannerVectorTypeHelper::Mode> List(const ScannerTypeHelper::Mode& _scannertype = SCOPE_SCANNERTYPE);

    static bool IsSupported(const ScannerVectorTypeHelper::Mode& _scanmode, const ScannerTypeHelper::Mode& _scannertype = SCOPE_SCANNERTYPE);

    static bool IsBuiltinSupported(const ScannerVectorTypeHelper::Mode& _scanmode);
};


class ScannerVectorFillTypeHelper {
public:
    enum Mode {
        FullframeXYZP,
        LineXPColumnYZ,
        LineZP
    };

    static const uint32_t S = 3;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names = { L"FullframeXYZP", L"LineXPColumnYZ", L"LineZP" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<ScannerVectorFillTypeHelper> ScannerVectorFillType;


class RunStateHelper {
public:
    enum Mode {
        Stopped,
        RunningContinuous,
        RunningSingle,
        RunningStack,
        RunningTimeseries,
        RunningBehavior
    };

    static const uint32_t S = 6;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names = { L"Stopped", L"RunningContinuous", L"RunningSingle", L"RunningStack", L"RunningTimeseries", L"RunningBehavior" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<RunStateHelper> RunState;


class DaqModeHelper {
public:
    enum Mode {
        continuous,
        nframes
    };

    static const uint32_t S = 2;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names = { L"continuous", L"nframes" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<DaqModeHelper> DaqMode;

class DaqSamplingHelper {
public:
    enum Mode {
        SimultaneousSampling,
        NonSimultaneousSampling
    };

    static const uint32_t S = 2;

    static std::wstring NameOf(const uint32_t& _n) {
        static std::array<std::wstring, S> names = { L"SimultaneousSampling", L"NonSimultaneousSampling" };
        return names[_n];
    }
};

typedef ScopeDatatypeBase<DaqSamplingHelper> DaqSampling;


}