BaosDevicesMeta.h

Go to the documentation of this file.

//
// Copyright (c) 2002-2026 WEINZIERL ENGINEERING GmbH
// All rights reserved.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY,
// WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
//
#ifndef __BAOSLIB_INTERFACE_META_H__
#define __BAOSLIB_INTERFACE_META_H__
 
#include "baos/protocol/Defines.h"
 
#include "wzcpp/features/utils/ByteArray.h"
 
 
#include <array>
#include <cassert>
#include <cstdint>
#include <functional>
#include <map>
#include <optional>
#include <string>
 
namespace wz::baos
{
struct DeviceGroupIdentifier
{
    DeviceGroupIdentifier(const protocol::ServerItem& manufacturerApp,
                          const protocol::ServerItem& applicationId,
                          const protocol::ServerItem& applicationVersion)
    {
        assert(manufacturerApp.id == protocol::ServerItemId::ManufactureCodeApp);
        assert(applicationId.id == protocol::ServerItemId::ApplicationId);
        assert(applicationVersion.id == protocol::ServerItemId::ApplicationVersion);
 
        deviceid[0] = static_cast<std::byte>(manufacturerApp.data[0] & 0xff);
        deviceid[1] = static_cast<std::byte>(manufacturerApp.data[1] & 0xff);
        deviceid[2] = static_cast<std::byte>(applicationId.data[0] & 0xff);
        deviceid[3] = static_cast<std::byte>(applicationId.data[1] & 0xff);
        deviceid[4] = static_cast<std::byte>(applicationVersion.data[0] & 0xff);
    };
 
    DeviceGroupIdentifier(std::uint16_t manufacturerApp, std::uint16_t applicationId, std::uint8_t applicationVersion)
    {
        deviceid[0] = static_cast<std::byte>((manufacturerApp >> 8) & 0xff);
        deviceid[1] = static_cast<std::byte>(manufacturerApp & 0xff);
        deviceid[2] = static_cast<std::byte>((applicationId >> 8) & 0xff);
        deviceid[3] = static_cast<std::byte>(applicationId & 0xff);
        deviceid[4] = static_cast<std::byte>(applicationVersion & 0xff);
    };
 
    bool operator==(const DeviceGroupIdentifier& other) const
    {
        return (deviceid == other.deviceid);
    }
    bool operator<(const DeviceGroupIdentifier& other) const
    {
        return (deviceid < other.deviceid);
    }
 
    std::array<std::byte, 5> deviceid;  
};
 
struct DeviceMeta
{
    using UPtr = std::unique_ptr<DeviceMeta>;  
    std::string name;                          
    std::uint16_t maxServerItemId{0};          
    std::uint16_t maxParameterBytes{0};        
    std::uint16_t maxDatapoints{0};            
};
 
using DevicesMeta =
    std::map<DeviceGroupIdentifier, DeviceMeta>;  
 
static DevicesMeta DevicesMetaLookup = {
    {{0xC5, 0x0708, 0x10}, DeviceMeta{"771", 18, 250, 250}},
    {{0xC5, 0x0709, 0x10}, DeviceMeta{"772", 18, 250, 1000}},  // despite having 1000 parameter bytes configurable in
                                                               // the ETS, the service only allows access to 250
    {{0xC5, 0x0714, 0x10}, DeviceMeta{"773", 18, 250, 250}},
    {{0xC5, 0x0715, 0x10}, DeviceMeta{"774", 18, 1000, 1000}}};
 
 
BAOSLIB_EXPORT std::optional<std::uint16_t> getAvailableBufferSizeFromMeta(const wzcpp::SixByteArray& hardwareType);
 
}  // namespace wz::baos
 
namespace std
{
 
template<>
struct hash<wz::baos::DeviceGroupIdentifier>
{
    std::size_t operator()(const wz::baos::DeviceGroupIdentifier& k) const
    {
        using std::hash;
        using std::size_t;
        using std::string;
 
        std::ostringstream stream;
 
        auto first = begin(k.deviceid);
        auto last  = end(k.deviceid);
        if (first != last)
        {  // initial check
            while (true)
            {
                stream << std::uppercase << std::setw(2) << std::setfill('0') << std::hex
                    << static_cast<short>(*first++);  // Write to stream in format 0F
                if (first == last) break;
                stream << " ";
            }
        }
 
        return std::hash<std::string>()(stream.str());
    }
};
 
}  // namespace std
 
#endif  // end ifdef __BAOSLIB_INTERFACE_META_H__