ASS: Create parts of the lines from the ASS

src/Lib/Ass/Line.cc

@@ -27,7 +27,27 @@ Line::Line(AssFactory *const factory, const QString &lineString)
         throw std::runtime_error(("invalid event line header: " + lineString).toStdString());
 
     const QString lineContent     = lineString.mid(lineString.indexOf(": ") + 2 /* strlen ": " */);
-    const QStringList content = lineContent.split(",", Qt::KeepEmptyParts, Qt::CaseInsensitive);
+    const QStringList contentList = lineContent.split(",", Qt::KeepEmptyParts, Qt::CaseInsensitive);
+
+    if (contentList.size() != LineIndex::PastLastCode)
+        throw std::runtime_error(("invalid number of items " + QString::number(content.size()) +
+                                  " instead of " + QString::number(PastLastCode) +
+                                  " for line: " + lineContent)
+                                     .toStdString());
+
+    layer  = Utils::decodeLineToInteger(contentList[LineIndex::Layer], "Layer is not an integer");
+    effect = contentList[LineIndex::Effect];
+    nameOrActor = contentList[LineIndex::Name];
+    styleProperties.marginL =
+        Utils::decodeLineToInteger(contentList[LineIndex::MarginL], "MarginL is not an integer");
+    styleProperties.marginR =
+        Utils::decodeLineToInteger(contentList[LineIndex::MarginR], "MarginR is not an integer");
+    styleProperties.marginV =
+        Utils::decodeLineToInteger(contentList[LineIndex::MarginV], "MarginV is not an integer");
+
+    const QString style = contentList[LineIndex::Style];
+    if (!assFactory->hasStyle(style))
+        throw std::runtime_error(("Invalid or not declared style name: " + style).toStdString());
 }
 
 void

src/Lib/Ass/Line.hh

@@ -14,9 +14,12 @@ class Line {
 private:
     quint64 start{ 0 };
     quint64 end{ 0 };
+    int layer{ 0 };
 
     QVector<Syl> content{};
-    StyleProperties styleProperties;
+    StyleProperties styleProperties{};
+    QString effect{};
+    QString nameOrActor{};
 
     AssFactory *const assFactory;
 

src/Lib/Ass/Style.cc

@@ -65,70 +65,49 @@ Style::Style(const QString &styleString)
 
     styleName = content[StyleIndex::Name];
     fontName  = content[StyleIndex::FontName];
-    fontSize  = decodeLineToInteger(content[StyleIndex::FontSize], "FontSize is not an integer");
+    fontSize =
+        Utils::decodeLineToInteger(content[StyleIndex::FontSize], "FontSize is not an integer");
 
     primaryColor   = Color::fromString(content[StyleIndex::ColorPrimary]);
     secondaryColor = Color::fromString(content[StyleIndex::ColorSecondary]);
     outlineColor   = Color::fromString(content[StyleIndex::ColorOutline]);
     backColor      = Color::fromString(content[StyleIndex::ColorBack]);
 
-    bold      = decodeLineToBoolean(content[StyleIndex::Bold], "Bold is not a boolean");
-    italic    = decodeLineToBoolean(content[StyleIndex::Italic], "Italic is not a boolean");
-    underline = decodeLineToBoolean(content[StyleIndex::Underline], "Underline is not a boolean");
-    strikeOut = decodeLineToBoolean(content[StyleIndex::StrikeOut], "StrikeOut is not a boolean");
-
-    scaleX  = decodeLineToFloating(content[StyleIndex::ScaleX], "ScaleX is not a floating");
-    scaleY  = decodeLineToFloating(content[StyleIndex::ScaleY], "ScaleY is not a floating");
-    spacing = decodeLineToFloating(content[StyleIndex::ScaleY], "Spacing is not a floating");
-    angle   = decodeLineToFloating(content[StyleIndex::Angle], "Angle is not a floating");
-    borderStyle =
-        decodeLineToFloating(content[StyleIndex::BorderStyle], "BorderStyle is not a floating");
-    outline = decodeLineToFloating(content[StyleIndex::Outline], "Outline is not a floating");
-    shadow  = decodeLineToFloating(content[StyleIndex::Shadow], "Shadow is not a floating");
+    bold   = Utils::decodeLineToBoolean(content[StyleIndex::Bold], "Bold is not a boolean");
+    italic = Utils::decodeLineToBoolean(content[StyleIndex::Italic], "Italic is not a boolean");
+    underline =
+        Utils::decodeLineToBoolean(content[StyleIndex::Underline], "Underline is not a boolean");
+    strikeOut =
+        Utils::decodeLineToBoolean(content[StyleIndex::StrikeOut], "StrikeOut is not a boolean");
+
+    scaleX  = Utils::decodeLineToFloating(content[StyleIndex::ScaleX], "ScaleX is not a floating");
+    scaleY  = Utils::decodeLineToFloating(content[StyleIndex::ScaleY], "ScaleY is not a floating");
+    spacing = Utils::decodeLineToFloating(content[StyleIndex::ScaleY], "Spacing is not a floating");
+    angle   = Utils::decodeLineToFloating(content[StyleIndex::Angle], "Angle is not a floating");
+    borderStyle = Utils::decodeLineToFloating(content[StyleIndex::BorderStyle],
+                                              "BorderStyle is not a floating");
+    outline =
+        Utils::decodeLineToFloating(content[StyleIndex::Outline], "Outline is not a floating");
+    shadow = Utils::decodeLineToFloating(content[StyleIndex::Shadow], "Shadow is not a floating");
 
     alignment =
-        decodeLineToInteger(content[StyleIndex::Alignement], "Alignement is not an integer");
+        Utils::decodeLineToInteger(content[StyleIndex::Alignement], "Alignement is not an integer");
     if (alignment < 1 || alignment > 9)
         throw std::runtime_error(
             ("invalid line content: Alignement must be between 1 and 9 included, it was " +
              QString::number(alignment))
                 .toStdString());
 
-    marginL  = decodeLineToInteger(content[StyleIndex::MarginL], "MarginL is not an integer");
-    marginR  = decodeLineToInteger(content[StyleIndex::MarginR], "MarginR is not an integer");
-    marginV  = decodeLineToInteger(content[StyleIndex::MarginV], "MarginV is not an integer");
-    encoding = decodeLineToInteger(content[StyleIndex::Encoding], "Encoding is not an integer");
+    marginL = Utils::decodeLineToInteger(content[StyleIndex::MarginL], "MarginL is not an integer");
+    marginR = Utils::decodeLineToInteger(content[StyleIndex::MarginR], "MarginR is not an integer");
+    marginV = Utils::decodeLineToInteger(content[StyleIndex::MarginV], "MarginV is not an integer");
+    encoding =
+        Utils::decodeLineToInteger(content[StyleIndex::Encoding], "Encoding is not an integer");
 
     if (encoding != 1)
         qWarning() << "Encoding is not '1' in the ASS Style";
 }
 
-bool
-Style::decodeLineToBoolean(const QString &item, const QString &error)
-{
-    return decodeLineToInteger(item, error) >= 1;
-}
-
-int
-Style::decodeLineToInteger(const QString &item, const QString &error)
-{
-    bool conversion = false;
-    int ret         = item.toInt(&conversion);
-    if (!conversion)
-        throw std::runtime_error(("invalid line content: " + error).toStdString());
-    return ret;
-}
-
-float
-Style::decodeLineToFloating(const QString &item, const QString &error)
-{
-    bool conversion = false;
-    float ret       = item.toFloat(&conversion);
-    if (!conversion)
-        throw std::runtime_error(("invalid line content: " + error).toStdString());
-    return ret;
-}
-
 QString
 Color::toString(const QColor &c) noexcept
 {

src/Lib/Ass/Style.hh

@@ -45,11 +45,6 @@ public:
 
     QString getElementName() const noexcept;
     QJsonDocument getProperties() const noexcept;
-
-private:
-    static bool decodeLineToBoolean(const QString &item, const QString &error);
-    static int decodeLineToInteger(const QString &item, const QString &error);
-    static float decodeLineToFloating(const QString &item, const QString &error);
 };
 
 }

src/Lib/Ass/StyleProperties.hh

@@ -14,7 +14,7 @@ struct StyleProperties final {
     QColor primaryColor{ Color::defaultValue }, secondaryColor{ Color::defaultValue },
         outlineColor{ Color::defaultValue }, backColor{ Color::defaultValue };
 
-    QString fontName; // Can override the font's name
+    QString fontName{}; // Can override the font's name
     int fontSize{};     // The font size != the font scaling
 
     bool bold{ false }, italic{ false }, underline{ false }, strikeOut{ false };

src/Lib/Utils.cc

@@ -24,3 +24,29 @@ Utils::detectDocumentType(const QFileInfo &file, DocumentType *type)
 
     return false;
 }
+
+bool
+Utils::decodeLineToBoolean(const QString &item, const QString &error)
+{
+    return Utils::decodeLineToInteger(item, error) >= 1;
+}
+
+int
+Utils::decodeLineToInteger(const QString &item, const QString &error)
+{
+    bool conversion = false;
+    int ret         = item.toInt(&conversion);
+    if (!conversion)
+        throw std::runtime_error(("invalid line content: " + error).toStdString());
+    return ret;
+}
+
+float
+Utils::decodeLineToFloating(const QString &item, const QString &error)
+{
+    bool conversion = false;
+    float ret       = item.toFloat(&conversion);
+    if (!conversion)
+        throw std::runtime_error(("invalid line content: " + error).toStdString());
+    return ret;
+}

src/Lib/Utils.hh

@@ -85,6 +85,9 @@ toUnderlying(E e) noexcept
 }
 
 bool detectDocumentType(const QFileInfo &, DocumentType *);
+bool decodeLineToBoolean(const QString &item, const QString &error);
+int decodeLineToInteger(const QString &item, const QString &error);
+float decodeLineToFloating(const QString &item, const QString &error);
 }
 
 namespace Vivy