transcript.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <promeki/datastream.h>
#include <promeki/datatype.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/namespace.h>
#include <promeki/result.h>
#include <promeki/sharedptr.h>
#include <promeki/string.h>
#include <promeki/timestamp.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class JsonObject;
class Metadata;
struct TranscriptImpl;     // Pimpl — defined in transcript.cpp.
struct TranscriptListImpl; // Pimpl — defined in transcript.cpp.
 
class TranscriptWord {
        public:
                PROMEKI_DATATYPE(TranscriptWord, DataTypeTranscriptWord, 1)
 
                
                using List = ::promeki::List<TranscriptWord>;
 
                TranscriptWord() = default;
 
                TranscriptWord(String text, TimeStamp start, TimeStamp end, float confidence = 1.0f)
                    : _text(std::move(text)), _start(start), _end(end), _confidence(confidence) {}
 
                const String &text() const { return _text; }
 
                const TimeStamp &start() const { return _start; }
 
                const TimeStamp &end() const { return _end; }
 
                float confidence() const { return _confidence; }
 
                TimeStamp::Duration duration() const { return _end.value() - _start.value(); }
 
                void setText(String v) { _text = std::move(v); }
                void setStart(const TimeStamp &v) { _start = v; }
                void setEnd(const TimeStamp &v) { _end = v; }
                void setConfidence(float v) { _confidence = v; }
 
                bool operator==(const TranscriptWord &o) const {
                        return _text == o._text && _start == o._start && _end == o._end
                                && _confidence == o._confidence;
                }
                bool operator!=(const TranscriptWord &o) const { return !(*this == o); }
 
                JsonObject toJson() const;
 
                String toString() const;
 
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<TranscriptWord> readFromStream(DataStream &s);
 
        private:
                String    _text;
                TimeStamp _start;
                TimeStamp _end;
                float     _confidence = 1.0f;
};
 
DataStream &operator<<(DataStream &stream, const TranscriptWord &word);
 
DataStream &operator>>(DataStream &stream, TranscriptWord &word);
 
class Transcript {
        public:
                PROMEKI_DATATYPE(Transcript, DataTypeTranscript, 1)
 
                
                Transcript();
 
                explicit Transcript(TranscriptWord::List words);
 
                Transcript(TranscriptWord::List words, String speaker, String language, float confidence, bool partial);
 
                Transcript(const Transcript &);
                Transcript(Transcript &&) noexcept;
                ~Transcript();
                Transcript &operator=(const Transcript &);
                Transcript &operator=(Transcript &&) noexcept;
 
                // -- Read-only accessors ----------------------------------
 
                const TranscriptWord::List &words() const;
 
                const String &speaker() const;
 
                const String &language() const;
 
                float confidence() const;
 
                bool partial() const;
 
                const Metadata &metadata() const;
 
                // -- Derived fields ---------------------------------------
 
                const String &text() const;
 
                TimeStamp start() const;
 
                TimeStamp end() const;
 
                TimeStamp::Duration duration() const;
 
                bool isEmpty() const;
 
                // -- CoW mutators -----------------------------------------
 
                void setWords(TranscriptWord::List v);
                void appendWord(TranscriptWord w);
                void setSpeaker(String v);
                void setLanguage(String v);
                void setConfidence(float v);
                void setPartial(bool v);
                void setMetadata(Metadata v);
 
                // -- Comparison + diagnostics -----------------------------
 
                bool operator==(const Transcript &o) const;
                bool operator!=(const Transcript &o) const { return !(*this == o); }
 
                JsonObject toJson() const;
 
                String toString() const;
 
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<Transcript> readFromStream(DataStream &s);
 
        private:
                SharedPtr<TranscriptImpl> _d;
};
 
// ============================================================================
// TranscriptList
// ============================================================================
 
class TranscriptList {
        public:
                TranscriptList();
                explicit TranscriptList(List<Transcript> entries);
                TranscriptList(const TranscriptList &);
                TranscriptList(TranscriptList &&) noexcept;
                ~TranscriptList();
                TranscriptList &operator=(const TranscriptList &);
                TranscriptList &operator=(TranscriptList &&) noexcept;
 
                // -- Size / access ----------------------------------------
 
                size_t size() const;
                bool   isEmpty() const;
 
                const Transcript &at(size_t i) const;
 
                const Transcript &operator[](size_t i) const;
 
                // -- Mutators (CoW) ---------------------------------------
 
                void append(const Transcript &t);
 
                void clear();
 
                void sortByStart();
 
                void reserve(size_t n);
 
                // -- Search helpers ---------------------------------------
 
                int64_t findActiveAt(const TimeStamp &t) const;
 
                int64_t findNextAfter(const TimeStamp &t) const;
 
                // -- Raw access -------------------------------------------
 
                const List<Transcript> &entries() const;
 
                // -- Comparison + diagnostics -----------------------------
 
                bool operator==(const TranscriptList &o) const;
                bool operator!=(const TranscriptList &o) const { return !(*this == o); }
 
                JsonObject toJson() const;
 
                String toString() const;
 
        private:
                SharedPtr<TranscriptListImpl> _d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV