Implementing From for Custom Types in Rust

Rust's From trait is a powerful mechanism for defining conversions between types. It allows you to express that one type can be "created from" another. This is fundamental for idiomatic Rust code, enabling cleaner and more expressive data transformations. Your challenge is to implement the From trait for a custom struct, allowing it to be easily constructed from a primitive type.

Problem Description

You are tasked with creating a Color struct that represents an RGB color. This struct should have three public fields: r, g, and b, all of type u8.

Your main goal is to implement the From<u32> trait for your Color struct. This implementation should allow you to create a Color instance from a single u32 value, where the bits of the u32 represent the red, green, and blue components.

Specifically, the u32 will be interpreted as follows:

• The most significant 8 bits (bits 24-31) will be ignored.
• The next 8 bits (bits 16-23) will represent the red component.
• The next 8 bits (bits 8-15) will represent the green component.
• The least significant 8 bits (bits 0-7) will represent the blue component.

You will need to use bitwise operations to extract these components from the u32.

Examples

Example 1:

Input: A u32 value representing the color (255, 128, 64). Let's construct this u32 for demonstration. Red (255) shifted left by 16 bits: 255 << 16 Green (128) shifted left by 8 bits: 128 << 8 Blue (64): 64 The combined u32 would be (255 << 16) | (128 << 8) | 64.

// Example u32 calculation:
let input_u32 = (255u32 << 16) | (128u32 << 8) | 64u32;
// input_u32 is now 0xFF8040

Output: A Color struct: Color { r: 255, g: 128, b: 64 }

Explanation: The u32 value 0xFF8040 is converted into a Color struct.

• The red component is extracted from bits 16-23: 0xFF.
• The green component is extracted from bits 8-15: 0x80.
• The blue component is extracted from bits 0-7: 0x40. These values are then assigned to the r, g, and b fields respectively.

Example 2:

Input: A u32 value representing the color (0, 0, 0).

let input_u32 = 0u32;

Output: A Color struct: Color { r: 0, g: 0, b: 0 }

Explanation: The u32 value 0x000000 is converted. All bitwise extractions result in 0.

Example 3:

Input: A u32 value representing the color (10, 20, 30).

// Example u32 calculation:
let input_u32 = (10u32 << 16) | (20u32 << 8) | 30u32;
// input_u32 is now 0x0A141E

Output: A Color struct: Color { r: 10, g: 20, b: 30 }

Explanation: The u32 value 0x0A141E is converted.

• Red: 0x0A (10)
• Green: 0x14 (20)
• Blue: 0x1E (30)

Constraints

• The Color struct must have fields r, g, and b, all of type u8.
• The implementation must use the From<u32> trait.
• The bitwise operations must correctly extract the color components as described.
• The ignored bits (24-31) should not affect the output.

Notes

• You will need to define the Color struct.
• You will need to implement std::convert::From<u32> for Color.
• Remember to use bitwise AND (&) and bitwise shifts (>>, <<) to extract the correct byte components.
• Consider the order of operations for shifting and masking.
• You can use {:02X} formatting in println! to help visualize hexadecimal byte values for debugging.