CRNAltoTextBlock.cpp

Go to the documentation of this file.

/* Copyright 2011-2016 CoReNum
 * 
 * This file is part of libcrn.
 * 
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNAltoTextBlock.cpp
 * \author Yann LEYDIER
 */

#include <CRNXml/CRNAlto.h>
#include <CRNException.h>
#include <CRNString.h>
#include <algorithm>
#include <CRNi18n.h>

using namespace crn;
using namespace xml;


// TextBlock

Alto::Layout::Page::Space::TextBlock::TextBlock(const Element &el):
    Block(el)
{
    update_subelements();
}

void Alto::Layout::Page::Space::TextBlock::update_subelements()
{
    lines.clear();
    id_lines.clear();
    Element cel = GetFirstChildElement("TextLine");
    while (cel)
    {
        lines.push_back(std::shared_ptr<TextLine>(new TextLine(cel)));
        id_lines[lines.back()->GetId()] = lines.back();
        cel = cel.GetNextSiblingElement("TextLine");
    }
}

Alto::Layout::Page::Space::TextBlock::TextBlock(const Element &el, const Id &id_, int x, int y, int w, int h):
    Block(el, id_, x, y, w, h)
{ }

Option<StringUTF8> Alto::Layout::Page::Space::TextBlock::GetLanguage() const
{
    Option<StringUTF8> language;
    StringUTF8 str = GetAttribute<StringUTF8>("language");
    if (str.IsNotEmpty())
        language = str;
    return language;
}

std::vector<Alto::Layout::Page::Space::TextBlock::TextLinePtr> Alto::Layout::Page::Space::TextBlock::GetTextLines() const 
{ 
    if (GetNbSubelements() != lines.size()) 
        const_cast<TextBlock*>(this)->update_subelements(); 
    return std::vector<TextLinePtr>(lines.begin(), lines.end());
}

Alto::Layout::Page::Space::TextBlock::TextLine& Alto::Layout::Page::Space::TextBlock::GetTextLine(const Id &id_)
{
    if (GetNbSubelements() != lines.size()) 
        const_cast<TextBlock*>(this)->update_subelements(); 

    std::map<Id, TextLinePtr>::iterator it(id_lines.find(id_));
    if ((it != id_lines.end()) && !it->second.expired())
        return *(it->second.lock());
    for (const std::shared_ptr<TextLine> &tl : lines)
    {
        if (tl->GetId() == id_)
        {
            id_lines[id_] = tl;
            return *tl;
        }
    }
    throw ExceptionNotFound(_("The block contains no text line with this id."));
}

Alto::Layout::Page::Space::TextBlock::TextLine& Alto::Layout::Page::Space::TextBlock::AddTextLine(const Id &id_, double x, double y, double w, double h)
{
    lines.push_back(std::shared_ptr<TextLine>(new TextLine(PushBackElement("TextLine"), id_, x, y, w, h)));
    id_lines[id_] = lines.back();
    return *lines.back();
}

Alto::Layout::Page::Space::TextBlock::TextLine& Alto::Layout::Page::Space::TextBlock::AddTextLineAfter(const Id &pred, const Id &id_, double x, double y, double w, double h)
{
    for (std::vector<std::shared_ptr<TextLine> >::iterator it = lines.begin(); it != lines.end(); ++it)
    {
        if ((*it)->GetId() == pred)
        {
            Element pel(**it);
            ++it;
            if (it == lines.end())
                return AddTextLine(id_, x, y, w, h);
            else
            {
                std::shared_ptr<TextLine> tl(new TextLine(InsertElement(pel, "TextLine"), id_, x, y, w, h));
                lines.insert(it, tl);
                id_lines[id_] = tl;
                return *tl;
            }
        }
    }
    throw crn::ExceptionNotFound(_("Page not found."));
}

