Skip to main content

nv_redfish/
hardware_id.rs

1// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2// SPDX-License-Identifier: Apache-2.0
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
16use std::marker::PhantomData;
17
18use tagged_types::TaggedType;
19
20/// Type for hardware manufacturers.
21pub type Manufacturer<T, Tag> = TaggedType<T, ManufacturerTag<Tag>>;
22#[doc(hidden)]
23pub struct ManufacturerTag<Tag> {
24    _marker: PhantomData<Tag>,
25}
26impl<T> tagged_types::ImplementClone for ManufacturerTag<T> {}
27impl<T> tagged_types::ImplementCopy for ManufacturerTag<T> {}
28impl<T> tagged_types::ImplementHash for ManufacturerTag<T> {}
29impl<T> tagged_types::ImplementPartialEq for ManufacturerTag<T> {}
30impl<T> tagged_types::ImplementEq for ManufacturerTag<T> {}
31impl<T> tagged_types::ImplementPartialOrd for ManufacturerTag<T> {}
32impl<T> tagged_types::ImplementDeref for ManufacturerTag<T> {}
33impl<T> tagged_types::TransparentDebug for ManufacturerTag<T> {}
34impl<T> tagged_types::TransparentDisplay for ManufacturerTag<T> {}
35impl<T> tagged_types::TransparentSerialize for ManufacturerTag<T> {}
36impl<T> tagged_types::TransparentDeserialize for ManufacturerTag<T> {}
37impl<T> tagged_types::InnerAccess for ManufacturerTag<T> {}
38impl<T> tagged_types::Cloned for ManufacturerTag<T> {}
39impl<T> tagged_types::AsRef for ManufacturerTag<T> {}
40impl<T> tagged_types::ValueMap for ManufacturerTag<T> {}
41
42/// Type for hardware model.
43pub type Model<T, Tag> = TaggedType<T, ModelTag<Tag>>;
44#[doc(hidden)]
45pub struct ModelTag<Tag> {
46    _marker: PhantomData<Tag>,
47}
48impl<T> tagged_types::ImplementClone for ModelTag<T> {}
49impl<T> tagged_types::ImplementCopy for ModelTag<T> {}
50impl<T> tagged_types::ImplementHash for ModelTag<T> {}
51impl<T> tagged_types::ImplementPartialEq for ModelTag<T> {}
52impl<T> tagged_types::ImplementEq for ModelTag<T> {}
53impl<T> tagged_types::ImplementPartialOrd for ModelTag<T> {}
54impl<T> tagged_types::TransparentDebug for ModelTag<T> {}
55impl<T> tagged_types::TransparentDisplay for ModelTag<T> {}
56impl<T> tagged_types::TransparentSerialize for ModelTag<T> {}
57impl<T> tagged_types::TransparentDeserialize for ModelTag<T> {}
58impl<T> tagged_types::InnerAccess for ModelTag<T> {}
59impl<T> tagged_types::Cloned for ModelTag<T> {}
60impl<T> tagged_types::AsRef for ModelTag<T> {}
61impl<T> tagged_types::ValueMap for ModelTag<T> {}
62
63/// Type for hardware model.
64pub type PartNumber<T, Tag> = TaggedType<T, PartNumberTag<Tag>>;
65#[doc(hidden)]
66pub struct PartNumberTag<Tag> {
67    _marker: PhantomData<Tag>,
68}
69impl<T> tagged_types::ImplementClone for PartNumberTag<T> {}
70impl<T> tagged_types::ImplementCopy for PartNumberTag<T> {}
71impl<T> tagged_types::ImplementHash for PartNumberTag<T> {}
72impl<T> tagged_types::ImplementPartialEq for PartNumberTag<T> {}
73impl<T> tagged_types::ImplementEq for PartNumberTag<T> {}
74impl<T> tagged_types::ImplementPartialOrd for PartNumberTag<T> {}
75impl<T> tagged_types::TransparentDebug for PartNumberTag<T> {}
76impl<T> tagged_types::TransparentDisplay for PartNumberTag<T> {}
77impl<T> tagged_types::TransparentSerialize for PartNumberTag<T> {}
78impl<T> tagged_types::TransparentDeserialize for PartNumberTag<T> {}
79impl<T> tagged_types::InnerAccess for PartNumberTag<T> {}
80impl<T> tagged_types::Cloned for PartNumberTag<T> {}
81impl<T> tagged_types::AsRef for PartNumberTag<T> {}
82impl<T> tagged_types::ValueMap for PartNumberTag<T> {}
83
84/// Type for hardware serial numbers.
85pub type SerialNumber<T, Tag> = TaggedType<T, SerialNumberTag<Tag>>;
86#[doc(hidden)]
87pub struct SerialNumberTag<Tag> {
88    _marker: PhantomData<Tag>,
89}
90impl<T> tagged_types::ImplementClone for SerialNumberTag<T> {}
91impl<T> tagged_types::ImplementCopy for SerialNumberTag<T> {}
92impl<T> tagged_types::ImplementHash for SerialNumberTag<T> {}
93impl<T> tagged_types::ImplementPartialEq for SerialNumberTag<T> {}
94impl<T> tagged_types::ImplementEq for SerialNumberTag<T> {}
95impl<T> tagged_types::ImplementPartialOrd for SerialNumberTag<T> {}
96impl<T> tagged_types::TransparentDebug for SerialNumberTag<T> {}
97impl<T> tagged_types::TransparentDisplay for SerialNumberTag<T> {}
98impl<T> tagged_types::TransparentSerialize for SerialNumberTag<T> {}
99impl<T> tagged_types::TransparentDeserialize for SerialNumberTag<T> {}
100impl<T> tagged_types::InnerAccess for SerialNumberTag<T> {}
101impl<T> tagged_types::Cloned for SerialNumberTag<T> {}
102impl<T> tagged_types::AsRef for SerialNumberTag<T> {}
103impl<T> tagged_types::ValueMap for SerialNumberTag<T> {}
104
105/// Hardware ID is Manufacturer + Model + Part Number + Serial Number.
106/// It is tagged by the type of related redfish module.
107#[derive(Clone)]
108pub struct HardwareId<Tag> {
109    /// Manufacturer of the hardware.
110    pub manufacturer: Option<Manufacturer<String, Tag>>,
111    /// Model of the hardware.
112    pub model: Option<Model<String, Tag>>,
113    /// Part number assigned by the manufacturer
114    pub part_number: Option<PartNumber<String, Tag>>,
115    /// Serial number assigned by the manufacturer
116    pub serial_number: Option<SerialNumber<String, Tag>>,
117}
118
119/// Reference to hardware IDs.
120#[derive(Clone, Copy)]
121pub struct HardwareIdRef<'a, Tag> {
122    /// Manufacturer of the hardware.
123    pub manufacturer: Option<Manufacturer<&'a str, Tag>>,
124    /// Model of the hardware.
125    pub model: Option<Model<&'a str, Tag>>,
126    /// Part number assigned by the manufacturer
127    pub part_number: Option<PartNumber<&'a str, Tag>>,
128    /// Serial number assigned by the manufacturer
129    pub serial_number: Option<SerialNumber<&'a str, Tag>>,
130}
131
132impl<Tag> HardwareIdRef<'_, Tag> {
133    /// Transform to owned `HardwareId`.
134    #[must_use]
135    pub fn cloned(&self) -> HardwareId<Tag> {
136        HardwareId {
137            manufacturer: self.manufacturer.map(|v| v.map(ToString::to_string)),
138            model: self.model.map(|v| v.map(ToString::to_string)),
139            part_number: self.part_number.map(|v| v.map(ToString::to_string)),
140            serial_number: self.serial_number.map(|v| v.map(ToString::to_string)),
141        }
142    }
143}