robot/robot/robotics/linq.hpp

/**
*
*  @file linq.hpp
*  @author zxw
*  Copyright 2024, yjrobotics.  All rights reserved.
*
*  robotics
*
*/
#pragma once
//stl
#include <iostream>
#include <functional>
#include <algorithm>
#include <vector>
#include <mutex>
#include <map>

namespace robotics {
    namespace v3 {
        /**
        * @brief 状态
        */
        enum class linq_change_type {
            Insert,
            Delete,
            Update
        };
        /**
         * @brief linq
         * @tparam _Type
         */
        template<typename _Type>
        class linq {
        public:
            /**
             * @brief 构造
             * @param value
             */
            linq(std::vector<_Type>& value) :
                source_(value) {
                source_ok_.assign(source_.size(), true);
            }
            /**
             * @brief 析构
             */
            ~linq() {
                submit();
            }
            /**
             * @brief 重置结果
             * @return
             */
            linq& reset() {
                std::lock_guard<std::mutex> locker(mutex_);
                source_ok_.assign(source_.size(), true);
                return *this;
            }
            /**
             * @brief 重置回调
             * @return
             */
            linq& reset_changed() {
                std::lock_guard<std::mutex> locker(mutex_);
                changed_list_.clear();
                return *this;
            }
            /**
             * @brief 提交
             * @return
             */
            linq& submit() {
                std::lock_guard<std::mutex> locker(mutex_);
                for (size_t i = 0; i < changed_list_.size(); ++i) {
                    for (auto const& it : changed_event) {
                        it(std::get<0>(changed_list_[i]), std::get<1>(changed_list_[i]), std::get<2>(changed_list_[i]), changed_list_.size() == (i + 1));
                    }
                }
                changed_list_.clear();
                return *this;
            }
            /**
             * @brief 绑定改变事件
             * @tparam _Fn
             * @tparam _Obj
             * @param fn
             * @param obj
             * @return
             */
            template<typename _Fn, typename _Obj>
            linq& changed_bind(_Fn&& fn, _Obj&& obj) {
                std::lock_guard<std::mutex> locker(mutex_);
                changed_event.push_back(std::bind(std::forward<_Fn>(fn), std::forward<_Obj>(obj), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
                return *this;
            }
            /**
             * @brief 绑定改变事件
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Fn>
            linq& changed_bind(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                changed_event.push_back(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 查询
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Fn>
            linq& where(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    source_ok_[i] = fn(it);
                }
                return *this;
            }
            /**
             * @brief 修改
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Fn>
            linq& update(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<_Type>::iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (changed_event.empty()) {
                        fn(it);
                    }
                    else {
                        _Type tmp = *it;
                        if (fn(it)) {
                            changed_list_.push_back(std::make_tuple(*it, tmp, linq_change_type::Update));
                        }
                    }
                }
                return *this;
            }
            /**
             * @brief 删除
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Fn>
            linq& remove(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<_Type>::const_iterator it;
                for (std::int64_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (fn(it)) {
                        if (!changed_event.empty()) {
                            changed_list_.push_back(std::make_tuple(*it, *it, linq_change_type::Delete));
                        }
                        if (i + 1 < source_ok_.size() && !source_ok_.empty()) {
                            source_ok_[i] = std::move(source_ok_.back());
                            source_[i] = std::move(source_.back());
                            source_ok_.pop_back();
                            source_.pop_back();
                        }
                        else {
                            source_ok_.pop_back();
                            source_.pop_back();
                        }
                        --i;
                    }
                }
                return *this;
            }
            /**
             * @brief 删除
             * @return
             */
            linq& remove() {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<_Type>::const_iterator it;
                for (std::int64_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (!changed_event.empty()) {
                        changed_list_.push_back(std::make_tuple(*it, *it, linq_change_type::Delete));
                    }

                    if (i + 1 < source_ok_.size() && !source_ok_.empty()) {
                        source_ok_[i] = std::move(source_ok_.back());
                        source_[i] = std::move(source_.back());
                        source_ok_.pop_back();
                        source_.pop_back();
                    }
                    else {
                        source_ok_.pop_back();
                        source_.pop_back();
                    }
                    --i;
                }
                return *this;
            }
            /**
             * @brief 添加
             * @param values
             * @return
             */
            linq& append(std::vector<_Type> const& values) {
                for (auto const& it : values) {
                    append(it);
                }
                return *this;
            }
            /**
             * @brief 添加
             * @param value
             * @return
             */
            linq& append(_Type const& value) {
                std::lock_guard<std::mutex> locker(mutex_);
                source_.push_back(value);
                source_ok_.push_back(true);
                if (!changed_event.empty()) {
                    changed_list_.push_back(std::make_tuple(value, value, linq_change_type::Insert));
                }
                return *this;
            }
            /**
             * @brief 排序
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Fn>
            linq& order_by(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<std::pair<_Type, bool>> alllist;
                for (std::int64_t i = 0; i < source_.size(); ++i) {
                    alllist.push_back(std::pair(source_[i], source_ok_[i]));
                }
                std::sort(alllist.begin(), alllist.end(), [&fn](std::pair<_Type, bool> const& val1, std::pair<_Type, bool> const& val2) {
                    return fn(&val1.first, &val2.first); });
                source_.clear();
                source_ok_.clear();
                for (std::int64_t i = 0; i < alllist.size(); ++i) {
                    source_.push_back(alllist[i].first);
                    source_ok_.push_back(alllist[i].second);
                }
                return *this;
            }
            /**
             * @brief 分页
             * @param page
             * @param count
             * @return
             */
            linq& limit(unsigned int page, unsigned int count) {
                std::lock_guard<std::mutex> locker(mutex_);
                size_t begin_index = (page - 1) * count;
                size_t current_index = 0;
                size_t current_count = 0;
                size_t i = 0;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    if (begin_index <= current_index && count > current_count) {
                        ++current_count;
                    }
                    else if (count <= current_count) {
                        std::fill(source_ok_.begin() + i, source_ok_.end(), false);
                        break;
                    }
                    else {
                        source_ok_[i] = false;
                    }
                    current_index++;
                }
                return *this;
            }
            /**
             * @brief 数量
             * @param result
             * @return
             */
            linq& count(size_t& result) {
                result = count();
                return *this;
            }
            /**
             * @brief 数量
             * @param result
             * @return
             */
            linq& count(int& result) {
                result = count();
                return *this;
            }
            /**
             * @brief 数量
             * @param result
             * @return
             */
            linq& size(size_t& result) {
                result = count();
                return *this;
            }
            /**
             * @brief 数量
             * @param result
             * @return
             */
            linq& size(int& result) {
                result = count();
                return *this;
            }
            /**
             * @brief 平均值
             * @tparam _Ret
             * @param result
             * @return
             */
            template<typename _Ret>
            linq& avg(_Ret& result) {
                result = avg<_Ret>();
                return *this;
            }
            /**
             * @brief 平均值
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq& avg(_Ret& result, _Fn&& fn) {
                result = avg<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 最大值
             * @tparam _Ret
             * @param result
             * @return
             */
            template<typename _Ret>
            linq& max(_Ret& result) {
                result = max<_Ret>();
                return *this;
            }
            /**
             * @brief 最大值
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq& max(_Ret& result, _Fn&& fn) {
                result = max<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 最小值
             * @tparam _Ret
             * @param result
             * @return
             */
            template<typename _Ret>
            linq& min(_Ret& result) {
                result = min<_Ret>();
                return *this;
            }
            /**
             * @brief 最小值
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq& min(_Ret& result, _Fn&& fn) {
                result = min<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 求和
             * @tparam _Ret
             * @param result
             * @return
             */
            template<typename _Ret>
            linq& sum(_Ret& result) {
                result = sum<_Ret>();
                return *this;
            }
            /**
             * @brief 求和
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq& sum(_Ret& result, _Fn&& fn) {
                result = sum<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 是否包含
             * @param result
             * @param value
             * @return
             */
            linq& contains(bool& result, _Type const& value) {
                result = contains(value);
                return *this;
            }
            /**
             * @brief 是否包含
             * @param result
             * @param fn
             * @return
             */
            linq& contains(bool& result, std::function<bool(typename std::vector<_Type>::const_iterator)> const& fn) {
                result = contains(fn);
                return *this;
            }
            /**
             * @brief 选择
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq& select(std::vector<_Ret>& result, _Fn&& fn) {
                result = select<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 分组
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq& group_by(_Ret& result, _Fn&& fn) {
                result = group_by<typename _Ret::key_type>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 自定义操作
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Fn>
            linq& function(_Fn&& fn) {
                fn();
                return *this;
            }
            /**
             * @brief 自增
             * @tparam _Param
             * @param value
             * @return
             */
            template<typename _Param>
            linq& inc(_Param& value) {
                ++value;
                return *this;
            }
            /**
             * @brief 数量
             * @return
             */
            size_t count() {
                std::lock_guard<std::mutex> locker(mutex_);
                size_t result = 0;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    result++;
                }
                return result;
            }
            /**
             * @brief 数量
             * @return
             */
            size_t size() {
                return count();
            }
            /**
             * @brief 计算平均值
             * @tparam _Ret
             * @return
             */
            template<typename _Ret>
            _Ret avg() {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret all = _Ret();
                size_t count = 0;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    all += *it;
                    count++;
                }
                return all / _Ret(count);
            }
            /**
             * @brief 计算平均值
             * @tparam _Ret
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            _Ret avg(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret all = _Ret();
                size_t count = 0;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    all += fn(it);
                    count++;
                }
                return all / _Ret(count);
            }
            /**
             * @brief 最大值
             * @tparam _Ret
             * @return
             */
            template<typename _Ret>
            _Ret max() {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                bool ok = true;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (ok) {
                        ok = false;
                        result = *it;
                    }
                    else {
                        if (result < *it) {
                            result = *it;
                        }
                    }
                }
                return result;
            }
            /**
             * @brief 最大值
             * @tparam _Ret
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            _Ret max(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                bool ok = true;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (ok) {
                        ok = false;
                        result = fn(it);
                    }
                    else {
                        _Ret tmp_value = fn(it);
                        if (result < tmp_value) {
                            result = tmp_value;
                        }
                    }
                }
                return result;
            }
            /**
             * @brief 最小值
             * @tparam _Ret
             * @return
             */
            template<typename _Ret>
            _Ret min() {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                bool ok = true;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (ok) {
                        ok = false;
                        result = *it;
                    }
                    else {
                        if (result > *it) {
                            result = *it;
                        }
                    }
                }
                return result;
            }
            /**
             * @brief 最小值
             * @tparam _Ret
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            _Ret min(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                bool ok = true;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (ok) {
                        ok = false;
                        result = fn(it);
                    }
                    else {
                        _Ret tmp_value = fn(it);
                        if (result > tmp_value) {
                            result = tmp_value;
                        }
                    }
                }
                return result;
            }
            /**
             * @brief 求和
             * @tparam _Ret
             * @return
             */
            template<typename _Ret>
            _Ret sum() {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result += *it;
                }
                return result;
            }
            /**
             * @brief 求和
             * @tparam _Ret
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            _Ret sum(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result += fn(it);
                }
                return result;
            }
            /**
             * @brief 是否包含
             * @param value
             * @return
             */
            bool contains(_Type const& value) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (*it == value) {
                        return true;
                    }
                }
                return false;
            }
            /**
             * @brief 是否包含
             * @param fn
             * @return
             */
            bool contains(std::function<bool(typename std::vector<_Type>::const_iterator)>const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (fn(it)) {
                        return true;
                    }
                }
                return false;
            }
            /**
             * @brief 选择
             * @tparam _Ret
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            std::vector<_Ret> select(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<_Ret> result;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result.push_back(fn(it));
                }
                return result;
            }
            /**
             * @brief 分组
             * @tparam _Key
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Key, typename _Fn>
            std::map<_Key, std::vector<_Type>> group_by(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                std::map<_Key, std::vector<_Type>> result;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result[fn(it)].push_back(*it);
                }
                return result;
            }
            /**
             * @brief 获取值
             * @return
             */
            std::vector<_Type> value() {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<_Type> result;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result.push_back(*it);
                }
                return result;
            }
            /**
             * @brief 原始资源
             * @return
             */
            std::vector<_Type> source() {
                return source_;
            }
            /**
             * @brief 获取值
             */
            operator std::vector<_Type>() {
                return value();
            }
            /**
             * @brief 获取原始资源
             * @return
             */
            std::vector<std::shared_ptr<_Type>> source_ptr() {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<std::shared_ptr<_Type>> result;
                for (auto& it : source_) {
                    result.push_back(std::make_shared<_Type>(it));
                }
                return result;
            }
            /**
             * @brief 获取数据
             * @return
             */
            std::vector<std::shared_ptr<_Type>> value_ptr() {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<std::shared_ptr<_Type>> result;
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result.push_back(std::make_shared<_Type>(*it));
                }
                return result;
            }
            /**
             * @brief 获取数据
             */
            operator std::vector<std::shared_ptr<_Type>>() {
                return value_ptr();
            }
            /**
             * @brief 获取一条数据
             * @return
             */
            std::optional<_Type> first() {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<_Type>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    return *it;
                }
                return std::nullopt;
            }
            /**
             * @brief 获取一条数据
             */
            operator std::optional<_Type>() {
                return first();
            }
            /**
             * @brief
             * @return
             */
            bool empty() {
                for (bool it : source_ok_) {
                    if (it) {
                        return false;
                    }
                }
                return true;
            }
            /**
             * @brief 改变事件
             */
            std::vector<std::function<void(_Type const&, _Type const&, linq_change_type, bool)>> changed_event;
        protected:
            std::mutex                                               mutex_;
            std::vector<_Type>&                                      source_;
            std::vector<bool>                                        source_ok_;
            std::vector<std::tuple<_Type, _Type, linq_change_type>>  changed_list_;
        };
        /**
         * @brief linq_ptr
         * @tparam _Type
         */
        template<typename _Type>
        class linq_ptr {
        public:
            /**
             * @brief 构造
             * @param value
             */
            linq_ptr(std::vector<std::shared_ptr<_Type>>& value) :
                source_(value) {
                source_ok_.assign(source_.size(), true);
            }
            /**
             * @brief 析构
             */
            ~linq_ptr() {
                submit();
            }
            /**
             * @brief 重置结果
             * @return
             */
            linq_ptr& reset() {
                std::lock_guard<std::mutex> locker(mutex_);
                source_ok_.assign(source_.size(), true);
                return *this;
            }
            /**
             * @brief 重置回调
             * @return
             */
            linq_ptr& reset_changed() {
                std::lock_guard<std::mutex> locker(mutex_);
                changed_list_.clear();
                return *this;
            }
            /**
             * @brief 提交
             * @return
             */
            linq_ptr& submit() {
                std::lock_guard<std::mutex> locker(mutex_);
                for (size_t i = 0; i < changed_list_.size(); ++i) {
                    for (auto const& it : changed_event) {
                        it(std::get<0>(changed_list_[i]), std::get<1>(changed_list_[i]), std::get<2>(changed_list_[i]), changed_list_.size() == (i + 1));
                    }
                }
                changed_list_.clear();
                return *this;
            }
            /**
             * @brief 绑定改变事件
             * @tparam _Fn
             * @tparam _Obj
             * @param fn
             * @param obj
             * @return
             */
            template<typename _Fn, typename _Obj>
            linq_ptr& changed_bind(_Fn&& fn, _Obj&& obj) {
                std::lock_guard<std::mutex> locker(mutex_);
                changed_event.push_back(std::bind(std::forward<_Fn>(fn), std::forward<_Obj>(obj), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
                return *this;
            }
            /**
             * @brief 绑定改变事件
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Fn>
            linq_ptr& changed_bind(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                changed_event.push_back(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 查询
             * @param fn
             * @return
             */
            linq_ptr& where(std::function<bool(std::shared_ptr<const _Type> const&)> const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    source_ok_[i] = fn(*it);
                }
                return *this;
            }
            /**
             * @brief 修改
             * @param fn
             * @return
             */
            linq_ptr& update(std::function<bool(std::shared_ptr<_Type> const&)> const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<std::shared_ptr<_Type>>::iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (changed_event.empty()) {
                        fn(*it);
                    }
                    else {
                        _Type tmp = **it;
                        if (fn(*it)) {
                            changed_list_.push_back(std::make_tuple(**it, tmp, linq_change_type::Update));
                        }
                    }
                }
                return *this;
            }
            /**
             * @brief 删除
             * @param fn
             * @return
             */
            linq_ptr& remove(std::function<bool(std::shared_ptr<const _Type> const&)> const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (std::int64_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (fn(*it)) {
                        if (!changed_event.empty()) {
                            changed_list_.push_back(std::make_tuple(**it, **it, linq_change_type::Delete));
                        }
                        if (i + 1 < source_ok_.size() && !source_ok_.empty()) {
                            source_ok_[i] = std::move(source_ok_.back());
                            source_[i] = std::move(source_.back());
                            source_ok_.pop_back();
                            source_.pop_back();
                        }
                        else {
                            source_ok_.pop_back();
                            source_.pop_back();
                        }
                        --i;
                    }
                }
                return *this;
            }
            /**
             * @brief 删除
             * @return
             */
            linq_ptr& remove() {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (std::int64_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (!changed_event.empty()) {
                        changed_list_.push_back(std::make_tuple(**it, **it, linq_change_type::Delete));
                    }

                    if (i + 1 < source_ok_.size() && !source_ok_.empty()) {
                        source_ok_[i] = std::move(source_ok_.back());
                        source_[i] = std::move(source_.back());
                        source_ok_.pop_back();
                        source_.pop_back();
                    }
                    else {
                        source_ok_.pop_back();
                        source_.pop_back();
                    }
                    --i;
                }
                return *this;
            }
            /**
             * @brief 添加
             * @param values
             * @return
             */
            linq_ptr& append(std::vector<_Type> const& values) {
                for (auto const& it : values) {
                    append(it);
                }
                return *this;
            }
            /**
             * @brief 添加
             * @param value
             * @return
             */
            linq_ptr& append(_Type const& value) {
                append(std::make_shared<_Type>(value));
                return *this;
            }
            /**
             * @brief 添加
             * @param values
             * @return
             */
            linq_ptr& append(std::vector<std::shared_ptr<_Type>> const& values) {
                for (auto const& it : values) {
                    append(it);
                }
                return *this;
            }
            /**
             * @brief 添加
             * @param value
             * @return
             */
            linq_ptr& append(std::shared_ptr<_Type> const& value) {
                std::lock_guard<std::mutex> locker(mutex_);
                source_.push_back(value);
                source_ok_.push_back(true);
                if (!changed_event.empty()) {
                    changed_list_.push_back(std::make_tuple(*value, *value, linq_change_type::Insert));
                }
                return *this;
            }
            /**
             * @brief 排序
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Fn>
            linq_ptr& order_by(_Fn&& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<std::pair<std::shared_ptr<_Type>, bool>> alllist;
                for (std::int64_t i = 0; i < source_.size(); ++i) {
                    alllist.push_back(std::pair(source_[i], source_ok_[i]));
                }
                std::sort(alllist.begin(), alllist.end(), [&fn](std::pair<std::shared_ptr<_Type>, bool> val1, std::pair<std::shared_ptr<_Type>, bool> val2) {
                    return fn(&val1.first, &val2.first); });
                source_.clear();
                source_ok_.clear();
                for (std::int64_t i = 0; i < alllist.size(); ++i) {
                    source_.push_back(alllist[i].first);
                    source_ok_.push_back(alllist[i].second);
                }
                return *this;
            }
            /**
             * @brief 分页
             * @param page
             * @param count
             * @return
             */
            linq_ptr& limit(unsigned int page, unsigned int count) {
                std::lock_guard<std::mutex> locker(mutex_);
                size_t begin_index = (page - 1) * count;
                size_t current_index = 0;
                size_t current_count = 0;
                size_t i = 0;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    if (begin_index <= current_index && count > current_count) {
                        ++current_count;
                    }
                    else if (count <= current_count) {
                        std::fill(source_ok_.begin() + i, source_ok_.end(), false);
                        break;
                    }
                    else {
                        source_ok_[i] = false;
                    }
                    current_index++;
                }
                return *this;
            }
            /**
             * @brief 数量
             * @param result
             * @return
             */
            linq_ptr& count(size_t& result) {
                result = count();
                return *this;
            }
            /**
             * @brief 数量
             * @param result
             * @return
             */
            linq_ptr& count(int& result) {
                result = count();
                return *this;
            }
            /**
             * @brief 数量
             * @param result
             * @return
             */
            linq_ptr& size(size_t& result) {
                result = count();
                return *this;
            }
            /**
             * @brief 数量
             * @param result
             * @return
             */
            linq_ptr& size(int& result) {
                result = count();
                return *this;
            }
            /**
             * @brief 平均值
             * @tparam _Ret
             * @param result
             * @return
             */
            template<typename _Ret>
            linq_ptr& avg(_Ret& result) {
                result = avg<_Ret>();
                return *this;
            }
            /**
             * @brief 平均值
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq_ptr& avg(_Ret& result, _Fn&& fn) {
                result = avg<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 最大值
             * @tparam _Ret
             * @param result
             * @return
             */
            template<typename _Ret>
            linq_ptr& max(_Ret& result) {
                result = max<_Ret>();
                return *this;
            }
            /**
             * @brief 最大值
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq_ptr& max(_Ret& result, _Fn&& fn) {
                result = max<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 最小值
             * @tparam _Ret
             * @param result
             * @return
             */
            template<typename _Ret>
            linq_ptr& min(_Ret& result) {
                result = min<_Ret>();
                return *this;
            }
            /**
             * @brief 最小值
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq_ptr& min(_Ret& result, _Fn&& fn) {
                result = min<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 求和
             * @tparam _Ret
             * @param result
             * @return
             */
            template<typename _Ret>
            linq_ptr& sum(_Ret& result) {
                result = sum<_Ret>();
                return *this;
            }
            /**
             * @brief 求和
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq_ptr& sum(_Ret& result, _Fn&& fn) {
                result = sum<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 是否包含
             * @param result
             * @param value
             * @return
             */
            linq_ptr& contains(bool& result, std::shared_ptr<_Type> const& value) {
                result = contains(value);
                return *this;
            }
            /**
             * @brief 是否包含
             * @param result
             * @param fn
             * @return
             */
            linq_ptr& contains(bool& result, std::function<bool(std::shared_ptr<const _Type> const&)> const& fn) {
                result = contains(fn);
                return *this;
            }
            /**
             * @brief 选择
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq_ptr& select(std::vector<_Ret>& result, _Fn&& fn) {
                result = select<_Ret>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 分组
             * @tparam _Ret
             * @tparam _Fn
             * @param result
             * @param fn
             * @return
             */
            template<typename _Ret, typename _Fn>
            linq_ptr& group_by(_Ret& result, _Fn&& fn) {
                result = group_by<typename _Ret::key_type>(std::forward<_Fn>(fn));
                return *this;
            }
            /**
             * @brief 自定义操作
             * @tparam _Fn
             * @param fn
             * @return
             */
            template<typename _Fn>
            linq_ptr& function(_Fn&& fn) {
                fn();
                return *this;
            }
            /**
             * @brief 自增
             * @tparam _Param
             * @param value
             * @return
             */
            template<typename _Param>
            linq_ptr& inc(_Param& value) {
                ++value;
                return *this;
            }
            /**
             * @brief 数量
             * @return
             */
            size_t count() {
                std::lock_guard<std::mutex> locker(mutex_);
                size_t result = 0;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    result++;
                }
                return result;
            }
            /**
             * @brief 数量
             * @return
             */
            size_t size() {
                return count();
            }
            /**
             * @brief 计算平均值
             * @tparam _Ret
             * @return
             */
            template<typename _Ret>
            _Ret avg() {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret all = _Ret();
                size_t count = 0;
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    all += **it;
                    count++;
                }
                return all / _Ret(count);
            }
            /**
             * @brief 计算平均值
             * @tparam _Ret
             * @param fn
             * @return
             */
            template<typename _Ret>
            _Ret avg(std::function<_Ret(std::shared_ptr<const _Type> const&)> const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret all = _Ret();
                size_t count = 0;
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    all += fn(*it);
                    count++;
                }
                return all / _Ret(count);
            }
            /**
             * @brief 最大值
             * @tparam _Ret
             * @return
             */
            template<typename _Ret>
            _Ret max() {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                bool ok = true;
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (ok) {
                        ok = false;
                        result = **it;
                    }
                    else {
                        if (result < **it) {
                            result = **it;
                        }
                    }
                }
                return result;
            }
            /**
             * @brief
             * @tparam _Ret
             * @param fn
             * @return
             */
            template<typename _Ret>
            _Ret max(std::function<_Ret(std::shared_ptr<const _Type> const&)> const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                bool ok = true;
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (ok) {
                        ok = false;
                        result = fn(*it);
                    }
                    else {
                        _Ret tmp_value = fn(*it);
                        if (result < tmp_value) {
                            result = tmp_value;
                        }
                    }
                }
                return result;
            }
            /**
             * @brief 最小值
             * @tparam _Ret
             * @return
             */
            template<typename _Ret>
            _Ret min() {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                bool ok = true;
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (ok) {
                        ok = false;
                        result = *it;
                    }
                    else {
                        if (result > *it) {
                            result = *it;
                        }
                    }
                }
                return result;
            }
            /**
             * @brief 最小值
             * @tparam _Ret
             * @param fn
             * @return
             */
            template<typename _Ret>
            _Ret min(std::function<_Ret(std::shared_ptr<const _Type> const&)> const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                bool ok = true;
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (ok) {
                        ok = false;
                        result = fn(*it);
                    }
                    else {
                        _Ret tmp_value = fn(*it);
                        if (result > tmp_value) {
                            result = tmp_value;
                        }
                    }
                }
                return result;
            }
            /**
             * @brief 求和
             * @tparam _Ret
             * @return
             */
            template<typename _Ret>
            _Ret sum() {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result += **it;
                }
                return result;
            }
            /**
             * @brief 求和
             * @tparam _Ret
             * @param fn
             * @return
             */
            template<typename _Ret>
            _Ret sum(std::function<_Ret(std::shared_ptr<const _Type> const&)> const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                _Ret result = _Ret();
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result += fn(*it);
                }
                return result;
            }
            /**
             * @brief 是否包含
             * @param value
             * @return
             */
            bool contains(std::shared_ptr<_Type> const& value) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (**it == *value) {
                        return true;
                    }
                }
                return false;
            }
            /**
             * @brief 是否存在
             * @param fn
             * @return
             */
            bool contains(std::function<bool(std::shared_ptr<const _Type> const&)>const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    if (fn(*it)) {
                        return true;
                    }
                }
                return false;
            }
            /**
             * @brief 选择
             * @tparam _Ret
             * @param fn
             * @return
             */
            template<typename _Ret>
            std::vector<_Ret> select(std::function<_Ret(std::shared_ptr<const _Type> const&)> const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<_Ret> result;
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result.push_back(fn(*it));
                }
                return result;
            }
            /**
             * @brief 分组
             * @tparam _Key
             * @param function
             * @return
             */
            template<typename _Key>
            std::map<_Key, std::vector<std::shared_ptr<_Type>>> group_by(std::function<_Key(std::shared_ptr<const _Type> const&)> const& fn) {
                std::lock_guard<std::mutex> locker(mutex_);
                std::map<_Key, std::vector<std::shared_ptr<_Type>>> result;
                typename std::vector<std::shared_ptr<_Type>>::const_iterator it;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    it = source_.begin() + i;
                    result[fn(*it)].push_back(*it);
                }
                return result;
            }
            /**
             * @brief 获取值
             * @return
             */
            std::vector<std::shared_ptr<_Type>> value_ptr() {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<std::shared_ptr<_Type>> result;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    result.push_back(*(source_.begin() + i));
                }
                return result;
            }
            /**
             * @brief 获取一个值
             * @return
             */
            std::shared_ptr<_Type> first() {
                std::lock_guard<std::mutex> locker(mutex_);
                std::shared_ptr<_Type> result = nullptr;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    result = *(source_.begin() + i);
                    break;
                }
                return result;
            }
            /**
             * @brief 获取值
             */
            operator std::shared_ptr<_Type>() {
                return first();
            }
            /**
             * @brief 原始资源
             * @return
             */
            std::vector<std::shared_ptr<_Type>> source_ptr() {
                return source_;
            }
            /**
             * @brief 获取值
             */
            operator std::vector<std::shared_ptr<_Type>>() {
                return value_ptr();
            }
            /**
             * @brief 获取值
             * @return
             */
            std::vector<_Type> value() {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<_Type> result;
                for (size_t i = 0; i < source_ok_.size(); ++i) {
                    if (!source_ok_[i]) {
                        continue;
                    }
                    result.push_back(**(source_.begin() + i));
                }
                return result;
            }
            /**
             * @brief 原始资源
             * @return
             */
            std::vector<_Type> source() {
                std::lock_guard<std::mutex> locker(mutex_);
                std::vector<_Type> result;
                for (auto& it : source_) {
                    result.push_back(*it);
                }
                return result;
            }
            /**
             * @brief
             * @return
             */
            bool empty() {
                for (bool it : source_ok_) {
                    if (it) {
                        return false;
                    }
                }
                return true;
            }
            /**
             * @brief 获取值
             */
            operator std::vector<_Type>() {
                return value();
            }
            /**
             * @brief 改变事件
             */
            std::vector<std::function<void(_Type const&, _Type const&, linq_change_type, bool)>> changed_event;
        protected:
            std::mutex                                               mutex_;
            std::vector<bool>                                        source_ok_;
            std::vector<std::shared_ptr<_Type>>&                     source_;
            std::vector<std::tuple<_Type, _Type, linq_change_type>>  changed_list_;
        };
        /**
         * @brief from
         * @tparam _Type
         * @param value
         * @return
         */
        template<typename _Type>
        static inline linq<_Type> from(std::vector<_Type>& value) {
            return linq<_Type>(value);
        }
        /**
         * @brief from
         * @tparam _Type
         * @param value
         * @return
         */
        template<typename _Type>
        static inline linq_ptr<_Type> from(std::vector<std::shared_ptr<_Type>>& value) {
            return linq_ptr<_Type>(value);
        }
    }
}