类
struct	bitmark_for_finds
	bitmark提供了一种快速进行四种泛搜索的实现，前提是构建中的pattern中的每一项的usigned表示都在一个字节（表长）内。若bitmark构建失败，程序应当使用正在进行的泛搜索的朴素实现版本。更多...

struct	bitmark_for_quick_unindex
	bitmark提供了一种快速进行反索引的实现，前提是构建中的pattern中的每一项的usigned表示都在一个字节（表长）内。若bitmark构建失败，程序应当使用正在进行的反索引的朴素实现版本。更多...

struct	match_pattern
	sunday算法表头，用以实施头起始的快速子串匹配算法大部分情况下应当编译时预构建或对运行时生成的实例进行缓存更多...

struct	range_t
	用以表示某类型的数值范围，仅可表示闭区间更多...

struct	reverse_match_pattern
	反向Sunday算法表头，用以实施尾起始的快速子串匹配算法大部分情况下应当编译时预构建或对运行时生成的实例进行缓存更多...

函数
template<class T >
auto	size_of_array_like (range_t< T * > &a) noexcept

template<class T >
auto	size_of_array_like (range_t< const T * > &a) noexcept

template<class T >
auto	begin_of_array_like (range_t< T * > &a) noexcept

template<class T >
auto	begin_of_array_like (range_t< const T * > &a) noexcept

template<typename T >
constexpr bool	in_range (T pattern, const range_t< T >range) noexcept(noexcept((bool((::std::declval< T >())>=(::std::declval< const T >()) &&(::std::declval< T >())<=(::std::declval< const T >())))))
	判断一个值是否在某个范围内

template<typename T >
constexpr bool	in_range (T pattern, const range_t< byte >range) noexcept
	判断一个指针是否在某个byte指针范围内

template<typename T >
constexpr T *	in_range (const remove_cvref< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	in_range_size_t (const remove_cvref< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

template<typename T >
constexpr T *	in_range_but_reverse (const remove_cvref< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	in_range_but_reverse_size_t (const remove_cvref< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

template<typename T >
constexpr T *	in_range (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据串，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	in_range_size_t (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据串，返回其距离开头的步数，若未找到，返回npos

template<typename T >
constexpr T *	in_range_but_reverse (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据串，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	in_range_but_reverse_size_t (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据串，返回其距离开头的步数，若未找到，返回npos

template<typename T >
constexpr T *	find_first_of_bitmark (const bitmark_for_finds< T > &mark, array_like_view_t< T > range)
	find_first_of的bitmark实现若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr T *	base_find_first_of (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	find_first_of的朴素实现若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr T *	find_first_of (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	find_first_of_size_t (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

template<typename T >
constexpr T *	find_last_of_bitmark (const bitmark_for_finds< T > &mark, array_like_view_t< T > range)
	find_last_of的bitmark实现若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr T *	base_find_last_of (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	find_last_of的朴素实现若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr T *	find_last_of (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	find_last_of_size_t (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

template<typename T >
constexpr T *	find_first_not_of_bitmark (const bitmark_for_finds< T > &mark, array_like_view_t< T > range)
	find_first_not_of的bitmark实现若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr T *	base_find_first_not_of (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	find_first_not_of的朴素实现若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr T *	find_first_not_of (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	find_first_not_of_size_t (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到不匹配的数据项，返回其距离开头的步数，若未找到，返回npos

template<typename T >
constexpr T *	find_last_not_of_bitmark (const bitmark_for_finds< T > &mark, array_like_view_t< T > range)
	find_last_not_of的bitmark实现若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr T *	base_find_last_not_of (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	find_last_not_of的朴素实现若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr T *	find_last_not_of (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	find_last_not_of_size_t (const array_like_view_t< T > &pattern, array_like_view_t< T > range)
	若成功找到不匹配的数据项，返回其距离开头的步数，若未找到，返回npos

template<typename T >
constexpr T *	in_range (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr size_t	in_range_size_t (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr T *	in_range_but_reverse (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr size_t	in_range_but_reverse_size_t (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr T *	find_first_of (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr size_t	find_first_of_size_t (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr T *	find_last_of (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr size_t	find_last_of_size_t (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr T *	find_first_not_of (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr size_t	find_first_not_of_size_t (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr T *	find_last_not_of (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr T *	find_last_not_of_size_t (const constexpr_str_t< remove_cvref< T > > &pattern, array_like_view_t< T > range)

template<typename T >
constexpr const T *	in_range (const remove_cvref< T > &pattern, const constexpr_str_t< T > &range)
	若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	in_range_size_t (const remove_cvref< T > &pattern, const constexpr_str_t< T > &range)
	若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

template<typename T >
constexpr const T *	in_range_but_reverse (const remove_cvref< T > &pattern, const constexpr_str_t< T > &range)
	若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

template<typename T >
constexpr size_t	in_range_but_reverse_size_t (const remove_cvref< T > &pattern, const constexpr_str_t< T > &range)
	若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

函数说明

◆ base_find_first_not_of()

template<typename T >

constexpr T * elc::defs::base::range_n::base_find_first_not_of	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

find_first_not_of的朴素实现若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11468 行定义.

                                                                                                                   {
        for(auto&i : range){
            if(!in_range(i,pattern))
                return addressof(i);
        }
        return nullptr;
    }

函数调用图:

这是这个函数的调用关系图:

◆ base_find_first_of()

template<typename T >

constexpr T * elc::defs::base::range_n::base_find_first_of	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

find_first_of的朴素实现若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11389 行定义.

                                                                                                               {
        for(auto&i : range){
            if(in_range(i,pattern))
                return addressof(i);
        }
        return nullptr;
    }

函数调用图:

这是这个函数的调用关系图:

◆ base_find_last_not_of()

template<typename T >

constexpr T * elc::defs::base::range_n::base_find_last_not_of	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

find_last_not_of的朴素实现若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11508 行定义.

                                                                                                                  {
        for(auto&i : range|::std::views::reverse){
            if(!in_range(i,pattern))
                return addressof(i);
        }
        return nullptr;
    }

函数调用图:

这是这个函数的调用关系图:

◆ base_find_last_of()

template<typename T >

constexpr T * elc::defs::base::range_n::base_find_last_of	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

find_last_of的朴素实现若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11428 行定义.

                                                                                                              {
        for(auto&i : range|::std::views::reverse){
            if(in_range(i,pattern))
                return addressof(i);
        }
        return nullptr;
    }

函数调用图:

这是这个函数的调用关系图:

◆ begin_of_array_like() [1/2]

template<class T >

auto elc::defs::base::range_n::begin_of_array_like ( range_t< const T * > & a )

inlinenoexcept

在文件 all_defs.cpp 第 11177 行定义.

11177{return a.begin();}

elc::defs::base::range_n::range_t::begin

constexpr auto begin() noexcept

Definition all_defs.cpp:11159

◆ begin_of_array_like() [2/2]

template<class T >

auto elc::defs::base::range_n::begin_of_array_like ( range_t< T * > & a )

inlinenoexcept

在文件 all_defs.cpp 第 11175 行定义.

11175{return a.begin();}

◆ find_first_not_of() [1/2]

template<typename T >

constexpr T * elc::defs::base::range_n::find_first_not_of	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11478 行定义.

                                                                                                              {
        if constexpr(basic_integer_type<T>){
            bitmark_for_finds<T> mark;
            if(mark.mark(pattern))
                return find_first_not_of_bitmark(mark,range);
        }
        return base_find_first_not_of(pattern,range);
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_first_not_of() [2/2]

template<typename T >

constexpr T * elc::defs::base::range_n::find_first_not_of	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 12300 行定义.

                                                                                                                          {
        if(pattern.is_bitmark_workable)
            return find_first_not_of_bitmark(pattern.bitmark_for_finds,range);
        else
            return find_first_not_of((const constexpr_str_view_t<T>&)pattern,range);
    }

函数调用图:

◆ find_first_not_of_bitmark()

template<typename T >

constexpr T * elc::defs::base::range_n::find_first_not_of_bitmark	(	const bitmark_for_finds< T > &	mark,
		array_like_view_t< T >	range
	)

constexpr

find_first_not_of的bitmark实现若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11458 行定义.

                                                                                                                   {
        for(auto& i: range){
            if(!mark[i])
                return addressof(i);
        }
        return nullptr;
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_first_not_of_size_t() [1/2]

template<typename T >

constexpr size_t elc::defs::base::range_n::find_first_not_of_size_t	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到不匹配的数据项，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 11488 行定义.

                                                                                                                         {
        auto result = find_first_not_of(pattern,range);
        if(result)
            return result - range.begin();
        else
            return npos;
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_first_not_of_size_t() [2/2]

template<typename T >

constexpr size_t elc::defs::base::range_n::find_first_not_of_size_t	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 11896 行定义.

                                                                                                                                     {
        auto result = find_first_not_of(pattern, range);
        if(result)
            return result - range.data();
        else
            return npos;
    }

函数调用图:

◆ find_first_of() [1/2]

template<typename T >

constexpr T * elc::defs::base::range_n::find_first_of	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11399 行定义.

                                                                                                          {
        if constexpr(basic_integer_type<T>){
            bitmark_for_finds<T> mark;
            if(mark.mark(pattern))
                return find_first_of_bitmark(mark,range);
        }
        return base_find_first_of(pattern,range);
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_first_of() [2/2]

template<typename T >

constexpr T * elc::defs::base::range_n::find_first_of	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 12282 行定义.

                                                                                                                      {
        if(pattern.is_bitmark_workable)
            return find_first_of_bitmark(pattern.bitmark_for_finds,range);
        else
            return find_first_of((const constexpr_str_view_t<T>&)pattern,range);
    }

函数调用图:

◆ find_first_of_bitmark()

template<typename T >

constexpr T * elc::defs::base::range_n::find_first_of_bitmark	(	const bitmark_for_finds< T > &	mark,
		array_like_view_t< T >	range
	)

constexpr

find_first_of的bitmark实现若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11379 行定义.

                                                                                                               {
        for(auto&i : range){
            if(mark[i])
                return addressof(i);
        }
        return nullptr;
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_first_of_size_t() [1/2]

template<typename T >

constexpr size_t elc::defs::base::range_n::find_first_of_size_t	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 11409 行定义.

                                                                                                                     {
        auto result = find_first_of(pattern,range);
        if(result)
            return result - range.begin();
        else
            return npos;
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_first_of_size_t() [2/2]

template<typename T >

constexpr size_t elc::defs::base::range_n::find_first_of_size_t	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 11874 行定义.

                                                                                                                                 {
        auto result = find_first_of(pattern, range);
        if(result)
            return result - range.data();
        else
            return npos;
    }

函数调用图:

◆ find_last_not_of() [1/2]

template<typename T >

constexpr T * elc::defs::base::range_n::find_last_not_of	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11571 行定义.

                                                                                                             {
        if constexpr(basic_integer_type<T>){
            bitmark_for_finds<T> mark;
            if(mark.mark(pattern))
                return find_last_not_of_bitmark(mark,range);
        }
        return base_find_last_not_of(pattern,range);
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_last_not_of() [2/2]

template<typename T >

constexpr T * elc::defs::base::range_n::find_last_not_of	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 12309 行定义.

                                                                                                                         {
        if(pattern.is_bitmark_workable)
            return find_last_not_of_bitmark(pattern.bitmark_for_finds,range);
        else
            return find_last_not_of((const constexpr_str_view_t<T>&)pattern,range);
    }

函数调用图:

◆ find_last_not_of_bitmark()

template<typename T >

constexpr T * elc::defs::base::range_n::find_last_not_of_bitmark	(	const bitmark_for_finds< T > &	mark,
		array_like_view_t< T >	range
	)

constexpr

find_last_not_of的bitmark实现若成功找到不匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11498 行定义.

                                                                                                                  {
        for(auto& i: range|::std::views::reverse){
            if(!mark[i])
                return addressof(i);
        }
        return nullptr;
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_last_not_of_size_t() [1/2]

template<typename T >

constexpr size_t elc::defs::base::range_n::find_last_not_of_size_t	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到不匹配的数据项，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 11581 行定义.

                                                                                                                        {
        auto result = find_last_not_of(pattern,range);
        if(result)
            return result - range.begin();
        else
            return npos;
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_last_not_of_size_t() [2/2]

template<typename T >

constexpr T * elc::defs::base::range_n::find_last_not_of_size_t	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 11907 行定义.

                                                                                                                                {
        auto result = find_last_not_of(pattern,range);
        if(result)
            return result - range.begin();
        else
            return npos;
    }

函数调用图:

◆ find_last_of() [1/2]

template<typename T >

constexpr T * elc::defs::base::range_n::find_last_of	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11438 行定义.

                                                                                                         {
        if constexpr(basic_integer_type<T>){
            bitmark_for_finds<T> mark;
            if(mark.mark(pattern))
                return find_last_of_bitmark(mark,range);
        }
        return base_find_last_of(pattern,range);
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_last_of() [2/2]

template<typename T >

constexpr T * elc::defs::base::range_n::find_last_of	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 12291 行定义.

                                                                                                                     {
        if(pattern.is_bitmark_workable)
            return find_last_of_bitmark(pattern.bitmark_for_finds,range);
        else
            return find_last_of((const constexpr_str_view_t<T>&)pattern,range);
    }

函数调用图:

◆ find_last_of_bitmark()

template<typename T >

constexpr T * elc::defs::base::range_n::find_last_of_bitmark	(	const bitmark_for_finds< T > &	mark,
		array_like_view_t< T >	range
	)

constexpr

find_last_of的bitmark实现若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11419 行定义.

                                                                                                              {
        for(auto& i: range|::std::views::reverse){
            if(mark[i])
                return addressof(i);
        }
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_last_of_size_t() [1/2]

template<typename T >

constexpr size_t elc::defs::base::range_n::find_last_of_size_t	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 11448 行定义.

                                                                                                                    {
        auto result = find_last_of(pattern,range);
        if(result)
            return result - range.begin();
        else
            return npos;
    }

函数调用图:

这是这个函数的调用关系图:

◆ find_last_of_size_t() [2/2]

template<typename T >

constexpr size_t elc::defs::base::range_n::find_last_of_size_t	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 11885 行定义.

                                                                                                                                {
        auto result = find_last_of(pattern, range);
        if(result)
            return result - range.data();
        else
            return npos;
    }

函数调用图:

◆ in_range() [1/6]

template<typename T >

constexpr T * elc::defs::base::range_n::in_range	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据串，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11315 行定义.

                                                                                        {
        match_pattern tmp=pattern;
        return tmp.match(range);
    }

函数调用图:

◆ in_range() [2/6]

template<typename T >

constexpr T * elc::defs::base::range_n::in_range	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 12272 行定义.

                                                                                                                 {
        return pattern.match_pattern.match(range);
    }

函数调用图:

◆ in_range() [3/6]

template<typename T >

constexpr T * elc::defs::base::range_n::in_range	(	const remove_cvref< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11278 行定义.

                                                                                                {
        for(auto&i : range){
            if(i==pattern)
                return addressof(i);
        }
        return nullptr;
    }

函数调用图:

◆ in_range() [4/6]

template<typename T >

constexpr const T * elc::defs::base::range_n::in_range	(	const remove_cvref< T > &	pattern,
		const constexpr_str_t< T > &	range
	)

constexpr

若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 12320 行定义.

                                                                                                          {
        if(range.is_bitmark_for_unindex_workable){
            auto result = range.bitmark_for_unindex[pattern];
            return result==npos?nullptr:range.begin()+result;
        }
        else
            return in_range(pattern,(const constexpr_str_view_t<T>&)range);
    }

函数调用图:

◆ in_range() [5/6]

template<typename T >

constexpr bool elc::defs::base::range_n::in_range	(	T *	pattern,
		const range_t< byte * >	range
	)

constexprnoexcept

判断一个指针是否在某个byte指针范围内

在文件 all_defs.cpp 第 11188 行定义.

                                                                                     {
        return cast_to_data(pattern)>=range.begin() && cast_to_data(pattern)<range.end();
    }

函数调用图:

◆ in_range() [6/6]

template<typename T >

constexpr bool elc::defs::base::range_n::in_range	(	T	pattern,
		const range_t< T >	range
	)

constexprnoexcept

判断一个值是否在某个范围内

在文件 all_defs.cpp 第 11182 行定义.

                                                                                                                                                                {//算术类型或指针
        return bool(pattern>=range.begin() && pattern<range.end());
    }

函数调用图:

这是这个函数的调用关系图:

◆ in_range_but_reverse() [1/4]

template<typename T >

constexpr T * elc::defs::base::range_n::in_range_but_reverse	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据串，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11332 行定义.

                                                                                                    {
        reverse_match_pattern tmp = pattern;
        return tmp.match(range);
    }

函数调用图:

◆ in_range_but_reverse() [2/4]

template<typename T >

constexpr T * elc::defs::base::range_n::in_range_but_reverse	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 12276 行定义.

                                                                                                                             {
        return pattern.reverse_match_pattern.match(range);
    }

函数调用图:

◆ in_range_but_reverse() [3/4]

template<typename T >

constexpr T * elc::defs::base::range_n::in_range_but_reverse	(	const remove_cvref< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 11296 行定义.

                                                                                                            {
        for(auto&i : range|::std::views::reverse){
            if(i==pattern)
                return addressof(i);
        }
        return nullptr;
    }

函数调用图:

这是这个函数的调用关系图:

◆ in_range_but_reverse() [4/4]

template<typename T >

constexpr const T * elc::defs::base::range_n::in_range_but_reverse	(	const remove_cvref< T > &	pattern,
		const constexpr_str_t< T > &	range
	)

constexpr

若成功找到匹配的数据项，返回其开头，若未找到，返回nullptr

在文件 all_defs.cpp 第 12338 行定义.

                                                                                                                      {
        if(range.is_bitmark_for_unindex_workable){
            auto result = range.bitmark_for_unindex[pattern];
            return result==npos?nullptr:range.begin()+result;
        }
        else
            return in_range_but_reverse(pattern,(const constexpr_str_view_t<T>&)range);
    }

函数调用图:

◆ in_range_but_reverse_size_t() [1/4]

template<typename T >

constexpr size_t elc::defs::base::range_n::in_range_but_reverse_size_t	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据串，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 11338 行定义.

                                                                                                                            {
        auto result = in_range_but_reverse(pattern,range);
        if(result)
            return result - range.begin();
        else
            return npos;
    }

函数调用图:

◆ in_range_but_reverse_size_t() [2/4]

template<typename T >

constexpr size_t elc::defs::base::range_n::in_range_but_reverse_size_t	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 11863 行定义.

                                                                                                                                        {
        auto result = in_range_but_reverse(pattern, range);
        if(result)
            return result - range.data();
        else
            return npos;
    }

函数调用图:

◆ in_range_but_reverse_size_t() [3/4]

template<typename T >

constexpr size_t elc::defs::base::range_n::in_range_but_reverse_size_t	(	const remove_cvref< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 11305 行定义.

                                                                                                                       {
        auto result = in_range_but_reverse(pattern,range);
        if(result)
            return result - range.begin();
        else
            return npos;
    }

函数调用图:

这是这个函数的调用关系图:

◆ in_range_but_reverse_size_t() [4/4]

template<typename T >

constexpr size_t elc::defs::base::range_n::in_range_but_reverse_size_t	(	const remove_cvref< T > &	pattern,
		const constexpr_str_t< T > &	range
	)

constexpr

若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 12348 行定义.

                                                                                                                           {
        if(range.is_bitmark_for_unindex_workable)
            return range.bitmark_for_unindex[pattern];
        else
            return in_range_but_reverse_size_t(pattern,(const constexpr_str_view_t<T>&)range);
    }

函数调用图:

◆ in_range_size_t() [1/4]

template<typename T >

constexpr size_t elc::defs::base::range_n::in_range_size_t	(	const array_like_view_t< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据串，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 11321 行定义.

                                                                                                                {
        auto result = in_range(pattern,range);
        if(result)
            return result - range.begin();
        else
            return npos;
    }

函数调用图:

◆ in_range_size_t() [2/4]

template<typename T >

constexpr size_t elc::defs::base::range_n::in_range_size_t	(	const constexpr_str_t< remove_cvref< T > > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

在文件 all_defs.cpp 第 11852 行定义.

                                                                                                                            {
        auto result = in_range(pattern, range);
        if(result)
            return result - range.data();
        else
            return npos;
    }

函数调用图:

◆ in_range_size_t() [3/4]

template<typename T >

constexpr size_t elc::defs::base::range_n::in_range_size_t	(	const remove_cvref< T > &	pattern,
		array_like_view_t< T >	range
	)

constexpr

若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 11287 行定义.

                                                                                                           {
        auto result = in_range(pattern,range);
        if(result)
            return result - range.begin();
        else
            return npos;
    }

函数调用图:

这是这个函数的调用关系图:

◆ in_range_size_t() [4/4]

template<typename T >

constexpr size_t elc::defs::base::range_n::in_range_size_t	(	const remove_cvref< T > &	pattern,
		const constexpr_str_t< T > &	range
	)

constexpr

若成功找到匹配的数据项，返回其距离开头的步数，若未找到，返回npos

在文件 all_defs.cpp 第 12330 行定义.

                                                                                                               {
        if(range.is_bitmark_for_unindex_workable)
            return range.bitmark_for_unindex[pattern];
        else
            return in_range_size_t(pattern,(const constexpr_str_view_t<T>&)range);
    }

函数调用图:

◆ size_of_array_like() [1/2]

template<class T >

auto elc::defs::base::range_n::size_of_array_like ( range_t< const T * > & a )

inlinenoexcept

在文件 all_defs.cpp 第 11172 行定义.

11172{return a.size();}

elc::defs::base::range_n::range_t::size

constexpr size_t size() noexcept

Definition all_defs.cpp:11157

◆ size_of_array_like() [2/2]

template<class T >

auto elc::defs::base::range_n::size_of_array_like ( range_t< T * > & a )

inlinenoexcept

在文件 all_defs.cpp 第 11170 行定义.

11170{return a.size();}