Alto::Layout::Page::Space::TextBlock::TextLine& Alto::Layout::Page::Space::TextBlock::AddTextLineBefore(const Id &next, const Id &id_, double x, double y, double w, double h)
{
    for (std::vector<std::shared_ptr<TextLine> >::iterator it = lines.begin(); it != lines.end(); ++it)
    {
        if ((*it)->GetId() == next)
        {
            std::shared_ptr<TextLine> newline;
            if (it == lines.begin())
                newline.reset(new TextLine(PushFrontElement("TextLine"), id_, x, y, w, h));
            else
                newline.reset(new TextLine(InsertElement(**(it - 1), "TextLine"), id_, x, y, w, h));
            lines.insert(it, newline);
            id_lines[id_] = newline;
            return *newline;
        }
    }
    throw crn::ExceptionNotFound(_("Page not found."));
}

void Alto::Layout::Page::Space::TextBlock::RemoveTextLine(const Id &tid)
{
    for (std::vector<std::shared_ptr<TextLine> >::iterator it = lines.begin(); it != lines.end(); ++it)
    {
        if ((*it)->GetId() == tid)
        {
            RemoveChild(**it);
            lines.erase(it);
            id_lines.erase(tid);
        }
    }
    throw crn::ExceptionNotFound(_("Page not found."));
}

// TextLine

Alto::Layout::Page::Space::TextBlock::TextLine::TextLine(const Element &el):
    Element(el)
{
    id = GetAttribute<StringUTF8>("ID", false); // may throw;
    GetAttribute<double>("HEIGHT", false); // may throw
    GetAttribute<double>("WIDTH", false); // may throw
    GetAttribute<double>("HPOS", false); // may throw
    GetAttribute<double>("VPOS", false); // may throw

    update_subelements();
}

void Alto::Layout::Page::Space::TextBlock::TextLine::update_subelements()
{
    lineElements.clear();
    words.clear();
    id_words.clear();

    for (Element cel = BeginElement(); cel != EndElement(); ++cel)
    {
        std::shared_ptr<LineElement> newnode(NULL);
        String elname(cel.GetName());
        if (elname == "String")
        {
            newnode.reset(new Word(cel));
            words.push_back(std::static_pointer_cast<Word>(newnode));
            if (words.back().lock()->GetId())
                id_words[words.back().lock()->GetId().Get()] = words.back();
        }
        else if (elname == "SP")
        {
            newnode.reset(new WhiteSpace(cel));
        }
        else if (elname == "HYP")
        {
            newnode.reset(new Hyphen(cel));
        }
        if (newnode)
            lineElements.push_back(newnode);
    }
}

Alto::Layout::Page::Space::TextBlock::TextLine::TextLine(const Element &el, const Id &id_, double x, double y, double w, double h):
    Element(el),
    id(id_)
{
    SetAttribute("ID", id);
    SetAttribute("HPOS", x);
    SetAttribute("VPOS", y);
    SetAttribute("WIDTH", w);
    SetAttribute("HEIGHT", h);
}

std::vector<Id> Alto::Layout::Page::Space::TextBlock::TextLine::GetStyles() const
{
    return GetStyleRefs(*this);
}

void Alto::Layout::Page::Space::TextBlock::TextLine::AddStyle(const Id &styleid)
{
    AddStyleRef(*this, styleid);
}

void Alto::Layout::Page::Space::TextBlock::TextLine::RemoveStyle(const Id &styleid)
{
    RemoveStyleRef(*this, styleid);
}

double Alto::Layout::Page::Space::TextBlock::TextLine::GetWidth() const
{
    return GetAttribute<double>("WIDTH", false); // should not throw
}

void Alto::Layout::Page::Space::TextBlock::TextLine::SetWidth(double d)
{
    SetAttribute("WIDTH", d);
}

double Alto::Layout::Page::Space::TextBlock::TextLine::GetHeight() const
{
    return GetAttribute<double>("HEIGHT", false); // should not throw
}

void Alto::Layout::Page::Space::TextBlock::TextLine::SetHeight(double d)
{
    SetAttribute("HEIGHT", d);
}

double Alto::Layout::Page::Space::TextBlock::TextLine::GetHPos() const
{
    return GetAttribute<double>("HPOS", false); // should not throw
}

void Alto::Layout::Page::Space::TextBlock::TextLine::SetHPos(double d)
{
    SetAttribute("HPOS", d);
}

double Alto::Layout::Page::Space::TextBlock::TextLine::GetVPos() const
{
    return GetAttribute<double>("VPOS", false); // should not throw
}

void Alto::Layout::Page::Space::TextBlock::TextLine::SetVPos(double d)
{
    SetAttribute("VPOS", d);
}

Option<double> Alto::Layout::Page::Space::TextBlock::TextLine::GetBaseline() const
{
    Option<double> baseline;
    try { baseline = GetAttribute<double>("BASELINE", false); } catch (...) { }
    return baseline;
}

void Alto::Layout::Page::Space::TextBlock::TextLine::SetBaseline(double d, bool check_bounds)
{
    if (check_bounds && ((d < GetVPos()) || (d > GetVPos() + GetHeight())))
        throw ExceptionDomain(_("The baseline is out of the line's bounds"));
    SetAttribute("BASELINE", d);
}

void Alto::Layout::Page::Space::TextBlock::TextLine::UnsetBaseline()
{
    RemoveAttribute("BASELINE");
}

Option<bool> Alto::Layout::Page::Space::TextBlock::TextLine::GetManuallyCorrected() const
{
    Option<bool> manuallyCorrected;
    try { manuallyCorrected = GetAttribute<bool>("CS", false); } catch (...) { }
    return manuallyCorrected;
}

void Alto::Layout::Page::Space::TextBlock::TextLine::SetManuallyCorrected(bool c)
{
    SetAttribute("CS", c);
}

void Alto::Layout::Page::Space::TextBlock::TextLine::UnsetManuallyCorrected()
{
    RemoveAttribute("CS");
}

std::vector<Alto::Layout::Page::Space::TextBlock::TextLine::LineElementPtr> Alto::Layout::Page::Space::TextBlock::TextLine::GetLineElements() const 
{ 
    if (GetNbSubelements() != lineElements.size()) 
        const_cast<TextLine*>(this)->update_subelements(); 
    return std::vector<LineElementPtr>(lineElements.begin(), lineElements.end()); 
}

const std::vector<Alto::Layout::Page::Space::TextBlock::TextLine::WordPtr>& Alto::Layout::Page::Space::TextBlock::TextLine::GetWords() const 
{ 
    if (GetNbSubelements() != lineElements.size()) 
        const_cast<TextLine*>(this)->update_subelements(); 
    return words; 
}

Alto::Layout::Page::Space::TextBlock::TextLine::Word& Alto::Layout::Page::Space::TextBlock::TextLine::GetWord(const Id &id_)
{
    if (GetNbSubelements() != lineElements.size())
        update_subelements();
    std::map<Id, WordPtr>::iterator it(id_words.find(id_));
    if ((it != id_words.end()) && !it->second.expired())
        return *(it->second.lock());
    for (const WordPtr &word : words)
    {
        const std::shared_ptr<Word> sword(word.lock());
        if (sword->GetId() && (sword->GetId().Get() == id_))
        {
            id_words[id_] = word;
            return *sword;
        }
    }
    throw ExceptionNotFound(_("The line contains no word with this id."));
}

Alto::Layout::Page::Space::TextBlock::TextLine::Word& Alto::Layout::Page::Space::TextBlock::TextLine::AddWord(const Id &id_, const StringUTF8 &text, const Option<double> &x, const Option<double> &y, const Option<double> &w, const Option<double> &h)
{
    std::shared_ptr<Word> word(new Word(PushBackElement("String"), id_, text, x, y, w, h));
    words.push_back(word);
    id_words[id_] = word;
    lineElements.push_back(word);
    return *word;
}

