Class Block

develop/matchit/patterns.h:798–855

        {
        private:
            class Block
            {
            public:
                ValueVariant<Type> mVariant;
                int32_t mDepth;

                constexpr auto &variant() { return mVariant; }
                constexpr auto hasValue() const
                {
                    return std::visit(overload([](Type const &)
                                               { return true; },
                                               [](Type const *)
                                               { return true; },
                                               [](std::monostate const &)
                                               { return false; }),
                                      mVariant);
                }
                constexpr decltype(auto) value() const
                {
                    return std::visit(
                        overload([](Type const &v) -> Type const & { return v; },
                                 [](Type const *p) -> Type const & { return *p; },
                                 [](std::monostate const &) -> Type const & {
                                     throw std::logic_error("invalid state!");
                                 }),
                        mVariant);
                }

                constexpr decltype(auto) mutableValue()
                {
                    return std::visit(
                        overload([](Type &v) -> Type & { return v; },
                                 [](Type const *) -> Type & {
                                     throw std::logic_error(
                                         "Cannot get mutableValue for pointer type!");
                                 },
                                 [](std::monostate &) -> Type & {
                                     throw std::logic_error("Invalid state!");
                                 }),
                        mVariant);
                }
                constexpr void reset(int32_t depth)
                {
                    if (mDepth - depth >= 0)
                    {
                        mVariant = {};
                        mDepth = depth;
                    }
                }
                constexpr void confirm(int32_t depth)
                {
                    if (mDepth > depth || mDepth == 0)
                    {
                        assert(depth == mDepth - 1 || depth == mDepth || mDepth == 0);
                        mDepth = depth;
                    }
                }
            };