mlStringSwitch.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2013, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_STRING_SWITCH_H
#define ML_STRING_SWITCH_H
 
#include "mlTypeDefs.h"
 
#include <stdexcept>
#include <exception>
#include <string>
#include <cstring>
 
ML_START_NAMESPACE
 
template<typename T, typename R = T>
class StringSwitch
{
public:
  explicit StringSwitch(const std::string& s)
    : _string(s)
    , _result(nullptr)
  {}
 
  explicit StringSwitch(const char* s)
    : _string(s)
    , _result(nullptr)
  {}
 
  template<unsigned N>
  StringSwitch& Case(const char (&s)[N], const T& Value)
  {
    if (!_result
      && N-1 == _string.size()
      && (std::memcmp(s, _string.c_str(), N-1) == 0))
    {
      _result = &Value;
    }
 
    return *this;
  }
 
  StringSwitch& Case(const std::string& s, const T& Value)
  {
    if (!_result && s == _string)
    {
      _result = &Value;
    }
 
    return *this;
  }
 
 
  template<unsigned N>
  StringSwitch& EndsWith(const char (&s)[N], const T &Value)
  {
    if (!_result
      && _string.size() >= N-1
      && std::memcmp(s, _string.c_str() + _string.size() + 1 - N, N-1) == 0)
    {
      _result = &Value;
    }
 
    return *this;
  }
 
  template<unsigned N>
  StringSwitch& StartsWith(const char (&s)[N], const T &Value)
  {
    if (!_result
      && _string.size() >= N-1
      && std::memcmp(s, _string.c_str(), N-1) == 0)
    {
      _result = &Value;
    }
 
    return *this;
  }
 
  template<unsigned N0, unsigned N1>
  StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1], const T& Value)
  {
    return Case(S0, Value).Case(S1, Value);
  }
 
  template<unsigned N0, unsigned N1, unsigned N2>
  StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1], const char (&S2)[N2], const T& Value)
  {
    return Case(S0, Value).Case(S1, Value).Case(S2, Value);
  }
 
  template<unsigned N0, unsigned N1, unsigned N2, unsigned N3>
  StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1], const char (&S2)[N2], const char (&S3)[N3], const T& Value)
  {
    return Case(S0, Value).Case(S1, Value).Case(S2, Value).Case(S3, Value);
  }
 
  template<unsigned N0, unsigned N1, unsigned N2, unsigned N3, unsigned N4>
  StringSwitch& Cases(const char (&S0)[N0], const char (&S1)[N1], const char (&S2)[N2], const char (&S3)[N3], const char (&S4)[N4], const T& Value)
  {
    return Case(S0, Value).Case(S1, Value).Case(S2, Value).Case(S3, Value).Case(S4, Value);
  }
 
  R Default(const T& Value) const
  {
    if (_result)
    {
      return *_result;
    }
    return Value;
  }
 
  template<typename Ex, typename ExP1>
  R Throw(const ExP1& p1) const
  {
    if (_result)
    {
      return *_result;
    }
    throw Ex(p1);
  }
 
  template<typename Ex, typename ExP1, typename ExP2>
  R Throw(const ExP1& p1, const ExP2& p2) const
  {
    if (_result)
    {
      return *_result;
    }
    throw Ex(p1, p2);
  }
 
  template<typename Ex, typename ExP1, typename ExP2, typename ExP3>
  R Throw(const ExP1& p1, const ExP2& p2, const ExP3& p3) const
  {
    if (_result)
    {
      return *_result;
    }
    throw Ex(p1, p2, p3);
  }
 
  operator R() const
  {
    if (!_result)
    {
      throw std::domain_error("Fell off the end of the string switch");
    }
    return *_result;
  }
 
private:
  const std::string _string;
 
  const T *_result;
};
 
ML_END_NAMESPACE
 
#endif