Alto::Layout::Page::Space::TextBlock::TextLine::Word& Alto::Layout::Page::Space::TextBlock::TextLine::AddWordAfter(const Id &pred, const Id &id_, const StringUTF8 &text, const Option<double> &x, const Option<double> &y, const Option<double> &w, const Option<double> &h)
{
    for (std::vector<WordPtr>::iterator it = words.begin(); it != words.end(); ++it)
    {
        std::shared_ptr<Word> sw(it->lock());
        if (sw->GetId())
        {
            if (sw->GetId().Get() == pred)
            {
                Element &pw(*sw);
                ++it;
                if (it == words.end())
                    return AddWord(id_, text, x, y, w, h);
                else
                {
                    std::shared_ptr<Word> nw(new Word(InsertElement(pw, "String"), id_, text, x, y, w, h));
                    words.insert(it, nw);
                    id_words[id_] = nw;
                    sw = it->lock();
                    std::vector<std::shared_ptr<LineElement> >::iterator lit = std::find(lineElements.begin(), lineElements.end(), sw);
                    if (lit == lineElements.end())
                        lineElements.push_back(nw);
                    else
                    {
                        ++lit;
                        if (lit == lineElements.end())
                            lineElements.push_back(nw);
                        else
                            lineElements.insert(lit, nw);
                    }
                    return *nw;
                }
            } // found predecessor
        } // has an Id
    }
    throw ExceptionNotFound(_("Cannot find element."));
}

Alto::Layout::Page::Space::TextBlock::TextLine::Word& Alto::Layout::Page::Space::TextBlock::TextLine::AddWordBefore(const Id &next, const Id &id_, const StringUTF8 &text, const Option<double> &x, const Option<double> &y, const Option<double> &w, const Option<double> &h)
{
    for (std::vector<WordPtr>::iterator it = words.begin(); it != words.end(); ++it)
    {
        const std::shared_ptr<Word> sw(it->lock());
        if (sw->GetId())
        {
            if (sw->GetId().Get() == next)
            {
                std::shared_ptr<Word> nw;
                if (it == words.begin())
                    nw.reset(new Word(PushFrontElement("String"), id_, text, x, y, w, h));
                else
                    nw.reset(new Word(InsertElement(*(it - 1)->lock(), "String"), id_, text, x, y, w, h));
                words.insert(it, nw);
                id_words[id_] = nw;
                std::vector<std::shared_ptr<LineElement> >::iterator lit = std::find(lineElements.begin(), lineElements.end(), sw);
                if (lit == lineElements.end())
                    lineElements.push_back(nw);
                else
                    lineElements.insert(lit, nw);
                return *nw;
            } // found successor
        } // has an Id
    }
    throw ExceptionNotFound(_("Cannot find element."));
}

void Alto::Layout::Page::Space::TextBlock::TextLine::RemoveWord(const Id &wid)
{
    for (std::vector<WordPtr>::iterator it = words.begin(); it != words.end(); ++it)
    {
        const std::shared_ptr<Word> sw(it->lock());
        if (sw->GetId())
        {
            if (sw->GetId().Get() == wid)
            {
                RemoveChild(*sw);
                std::vector<std::shared_ptr<LineElement> >::iterator lit = std::find(lineElements.begin(), lineElements.end(), sw);
                words.erase(it);
                id_words.erase(wid);
                if (lit != lineElements.end())
                    lineElements.erase(lit);
                return;
            }
        }
    }
    throw ExceptionNotFound(_("Cannot find word."));
}

// LineElement

Alto::Layout::Page::Space::TextBlock::TextLine::LineElement::LineElement(const Element &el):
    Element(el)
{ 
    if (!el)
        throw ExceptionInvalidArgument(_("Null node."));
}

Alto::Layout::Page::Space::TextBlock::TextLine::LineElement::LineElement(const Element &el, const Option<double> &x, const Option<double> &y, const Option<double> &w):
    Element(el)
{
    if (!el)
        throw ExceptionInvalidArgument(_("Null node."));
    if (x)
        SetAttribute("HPOS", *x);
    if (y)
        SetAttribute("VPOS", *y);
    if (w)
        SetAttribute("WIDTH", *w);
}

Option<double> Alto::Layout::Page::Space::TextBlock::TextLine::LineElement::GetWidth() const
{
    Option<double> width;
    try { width = GetAttribute<double>("WIDTH", false); } catch (...) { }
    return width;
}

void Alto::Layout::Page::Space::TextBlock::TextLine::LineElement::SetWidth(double d)
{
    SetAttribute("WIDTH", d);
}

Option<double> Alto::Layout::Page::Space::TextBlock::TextLine::LineElement::GetHPos() const
{
    Option<double> hpos;
    try { hpos = GetAttribute<double>("HPOS", false); } catch (...) { }
    return hpos;
}

void Alto::Layout::Page::Space::TextBlock::TextLine::LineElement::SetHPos(double d)
{
    SetAttribute("HPOS", d);
}

Option<double> Alto::Layout::Page::Space::TextBlock::TextLine::LineElement::GetVPos() const
{
    Option<double> vpos;
    try { vpos = GetAttribute<double>("VPOS", false); } catch (...) { }
    return vpos;
}

void Alto::Layout::Page::Space::TextBlock::TextLine::LineElement::SetVPos(double d)
{
    SetAttribute("VPOS", d);
}

// Word

Alto::Layout::Page::Space::TextBlock::TextLine::Word::Word(const Element &el):
    LineElement(el)
{
    StringUTF8 str = GetAttribute<StringUTF8>("ID");
    if (str.IsNotEmpty())
        id = str;
    GetAttribute<StringUTF8>("CONTENT", false); // may throw

    /*
    for (Element cel = BeginElement(); cel != EndElement(); ++cel)
    {
        // TODO alternatives
    }
    */
}

Alto::Layout::Page::Space::TextBlock::TextLine::Word::Word(const Element &el, const Id &id_, const StringUTF8 &text, const Option<double> &x, const Option<double> &y, const Option<double> &w, const Option<double> &h):
    LineElement(el, x, y, w),
    id(id_)
{
    SetAttribute("ID", *id);
    SetAttribute("CONTENT", text);
    if (h)
        SetAttribute("HEIGHT", *h);
}

std::vector<Id> Alto::Layout::Page::Space::TextBlock::TextLine::Word::GetStyles() const
{
    return GetStyleRefs(*this);
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Word::AddStyle(const Id &styleid)
{
    AddStyleRef(*this, styleid);
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Word::RemoveStyle(const Id &styleid)
{
    RemoveStyleRef(*this, styleid);
}

StringUTF8 Alto::Layout::Page::Space::TextBlock::TextLine::Word::GetContent() const
{
    return GetAttribute<StringUTF8>("CONTENT", false); // should not throw
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Word::SetContent(const StringUTF8 &s)
{
    SetAttribute("CONTENT", s);
}

Option<double> Alto::Layout::Page::Space::TextBlock::TextLine::Word::GetHeight() const
{
    Option<double> height;
    try { height = GetAttribute<double>("HEIGHT", false); } catch (...) { }
    return height;
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Word::SetHeight(double d)
{
    SetAttribute("HEIGHT", d);
}

Option<Alto::Styles::Text::FontStyle> Alto::Layout::Page::Space::TextBlock::TextLine::Word::GetFontStyle() const
{
    Option<Alto::Styles::Text::FontStyle> fontStyle;
    StringUTF8 str = GetAttribute<StringUTF8>("STYLE");
    if (str.IsNotEmpty())
    {
        Alto::Styles::Text::FontStyle val = Alto::Styles::Text::FontStyle::Undef;
        if (str.Find("bold") != StringUTF8::NPos())
            val |= Alto::Styles::Text::FontStyle::Bold;
        if (str.Find("italics") != StringUTF8::NPos())
            val |= Alto::Styles::Text::FontStyle::Italics;
        if (str.Find("subscript") != StringUTF8::NPos())
            val |= Alto::Styles::Text::FontStyle::Subscript;
        if (str.Find("superscript") != StringUTF8::NPos())
            val |= Alto::Styles::Text::FontStyle::Superscript;
        if (str.Find("smallcaps") != StringUTF8::NPos())
            val |= Alto::Styles::Text::FontStyle::SmallCaps;
        if (str.Find("underline") != StringUTF8::NPos())
            val |= Alto::Styles::Text::FontStyle::Underline;
        if (val != Alto::Styles::Text::FontStyle::Undef)
            fontStyle = val;
    }
    return fontStyle;
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Word::SetFontStyle(Alto::Styles::Text::FontStyle fs)
{
    StringUTF8 attr;
    if (!!(fs & Alto::Styles::Text::FontStyle::Bold))
        attr += "bold ";
    if (!!(fs & Alto::Styles::Text::FontStyle::Italics))
        attr += "italics ";
    if (!!(fs & Alto::Styles::Text::FontStyle::Subscript))
        attr += "subscript ";
    if (!!(fs & Alto::Styles::Text::FontStyle::Superscript))
        attr += "superscript ";
    if (!!(fs & Alto::Styles::Text::FontStyle::SmallCaps))
        attr += "smallcaps ";
    if (!!(fs & Alto::Styles::Text::FontStyle::Underline))
        attr += "underline ";
    SetAttribute("STYLE", attr);
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Word::UnsetFontStyle()
{
    RemoveAttribute("STYLE");
}

Option<Alto::Layout::Page::Space::TextBlock::TextLine::Word::SubstitutionType> Alto::Layout::Page::Space::TextBlock::TextLine::Word::GetSubstitutionType() const
{
    Option<SubstitutionType> substitutionType;
    StringUTF8 str = GetAttribute<StringUTF8>("SUBS_TYPE");
    if (str.IsNotEmpty())
    {
        if (str == "HypPart1")
            substitutionType = SubstitutionType::HypPart1;
        else if (str == "HypPart2")
            substitutionType = SubstitutionType::HypPart2;
        else if (str == "Abbreviation")
            substitutionType = SubstitutionType::Abbreviation;
    }
    return substitutionType;
}

Option<StringUTF8> Alto::Layout::Page::Space::TextBlock::TextLine::Word::GetSubstitutionContent() const
{
    Option<StringUTF8> substitutionContent;
    StringUTF8 str = GetAttribute<StringUTF8>("SUBS_CONTENT");
    if (str.IsNotEmpty())
        substitutionContent = str;
    return substitutionContent;
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Word::SetSubstitution(SubstitutionType stype, const StringUTF8 &scontent)
{
    StringUTF8 atyp;
    switch (stype)
    {
        case SubstitutionType::HypPart1:
            atyp = "HypPart1";
            break;
        case SubstitutionType::HypPart2:
            atyp = "HypPart2";
            break;
        case SubstitutionType::Abbreviation:
            atyp = "Abbreviation";
            break;
        default:
            throw crn::ExceptionInvalidArgument(_("Wrong type of substitution."));
    }
    SetAttribute("SUBS_TYPE", atyp);
    SetAttribute("SUBS_CONTENT", scontent);
}

Option<double> Alto::Layout::Page::Space::TextBlock::TextLine::Word::GetWC() const
{
    Option<double> wordConfidence;
    try { wordConfidence = GetAttribute<double>("WC", false); } catch (...) { }
    return wordConfidence;
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Word::SetWC(double conf)
{
    if ((conf < 0.0) || (conf > 1.0))
        throw crn::ExceptionDomain(_("The word confidence must be in [0, 1]."));
    SetAttribute("WC", conf);
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Word::UnsetWC()
{
    RemoveAttribute("WC");
}


Option<StringUTF8> Alto::Layout::Page::Space::TextBlock::TextLine::Word::GetCC() const
{
    Option<StringUTF8> charactersConfidence;
    StringUTF8 str = GetAttribute<StringUTF8>("CC");
    if (str.IsNotEmpty())
        charactersConfidence = str;
    return charactersConfidence;
}

// WhiteSpace

Alto::Layout::Page::Space::TextBlock::TextLine::WhiteSpace::WhiteSpace(const Element &el):
    LineElement(el)
{ 
    StringUTF8 str = GetAttribute<StringUTF8>("ID");
    if (str.IsNotEmpty())
        id = str;
}

// Hyphen

Alto::Layout::Page::Space::TextBlock::TextLine::Hyphen::Hyphen(const Element &el):
    LineElement(el)
{
    GetAttribute<StringUTF8>("CONTENT", false); // may throw
}

StringUTF8 Alto::Layout::Page::Space::TextBlock::TextLine::Hyphen::GetContent() const
{
    return GetAttribute<StringUTF8>("CONTENT", false); // should not throw
}

void Alto::Layout::Page::Space::TextBlock::TextLine::Hyphen::SetContent(const StringUTF8 &s)
{
    SetAttribute("CONTENT", s);
}