audiostreamdesc.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <functional>
#include <promeki/namespace.h>
#include <promeki/datastream.h>
#include <promeki/logger.h>
#include <promeki/result.h>
#include <promeki/string.h>
#include <promeki/stringregistry.h>
 
PROMEKI_NAMESPACE_BEGIN
 
using AudioStreamDescRegistry = StringRegistry<"AudioStreamDesc">;
 
class AudioStreamDesc {
        public:
                PROMEKI_DATATYPE(AudioStreamDesc, DataTypeAudioStreamDesc, 1)
 
                
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<AudioStreamDesc> readFromStream(DataStream &s);
 
                using ID = uint64_t;
 
                static constexpr ID Undefined = 0;
 
                AudioStreamDesc() = default;
 
                explicit AudioStreamDesc(ID id) : _id(id) {}
 
                explicit AudioStreamDesc(const String &name) {
                        if (name.isEmpty()) {
                                _id = Undefined;
                                return;
                        }
                        if (containsReservedDelimiter(name)) {
                                promekiWarn("AudioStreamDesc: name '%s' contains "
                                            "a reserved delimiter (':' or ','); "
                                            "rejected — using Undefined",
                                            name.cstr());
                                _id = Undefined;
                                return;
                        }
                        _id = AudioStreamDescRegistry::instance().findOrCreateProbe(name);
                }
 
                ID id() const { return _id; }
 
                String name() const {
                        if (_id == Undefined) return String("Undefined");
                        return AudioStreamDescRegistry::instance().name(_id);
                }
 
                bool isUndefined() const { return _id == Undefined; }
 
                bool isValid() const {
                        if (_id == Undefined) return true; // Undefined is a valid value
                        return !AudioStreamDescRegistry::instance().name(_id).isEmpty();
                }
 
                bool operator==(const AudioStreamDesc &o) const { return _id == o._id; }
                bool operator!=(const AudioStreamDesc &o) const { return _id != o._id; }
                bool operator<(const AudioStreamDesc &o) const { return _id < o._id; }
 
                String toString() const { return name(); }
 
                static Result<AudioStreamDesc> fromString(const String &name) {
                        if (name.isEmpty() || name == "Undefined") return makeResult(AudioStreamDesc());
                        if (containsReservedDelimiter(name)) return makeError<AudioStreamDesc>(Error::Invalid);
                        return makeResult(AudioStreamDesc(AudioStreamDescRegistry::instance().findOrCreateProbe(name)));
                }
 
                static AudioStreamDesc lookup(const String &name) {
                        if (name.isEmpty() || name == "Undefined") return AudioStreamDesc();
                        if (containsReservedDelimiter(name)) {
                                promekiWarn("AudioStreamDesc::lookup: name '%s' "
                                            "contains a reserved delimiter (':' "
                                            "or ','); rejected — returning Undefined",
                                            name.cstr());
                                return AudioStreamDesc();
                        }
                        ID id = AudioStreamDescRegistry::instance().findId(name);
                        if (id == AudioStreamDescRegistry::InvalidID) return AudioStreamDesc();
                        return AudioStreamDesc(id);
                }
 
        private:
                ID _id = Undefined;
 
                static bool containsReservedDelimiter(const String &name) {
                        return name.find(':') != String::npos || name.find(',') != String::npos;
                }
};
 
inline Error AudioStreamDesc::writeToStream(DataStream &s) const {
        s << name();
        return s.status() == DataStream::Ok ? Error::Ok : s.toError();
}
 
template <>
inline Result<AudioStreamDesc> AudioStreamDesc::readFromStream<1>(DataStream &s) {
        String name;
        s >> name;
        if (s.status() != DataStream::Ok) return makeError<AudioStreamDesc>(s.toError());
        if (name.isEmpty() || name == "Undefined") return makeResult(AudioStreamDesc());
        // Re-register the name so cross-process round-trips are
        // self-consistent — the receiving side may not have seen this
        // name yet.  Names containing reserved delimiters produce
        // Undefined and a warning (handled by the ctor).
        return makeResult(AudioStreamDesc(name));
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::AudioStreamDesc);
 
template <> struct std::hash<promeki::AudioStreamDesc> {
                size_t operator()(const promeki::AudioStreamDesc &v) const noexcept {
                        return std::hash<uint64_t>()(v.id());
                }
};
 
#endif // PROMEKI_ENABLE_PROAV