Xor.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_QUERY_MODIFIERS_XOR_HPP_
#define ECSTASY_QUERY_MODIFIERS_XOR_HPP_
 
#include "BinaryModifier.hpp"
#include "ecstasy/query/concepts/Queryable.hpp"
#include "util/meta/add_optional.hpp"
 
namespace ecstasy::query::modifier
{
    template <bool AutoLock, Queryable Q1, Queryable Q2, Queryable... Qs>
    class XorImpl
        : public BinaryModifier<XorImpl<AutoLock, Q1, Q2, Qs...>, AutoLock, util::meta::add_optional, Q1, Q2, Qs...> {
        using ModifierClass =
            BinaryModifier<XorImpl<AutoLock, Q1, Q2, Qs...>, AutoLock, util::meta::add_optional, Q1, Q2, Qs...>;
 
      public:
        XorImpl(Q1 &firstOperand, Q2 &secondOperand, Qs &...otherOperands)
            : ModifierClass(firstOperand, secondOperand, otherOperands...)
        {
        }
 
        template <size_t operandId>
        [[nodiscard]] inline typename ModifierClass::template OperandData<operandId> getOperandData(size_t index)
        {
            auto &operand = std::get<operandId>(this->_operands);
 
            if (index < getQueryableMask(operand).size() && getQueryableMask(operand)[index])
                return getQueryableData(operand, index);
            return std::nullopt;
        }
 
        inline void reloadMask()
        {
            if constexpr (sizeof...(Qs) > 0)
                combineOperandMasks(std::make_index_sequence<(sizeof...(Qs))>());
            else {
                auto &leftOperand = std::get<0>(this->_operands);
                auto &rightOperand = std::get<1>(this->_operands);
 
                if (getQueryableMask(leftOperand).size() > getQueryableMask(rightOperand).size()) {
                    this->_mask = getQueryableMask(leftOperand);
                    this->_mask.inplaceXor(getQueryableMask(rightOperand));
                } else {
                    this->_mask = getQueryableMask(rightOperand);
                    this->_mask.inplaceXor(getQueryableMask(leftOperand));
                }
            }
        }
 
      private:
        inline void combineMask(const util::BitSet &mask)
        {
            if (this->_mask.size() < mask.size())
                this->_mask = util::BitSet(mask).inplaceXor(this->_mask);
            else
                this->_mask.inplaceXor(mask);
        }
 
        template <size_t... ints>
        inline void combineOperandMasks(std::integer_sequence<size_t, ints...> int_seq)
        {
            (void)int_seq;
            this->_mask = getQueryableMask(std::get<0>(this->_operands));
            combineMask(getQueryableMask(std::get<1>(this->_operands)));
            std::ignore = std::make_tuple((combineMask(getQueryableMask(std::get<ints + 2>(this->_operands))), 0)...);
        }
    };
 
    template <Queryable Q1, Queryable Q2, Queryable... Qs>
    [[nodiscard]] auto constexpr Xor(Q1 &firstOperand, Q2 &secondOperand, Qs &...otherOperands)
    {
        return XorImpl<false, Q1, Q2, Qs...>(firstOperand, secondOperand, otherOperands...);
    }
} // namespace ecstasy::query::modifier
 
#endif /* !ECSTASY_QUERY_MODIFIERS_XOR_HPP_ */