diff options
author | Noel Grandin <noel@peralex.com> | 2014-10-06 14:48:16 +0200 |
---|---|---|
committer | Stephan Bergmann <sbergman@redhat.com> | 2014-10-13 17:45:57 +0200 |
commit | af5ebbf7835441c767f91a620f109ee6722e57bd (patch) | |
tree | c72b2a1ddb5aa0a0a369be7babd516a5592d5fac /include/o3tl | |
parent | 1156d11ef0bb2bc3d71ae9299656db4fed66f073 (diff) |
create a macro library for implementing bit-flags types
Signed-off-by: Stephan Bergmann <sbergman@redhat.com>,
changed from a macro- to a template-based solution. (Unfortunately MSVC 2012
does not support explicit conversion operators. Worked around that with
explicit #ifs rather than some HAVE_EXPLICIT_CONVERSION_OPERATORS and
SAL_EXPLICIT_CONVERSION_OPERATOR ainticipating we hopefully soon move to a
baseline that requires unconditional support for them.)
Change-Id: I4a89643b218d247e8e4a861faba458ec6dfe1396
Diffstat (limited to 'include/o3tl')
-rw-r--r-- | include/o3tl/typed_flags_set.hxx | 208 |
1 files changed, 208 insertions, 0 deletions
diff --git a/include/o3tl/typed_flags_set.hxx b/include/o3tl/typed_flags_set.hxx new file mode 100644 index 000000000000..baa679354de5 --- /dev/null +++ b/include/o3tl/typed_flags_set.hxx @@ -0,0 +1,208 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you 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 . + */ + +#ifndef INCLUDED_O3TL_TYPED_FLAGS_SET_HXX +#define INCLUDED_O3TL_TYPED_FLAGS_SET_HXX + +#include <sal/config.h> + +#include <cassert> +#include <type_traits> + +namespace o3tl { + +template<typename T> struct typed_flags {}; + +/// Mark a (scoped) enumeration as a set of bit flags, with accompanying +/// operations. +/// +/// template<> +/// struct o3tl::typed_flags<TheE>: o3tl::is_typed_flags<TheE, TheM> {}; +/// +/// All relevant values must be non-negative. (Typically, the enumeration's +/// underlying type will either be fixed and unsigned, or it will be unfixed--- +/// and can thus default to a signed type---and all enumerators will have non- +/// negative values.) +/// +/// \param E the enumeration type. +/// \param M the all-bits-set value for the bit flags. +template<typename E, typename std::underlying_type<E>::type M> +struct is_typed_flags { + static_assert( + M >= 0, "is_typed_flags expects only non-negative bit values"); + + class Self { + public: + explicit Self(typename std::underlying_type<E>::type value): + value_(value) + { assert(value >= 0); } + + operator E() { return static_cast<E>(value_); } + +#if !defined _MSC_VER || _MSC_VER > 1700 + explicit +#endif + operator typename std::underlying_type<E>::type() { return value_; } + +#if !defined _MSC_VER || _MSC_VER > 1700 + explicit +#endif + operator bool() { return value_ != 0; } + + private: + typename std::underlying_type<E>::type value_; + }; + + static typename std::underlying_type<E>::type const mask = M; +}; + +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator ~(E rhs) { + assert(static_cast<typename std::underlying_type<E>::type>(rhs) >= 0); + return static_cast<typename o3tl::typed_flags<E>::Self>( + o3tl::typed_flags<E>::mask + & ~static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator ~( + typename o3tl::typed_flags<E>::Self rhs) +{ + return static_cast<typename o3tl::typed_flags<E>::Self>( + o3tl::typed_flags<E>::mask + & ~static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator &(E lhs, E rhs) { + assert(static_cast<typename std::underlying_type<E>::type>(lhs) >= 0); + assert(static_cast<typename std::underlying_type<E>::type>(rhs) >= 0); + return static_cast<typename o3tl::typed_flags<E>::Self>( + static_cast<typename std::underlying_type<E>::type>(lhs) + & static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator &( + E lhs, typename o3tl::typed_flags<E>::Self rhs) +{ + assert(static_cast<typename std::underlying_type<E>::type>(lhs) >= 0); + return static_cast<typename o3tl::typed_flags<E>::Self>( + static_cast<typename std::underlying_type<E>::type>(lhs) + & static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator &( + typename o3tl::typed_flags<E>::Self lhs, E rhs) +{ + assert(static_cast<typename std::underlying_type<E>::type>(rhs) >= 0); + return static_cast<typename o3tl::typed_flags<E>::Self>( + static_cast<typename std::underlying_type<E>::type>(lhs) + & static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator &( + typename o3tl::typed_flags<E>::Self lhs, + typename o3tl::typed_flags<E>::Self rhs) +{ + return static_cast<typename o3tl::typed_flags<E>::Self>( + static_cast<typename std::underlying_type<E>::type>(lhs) + & static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator |(E lhs, E rhs) { + assert(static_cast<typename std::underlying_type<E>::type>(lhs) >= 0); + assert(static_cast<typename std::underlying_type<E>::type>(rhs) >= 0); + return static_cast<typename o3tl::typed_flags<E>::Self>( + static_cast<typename std::underlying_type<E>::type>(lhs) + | static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator |( + E lhs, typename o3tl::typed_flags<E>::Self rhs) +{ + assert(static_cast<typename std::underlying_type<E>::type>(lhs) >= 0); + return static_cast<typename o3tl::typed_flags<E>::Self>( + static_cast<typename std::underlying_type<E>::type>(lhs) + | static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator |( + typename o3tl::typed_flags<E>::Self lhs, E rhs) +{ + assert(static_cast<typename std::underlying_type<E>::type>(rhs) >= 0); + return static_cast<typename o3tl::typed_flags<E>::Self>( + static_cast<typename std::underlying_type<E>::type>(lhs) + | static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator |( + typename o3tl::typed_flags<E>::Self lhs, + typename o3tl::typed_flags<E>::Self rhs) +{ + return static_cast<typename o3tl::typed_flags<E>::Self>( + static_cast<typename std::underlying_type<E>::type>(lhs) + | static_cast<typename std::underlying_type<E>::type>(rhs)); +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator &=(E & lhs, E rhs) { + assert(static_cast<typename std::underlying_type<E>::type>(lhs) >= 0); + assert(static_cast<typename std::underlying_type<E>::type>(rhs) >= 0); + lhs = lhs & rhs; + return lhs; +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator &=( + E & lhs, typename o3tl::typed_flags<E>::Self rhs) +{ + assert(static_cast<typename std::underlying_type<E>::type>(lhs) >= 0); + lhs = lhs & rhs; + return lhs; +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator |=(E & lhs, E rhs) { + assert(static_cast<typename std::underlying_type<E>::type>(lhs) >= 0); + assert(static_cast<typename std::underlying_type<E>::type>(rhs) >= 0); + lhs = lhs | rhs; + return lhs; +} + +template<typename E> +inline typename o3tl::typed_flags<E>::Self operator |=( + E & lhs, typename o3tl::typed_flags<E>::Self rhs) +{ + assert(static_cast<typename std::underlying_type<E>::type>(lhs) >= 0); + lhs = lhs | rhs; + return lhs; +} + +#endif /* INCLUDED_O3TL_TYPED_FLAGS_SET_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |