Найти все записи вектора А присутствующие в векторе В

#include <iostream>
#include <fstream>
#include <filesystem>
#include <string>
#include <vector>
#include <iterator>
#include <algorithm>
#include <cassert>
 
#define TESTING 1
 
struct s_item
{
private:
    std::string raw_data;//строка без изменений
    size_t key_len{};//длина ключа
    size_t index{};//индекс в неотсортированном массиве
    
public:
    s_item()=default;
    s_item(const s_item&)noexcept=default;
    s_item(s_item&&)noexcept=default;
    s_item& operator=(const s_item&)=default;
    s_item& operator=(s_item&&)noexcept=default;
    
    s_item(const std::string_view& raw_data_view,const size_t index):raw_data(raw_data_view),index(index)
    {
        const auto pos=raw_data.find(' ');
 
        if(pos==raw_data.npos)
        {
            key_len=raw_data.size();
        }
        else
        {
            key_len=pos;
        }
    }
    
    auto constexpr GetIndex()const noexcept
    {
        return index;
    }
    
    void CopyAllButIndex(const s_item& source)
    {
        const auto old_index=index;
        *this=source;
        index=old_index;
    }
 
    std::string_view GetView()const noexcept
    {
        assert(key_len<=raw_data.size());
        return {raw_data.data(),key_len};
    }
 
    friend bool operator<(const s_item& l,const s_item& r)noexcept
    {
        return l.GetView()<r.GetView();
    }
 
    friend bool operator==(const s_item& l,const s_item& r)noexcept
    {
        return l.GetView()==r.GetView();
    }
    
    friend std::ostream& operator<<(std::ostream& os, const s_item l)
    {
        os<<l.raw_data;
        return os;
    }
};
 
std::vector<s_item> readlines(const std::string &file)
{
    #ifdef TESTING
    return
    {
    //  {"111 A_dfdfg",0},
        {"888 A_dfgdfg",0},
        {"333 A_fgfgh1",0},
        {"444 A_fgfgh2",0},
        {"555 A_fgfgh3",0},
        {"777 A_cvfgh",0},
        {"999 A_cvfgh",0},       
    };
    #endif
    
    std::vector<s_item> lines;
    lines.reserve(256);
    
    std::ifstream open_file(file);
    for (std::string line; getline(open_file, line);)
    {
        //const auto index =lines.size();
        lines.emplace_back(line,0/*index*/);
    }
    open_file.close();
    return lines;
}
 
std::vector<s_item> recursive_dir(const std::string &path)
{
    #ifdef TESTING
    return
    {
        {"999 B_dfdfg",0},
//      {"888 B_dfgdfg",1},
        {"333 B_fgfgh1",2},
        {"555 B_fgfgh2",3},
        {"666 B_fgfgh3",4},
//      {"777 B_cvfgh",5},
        {"111 B_cvfgh",6},       
    };
    #endif
    
    std::vector<s_item> folder_files;
    folder_files.reserve(256);
    
    for (const auto &p : std::filesystem::recursive_directory_iterator(path))
    {
        if (std::filesystem::is_symlink(p))
        {
            auto v = std::filesystem::read_symlink(p);
            std::stringstream stream;
            stream << p.path().string() << " " << v.string();
            const auto index =folder_files.size();
            folder_files.emplace_back(stream.str(),index);
        }
        else
        {
            const auto index =folder_files.size();
            folder_files.emplace_back(p.path().string(),index);
        }
    }
    return folder_files;
}
 
int main()
{
    std::filesystem::path fsconfig;
    std::filesystem::path foldername;
    #ifdef TESTING
    #else
    fsconfig = "/data/local/UnpackerSystem/config/system/system_fs_config";
    foldername = "/data/local/UnpackerSystem/system";
    #endif
    
    auto A = readlines(fsconfig);
    auto B = recursive_dir(foldername);
  
    //временно отсортируем согласно предикату.
    //Потом B вернём обратно
    std::sort(A.begin(), A.end());
    std::sort(B.begin(), B.end());
    
    //если вдруг понадобится убирать повторные записи, то так:
    //Оставляем только уникальные записи
    //A.erase(std::unique(A.begin(), A.end()),A.end());
    //B.erase(std::unique(B.begin(), B.end()),B.end());
 
    for(auto& b:B)
    {
        auto it_A=std::lower_bound(A.begin(), A.end(), b);
        if(it_A!=A.end() && *it_A == b)
        {
            b.CopyAllButIndex(*it_A);
        }
    }
    
    //возвращаем изначальную сортировку B
    std::sort(B.begin(), B.end(),[](const auto& l,const auto& r)
    {
        return l.GetIndex()<r.GetIndex();
    });
 
    //выводим B на экран
    std::copy(B.begin(),B.end(),std::ostream_iterator<s_item>(std::cout,"\n"));
}

std::vector<s_item> recursive_dir(const std::filesystem::path &path)
{
    #ifdef TESTING
    return
    {
        {"999 B_dfdfg",0},
//      {"888 B_dfgdfg",1},
        {"333 B_fgfgh1",2},
        {"555 B_fgfgh2",3},
        {"666 B_fgfgh3",4},
//      {"777 B_cvfgh",5},
        {"111 B_cvfgh",6},       
    };
    #endif
    
    std::vector<s_item> folder_files;
    folder_files.reserve(256);
    std::string folder_parents = path.parent_path().string() + "/";
    for (const auto &p : std::filesystem::recursive_directory_iterator(path))
    {
        if (std::filesystem::is_symlink(p))
        {
            auto v = std::filesystem::read_symlink(p);
            std::stringstream stream;
            std::string f = p.path().string();
            std::string el = replace(f, folder_parents, "");
            stream << el << " " << v.string(); //вот тут было: //v.string();
            const auto index =folder_files.size();
            folder_files.emplace_back(stream.str(),index);
        }
        else
        {
             std::string f = p.path().string();
            std::string el = replace(f, folder_parents, "");
            const auto index =folder_files.size();
            folder_files.emplace_back(el,index);
        }
    }
    return folder_files;
}

            auto v = std::filesystem::read_symlink(p);
            std::string el = replace(p.path().string(), folder_parents, "")+" "+v.string();
            const auto index =folder_files.size();
            folder_files.emplace_back(el,index);

....
folder_files.emplace_back(std::move(el),index);
....