Hugging Face's logo

Datasets:
jasonfan
/
devboxbackup

Dataset card Files
xet
 Community
devboxbackup
File size: 3,621 Bytes
2492322
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
// Copyright (c) 2019, QuantStack and Mamba Contributors
//
// Distributed under the terms of the BSD 3-Clause License.
//
// The full license is in the file LICENSE, distributed with this software.

#ifndef MAMBA_CORE_QUERY_HPP
#define MAMBA_CORE_QUERY_HPP

#include <iosfwd>
#include <map>
#include <string>
#include <string_view>
#include <vector>

#include "mamba/core/context.hpp"
#include "mamba/specs/package_info.hpp"
#include "mamba/util/graph.hpp"

namespace mamba
{
    namespace solver::libsolv
    {
        class Database;
    }

    enum class QueryType
    {
        Search,
        Depends,
        WhoNeeds
    };

    constexpr auto enum_name(QueryType t) -> std::string_view;

    auto query_type_parse(std::string_view name) -> QueryType;

    class QueryResult
    {
    public:

        using GraphicsParams = Context::GraphicsParams;
        using dependency_graph = util::DiGraph<specs::PackageInfo>;

        QueryResult(QueryType type, std::string query, dependency_graph dep_graph);
        QueryResult(const QueryResult&) = default;
        QueryResult(QueryResult&&) = default;

        ~QueryResult() = default;

        auto operator=(const QueryResult&) -> QueryResult& = default;
        auto operator=(QueryResult&&) -> QueryResult& = default;

        [[nodiscard]] auto type() const -> QueryType;
        [[nodiscard]] auto query() const -> const std::string&;
        [[nodiscard]] auto empty() const -> bool;

        auto sort(std::string_view field) -> QueryResult&;

        auto groupby(std::string_view field) -> QueryResult&;

        auto reset() -> QueryResult&;

        auto table(std::ostream&) const -> std::ostream&;
        auto table(std::ostream&, const std::vector<std::string_view>& fmt) const -> std::ostream&;
        [[nodiscard]] auto table_to_str() const -> std::string;

        auto tree(std::ostream&, const GraphicsParams& graphics) const -> std::ostream&;
        [[nodiscard]] auto tree_to_str(const GraphicsParams& graphics) const -> std::string;

        [[nodiscard]] auto json() const -> nlohmann::json;

        auto pretty(std::ostream&, bool show_all_builds) const -> std::ostream&;
        [[nodiscard]] auto pretty_to_str(bool show_all_builds) const -> std::string;

    private:

        using node_id = dependency_graph::node_id;
        using package_id_list = std::vector<node_id>;
        using ordered_package_list = std::map<std::string, package_id_list>;

        void reset_pkg_view_list();

        QueryType m_type;
        std::string m_query;
        dependency_graph m_dep_graph;
        package_id_list m_pkg_id_list = {};
        ordered_package_list m_ordered_pkg_id_list = {};
    };

    class Query
    {
    public:

        using Database = solver::libsolv::Database;

        [[nodiscard]] static auto find(Database& database, const std::vector<std::string>& queries)
            -> QueryResult;

        [[nodiscard]] static auto whoneeds(Database& database, std::string query, bool tree)
            -> QueryResult;

        [[nodiscard]] static auto depends(Database& database, std::string query, bool tree)
            -> QueryResult;
    };

    /********************
     *  Implementation  *
     ********************/

    constexpr auto enum_name(QueryType t) -> std::string_view
    {
        switch (t)
        {
            case QueryType::Search:
                return "Search";
            case QueryType::WhoNeeds:
                return "WhoNeeds";
            case QueryType::Depends:
                return "Depends";
        }
        throw std::invalid_argument("Invalid enum value");
    }
}
#endif