runtime/src/native/corehost/fx_reference.h at main · dotnet/runtime · GitHub

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

#ifndef __FX_REFERENCE_H__
#define __FX_REFERENCE_H__

#include <list>
#include "pal.h"
#include "fx_ver.h"
#include "roll_forward_option.h"
#include "version_compatibility_range.h"

class fx_reference_t
{
public:
    fx_reference_t()
        : apply_patches(true)
        , version_compatibility_range(version_compatibility_range_t::minor)
        , roll_to_highest_version(false)
        , prefer_release(false)
        , fx_name(_X(""))
        , fx_version(_X(""))
        , fx_version_number()
        { }

    const pal::string_t& get_fx_name() const
    {
        return fx_name;
    }
    void set_fx_name(const pal::string_t& value)
    {
        fx_name = value;
    }

    const pal::string_t& get_fx_version() const
    {
        return fx_version;
    }
    void set_fx_version(const pal::string_t& value)
    {
        fx_version = value;

        fx_ver_t::parse(fx_version, &fx_version_number);
    }

    const fx_ver_t& get_fx_version_number() const
    {
        return fx_version_number;
    }

    bool get_apply_patches() const
    {
        return apply_patches;
    }
    void set_apply_patches(bool value)
    {
        apply_patches = value;
    }

    version_compatibility_range_t get_version_compatibility_range() const
    {
        return version_compatibility_range;
    }

    void set_roll_forward(roll_forward_option value)
    {
        switch (value)
        {
        case roll_forward_option::Disable:
            version_compatibility_range = version_compatibility_range_t::exact;
            roll_to_highest_version = false;
            break;
        case roll_forward_option::LatestPatch:
            version_compatibility_range = version_compatibility_range_t::patch;
            roll_to_highest_version = false;
            break;
        case roll_forward_option::Minor:
            version_compatibility_range = version_compatibility_range_t::minor;
            roll_to_highest_version = false;
            break;
        case roll_forward_option::LatestMinor:
            version_compatibility_range = version_compatibility_range_t::minor;
            roll_to_highest_version = true;
            break;
        case roll_forward_option::Major:
            version_compatibility_range = version_compatibility_range_t::major;
            roll_to_highest_version = false;
            break;
        case roll_forward_option::LatestMajor:
            version_compatibility_range = version_compatibility_range_t::major;
            roll_to_highest_version = true;
            break;
        case roll_forward_option::__Last:
            assert(false);
            break;
        }
    }

    bool get_roll_to_highest_version() const
    {
        return roll_to_highest_version;
    }
    void set_roll_to_highest_version(bool value)
    {
        roll_to_highest_version = value;
    }

    bool get_prefer_release() const
    {
        return prefer_release;
    }
    void set_prefer_release(bool value)
    {
        prefer_release = value;
    }

    // Is the current version compatible with the specified equal or higher version.
    bool is_compatible_with_higher_version(const fx_ver_t& higher_version) const;

    // Merge roll forward settings for two framework references
    void merge_roll_forward_settings_from(const fx_reference_t& from);

    bool operator==(const fx_reference_t& other)
    {
        return
            fx_name == other.fx_name &&
            fx_version == other.fx_version &&
            apply_patches == other.apply_patches &&
            version_compatibility_range == other.version_compatibility_range &&
            roll_to_highest_version == other.roll_to_highest_version &&
            prefer_release == other.prefer_release;
    }

    bool operator!=(const fx_reference_t& other)
    {
        return !(*this == other);
    }

private:
    bool apply_patches;

    version_compatibility_range_t version_compatibility_range;
    bool roll_to_highest_version;

    // This indicates that when resolving the framework reference the search should prefer release version
    // and only resolve to pre-release if there's no matching release version available.
    bool prefer_release;

    pal::string_t fx_name;

    pal::string_t fx_version;
    fx_ver_t fx_version_number;
};

typedef std::vector<fx_reference_t> fx_reference_vector_t;
typedef std::unordered_map<pal::string_t, fx_reference_t> fx_name_to_fx_reference_map_t;

#endif // __FX_REFERENCE_H__