ScopeValue.cpp

#include "StdAfx.h"
#include "ScopeValue.h"

namespace scope {

template<>
void ScopeValue<bool>::SetFromString(const std::wstring& str) {
    Set( (str == L"true") );
}

template<>
void ScopeValue<Uint16Range>::SetFromString(const std::wstring& str) {
    Set(Uint16Range(str));
}

template<>
void ScopeValue<ScannerType>::SetFromString(const std::wstring& str) {
    Set(ScannerType(str));
}

template<>
void ScopeValue<ScannerVectorType>::SetFromString(const std::wstring& str) {
    Set(ScannerVectorType(str));
}

template<>
void ScopeValue<RunState>::SetFromString(const std::wstring& str) {
    Set(RunState(str));
}

template<>
void ScopeValue<ZDevice>::SetFromString(const std::wstring& str) {
    Set(ZDevice(str));
}

template<>
void ScopeValue<BehaviorMode>::SetFromString(const std::wstring& str) {
    Set(BehaviorMode(str));
}

template<>
void ScopeValue<DaqMode>::SetFromString(const std::wstring& str) {
    Set(DaqMode(str));
}

template<>
void ScopeValue<DaqTiming>::SetFromString(const std::wstring& str) {
    Set(DaqTiming(str));
}

template<>
void ScopeValue<DaqSampling>::SetFromString(const std::wstring& str) {
    Set(DaqSampling(str));
}

template<>
void ScopeValue<double>::SetFromString(const std::wstring& str) {
    double tmp = 0.0;
    Set( !(std::wstringstream(str) >> tmp) ? 0.0 : tmp );           // operator! returns failbit, if failbit==false return tmp
}

template<>
void ScopeValue<uint8_t>::SetFromString(const std::wstring& str) {
    uint16_t tmp = 0;       // Workaround, using uint8_t (which is unsigned char!) gives problems
    Set( !(std::wstringstream(str) >> tmp) ? 0 : tmp );             // operator! returns failbit, if failbit==false return tmp
}

template<>
void ScopeValue<uint16_t>::SetFromString(const std::wstring& str) {
    uint16_t tmp = 0;
    Set( !(std::wstringstream(str) >> tmp) ? 0 : tmp );             // operator! returns failbit, if failbit==false return tmp
}

template<>
void ScopeValue<int32_t>::SetFromString(const std::wstring& str) {
    int32_t tmp = 0;
    Set( !(std::wstringstream(str) >> tmp) ? 0 : tmp );             // operator! returns failbit, if failbit==false return tmp
}

template<>
void ScopeValue<uint32_t>::SetFromString(const std::wstring& str) {
    uint32_t tmp = 0;
    Set( !(std::wstringstream(str) >> tmp) ? 0 : tmp );             // operator! returns failbit, if failbit==false return tmp
}

template<>
void ScopeValue<uint64_t>::SetFromString(const std::wstring& str) {
    uint64_t tmp = 0;
    Set( !(std::wstringstream(str) >> tmp) ? 0 : tmp );             // operator! returns failbit, if failbit==false return tmp
}

template<>
void ScopeValue<std::wstring>::SetFromString(const std::wstring& str) {
    Set(str);
}



template<>
std::wstring ScopeValue<bool>::ToChar() const {
    return (Value())?L"true":L"false";
}

template<>
std::wstring ScopeValue<Uint16Range>::ToChar() const {
    return Value().operator std::wstring();
}

template<>
std::wstring ScopeValue<ScannerType>::ToChar() const {
    return Value().operator std::wstring();
}

template<>
std::wstring ScopeValue<ScannerVectorType>::ToChar() const {
    return Value().operator std::wstring();
}

template<>
std::wstring ScopeValue<RunState>::ToChar() const {
    return Value().operator std::wstring();
}

template<>
std::wstring ScopeValue<ZDevice>::ToChar() const {
    return Value().operator std::wstring(); 
}

template<>
std::wstring ScopeValue<BehaviorMode>::ToChar() const {
    return Value().operator std::wstring(); 
}

template<>
std::wstring ScopeValue<DaqMode>::ToChar() const {
    return Value().operator std::wstring(); 
}

template<>
std::wstring ScopeValue<DaqSampling>::ToChar() const {
    return Value().operator std::wstring();
}

template<>
std::wstring ScopeValue<DaqTiming>::ToChar() const {
    return Value().operator std::wstring();
}

template<>
std::wstring ScopeValue<double>::ToChar() const {
    std::wstringstream stream;
    stream << Value();
    return stream.str();
}

template<>
std::wstring ScopeValue<uint8_t>::ToChar() const {
    std::wstringstream stream;
    stream << Value();
    return stream.str();
}

template<>
std::wstring ScopeValue<uint16_t>::ToChar() const {
    std::wstringstream stream;
    stream << Value();
    return stream.str();
}

template<>
std::wstring ScopeValue<int32_t>::ToChar() const {
    std::wstringstream stream;
    stream << Value();
    return stream.str();
}

template<>
std::wstring ScopeValue<uint32_t>::ToChar() const {
    std::wstringstream stream;
    stream << Value();
    return stream.str();
}

template<>
std::wstring ScopeValue<uint64_t>::ToChar() const {
    std::wstringstream stream;
    stream << Value();
    return stream.str();
}

template<>
std::wstring ScopeValue<std::wstring>::ToChar() const {
    return Value();
}

}