Golang中用位集表示物理设备能力及单位映射的技术咨询

Hey there! Let's tackle your Go device modeling problem step by step—you're already on the right track with using bit flags for capabilities, so let's expand on that and solve the unit mapping piece too.

Go doesn't have a built-in bitset type like C++, but your existing iota-defined constants are perfect for creating a bitmask using an unsigned integer. Here's how to integrate that into your PhysicalDevice struct:

First, update your struct to include a Capabilities field (use uint64 instead if you need to support more than 32 physical quantities):

const (
    // Light can be measured in the form of luminosity
    Light = 1 << iota
    Mass
    ElectricalCurrent
    Temperature // Add another example quantity for demonstration
)

type PhysicalDevice struct {
    Owner        string
    ID           string
    Description  string
    Capabilities uint // Bitmask to track supported measurements
}

Now you can easily set, check, and combine capabilities using basic bitwise operations:

// Create a device that measures both electrical current and temperature
multiMeter := PhysicalDevice{
    Owner:       "City Lab",
    ID:          "METER-001",
    Description: "Multi-function digital meter",
    Capabilities: ElectricalCurrent | Temperature, // Combine flags with OR
}

// Check if the device supports measuring electrical current
if multiMeter.Capabilities&ElectricalCurrent != 0 {
    fmt.Println("This device can measure electrical current!")
}

// Add support for light measurement later
multiMeter.Capabilities |= Light

This approach is lightweight, efficient, and handles arbitrary combinations of capabilities perfectly—exactly what you need for unknown pre-defined measurement combinations.

To link each supported physical quantity to its specific unit, you can add a map field to PhysicalDevice that maps your quantity constants to their corresponding unit strings. Let's update the struct and show how to use it:

type PhysicalDevice struct {
    Owner        string
    ID           string
    Description  string
    Capabilities uint
    UnitMap      map[uint]string // Maps quantity constants to their units
}

Initialize the device with specific units for each supported quantity:

multiMeter := PhysicalDevice{
    Owner:       "City Lab",
    ID:          "METER-001",
    Description: "Multi-function digital meter",
    Capabilities: ElectricalCurrent | Temperature,
    UnitMap: map[uint]string{
        ElectricalCurrent: "Ampere (A)",
        Temperature:       "Celsius (°C)",
    },
}

// Retrieve the unit for electrical current
if unit, ok := multiMeter.UnitMap[ElectricalCurrent]; ok {
    fmt.Printf("Electrical current is measured in %s\n", unit)
}

For extra robustness, you could define a custom Unit struct that holds additional details (like conversion factors or symbols), but a simple map works great for basic use cases.

Here's a complete example that ties everything together with helper methods for cleaner code:

package main

import "fmt"

const (
    Light = 1 << iota
    Mass
    ElectricalCurrent
    Temperature
)

type PhysicalDevice struct {
    Owner        string
    ID           string
    Description  string
    Capabilities uint
    UnitMap      map[uint]string
}

// Supports checks if the device can measure a given physical quantity
func (d *PhysicalDevice) Supports(quantity uint) bool {
    return d.Capabilities&quantity != 0
}

// GetUnit retrieves the unit for a supported physical quantity
func (d *PhysicalDevice) GetUnit(quantity uint) (string, bool) {
    if !d.Supports(quantity) {
        return "", false
    }
    unit, ok := d.UnitMap[quantity]
    return unit, ok
}

func main() {
    // Create a shipping scale that measures mass and light intensity
    shippingScale := PhysicalDevice{
        Owner:       "Warehouse Z",
        ID:          "SCALE-007",
        Description: "Digital scale with integrated light sensor",
        Capabilities: Mass | Light,
        UnitMap: map[uint]string{
            Mass:  "Kilogram (kg)",
            Light: "Lumen (lm)",
        },
    }

    // Check capabilities and units
    if shippingScale.Supports(Mass) {
        if unit, ok := shippingScale.GetUnit(Mass); ok {
            fmt.Printf("Scale measures mass in %s\n", unit)
        }
    }

    if shippingScale.Supports(ElectricalCurrent) {
        fmt.Println("Scale can measure electrical current!")
    } else {
        fmt.Println("Scale cannot measure electrical current")
    }
}

This setup gives you the flexibility to handle any combination of physical quantities and their corresponding units, which fits exactly what you're looking for.

内容的提问来源于stack exchange，提问作者BigONotation