EnumIface.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2016 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
*/
#ifndef GZ_COMMON_ENUMITERATOR_HH_
#define GZ_COMMON_ENUMITERATOR_HH_
 
#include <iterator>
#include <string>
#include <vector>
#include <algorithm>
 
#include <gz/common/Export.hh>
#include <gz/common/Util.hh>
 
namespace gz::common
{
  template<typename T>
  class EnumIface
  {
    public: EnumIface(T _start, T _end,
        const std::vector<std::string> &_names)
            : names(_names)
    {
      this->range[0] = _start;
      this->range[1] = _end;
    }
 
    public: T Begin()
    {
      return range[0];
    }
 
    public: T End()
    {
      return range[1];
    }
 
    public: std::string Str(T const &_e)
    {
      std::string ret;
      if (static_cast<unsigned int>(_e) < names.size())
        ret = names[static_cast<unsigned int>(_e)];
      return ret;
    }
 
    public: void Set(T &_e, const std::string &_str)
    {
      auto begin = std::begin(names);
      auto end = std::end(names);
 
      auto find = std::find(begin, end, _str);
      if (find != end)
      {
        _e = static_cast<T>(std::distance(begin, find));
      }
    }
 
    public: T range[2];
 
    public: std::vector<std::string> names;
  };
 
  template<typename Enum>
  class EnumIterator
  {
    public: using iterator_category = std::bidirectional_iterator_tag;
    public: using value_type = Enum;
    public: using difference_type = std::ptrdiff_t;
    public: using pointer = Enum*;
    public: using reference = Enum&;
 
    public: EnumIterator() = default;
 
    // cppcheck-suppress noExplicitConstructor
    public: explicit EnumIterator(const Enum &_c) : c(_c)
    {
    }
 
    public: EnumIterator &operator=(const Enum &_c)
    {
      this->c = _c;
      return *this;
    }
 
    public: EnumIterator &operator++()
    {
      this->c = static_cast<Enum>(static_cast<int>(this->c) + 1);
      return *this;
    }
 
    public: EnumIterator operator++(const int)
    {
      EnumIterator cpy(*this);
      ++*this;
      return cpy;
    }
 
    public: EnumIterator &operator--()
    {
      this->c = static_cast<Enum>(static_cast<int>(this->c) - 1);
      return *this;
    }
 
    public: EnumIterator operator--(const int)
    {
      EnumIterator cpy(*this);
      --*this;
      return cpy;
    }
 
    public: Enum operator*() const
    {
      return c;
    }
 
    public: Enum Value() const
    {
      return this->c;
    }
 
    private: Enum c;
  };
 
  template<typename Enum>
  bool operator==(EnumIterator<Enum> _e1, EnumIterator<Enum> _e2)
  {
    return _e1.Value() == _e2.Value();
  }
 
  template<typename Enum>
  bool operator!=(EnumIterator<Enum> _e1, EnumIterator<Enum> _e2)
  {
    return !(_e1 == _e2);
  }
 
  template<typename T>
  static constexpr gz::common::EnumIface<T> gzEnum(
    T _enumBegin, T _enumEnd, const std::vector<std::string> &_enumVals)
  {
    return gz::common::EnumIface<T>(_enumBegin, _enumEnd, _enumVals);
  }
}  // namespace gz::common
 
 
#define GZ_ENUM(name, enumType, begin, end, ...)  \
static auto name = gz::common::gzEnum(begin, end, {__VA_ARGS__});
 
#endif  // GZ_COMMON_ENUMITERATOR_HH_