CRNAlto.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: CRNAltoUtils.h
 * \author Yann LEYDIER
 */

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

using namespace crn;
using namespace xml;

Alto::Alto(const Path &fname, bool char_conversion_throws):
    Document(fname, char_conversion_throws)
{
    root.reset(new Root(GetRoot()));
    register_ids();
}

Alto::Alto(const Path &imagename, const StringUTF8 &ns, const StringUTF8 &encoding, const StringUTF8 &version, bool char_conversion_throws):
    Document(encoding, version, char_conversion_throws)
{
    PushBackComment("Created by CoReNum Nimrod Alto engine");
    root.reset(new Root(PushBackElement("Alto"), imagename, ns));
}

Alto::Layout::Page& Alto::GetPage(const Id &id)
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        const std::shared_ptr<Layout::Page> sp(p.lock());
        if (sp->GetId() == id)
            return *sp;
    } // pages
    throw ExceptionNotFound(_("Page not found."));
}

const Alto::Layout::Page& Alto::GetPage(const Id &id) const
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        const std::shared_ptr<const Layout::Page> sp(p.lock());
        if (sp->GetId() == id)
            return *sp;
    } // pages
    throw ExceptionNotFound(_("Page not found."));
}

Alto::Layout::Page::Space& Alto::GetSpace(const Id &id)
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            const std::shared_ptr<Layout::Page::Space> ss(s.lock());
            if (ss->GetId())
             if (ss->GetId().Get() == id)
                return *ss;
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Space not found."));
}

const Alto::Layout::Page::Space& Alto::GetSpace(const Id &id) const
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            const std::shared_ptr<const Layout::Page::Space> ss(s.lock());
            if (ss->GetId())
             if (ss->GetId().Get() == id)
                return *ss;
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Space not found."));
}

Alto::Layout::Page::Space::Block& Alto::GetBlock(const Id &id)
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            std::vector<Layout::Page::Space::BlockPtr> blocks(s.lock()->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<Layout::Page::Space::Block> sb(b.lock());
                if (sb->GetId() == id)
                    return *sb;
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Block not found."));
}

const Alto::Layout::Page::Space::Block& Alto::GetBlock(const Id &id) const
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            std::vector<Layout::Page::Space::BlockPtr> blocks(s.lock()->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<const Layout::Page::Space::Block> sb(b.lock());
                if (sb->GetId() == id)
                    return *sb;
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Block not found."));
}

Alto::Layout::Page::Space::TextBlock& Alto::GetTextBlock(const Id &id)
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            std::vector<Layout::Page::Space::BlockPtr> blocks(s.lock()->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<Layout::Page::Space::TextBlock> tb(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock>(b.lock()));
                if (tb)
                {
                    if (tb->GetId() == id)
                        return *tb;
                } // text block
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Text block not found."));
}

const Alto::Layout::Page::Space::TextBlock& Alto::GetTextBlock(const Id &id) const
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            std::vector<Layout::Page::Space::BlockPtr> blocks(s.lock()->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<const Layout::Page::Space::TextBlock> tb(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock>(b.lock()));
                if (tb)
                {
                    if (tb->GetId() == id)
                        return *tb;
                } // text block
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Text block not found."));
}

Alto::Layout::Page::Space::TextBlock::TextLine& Alto::GetTextLine(const Id &id)
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            std::vector<Layout::Page::Space::BlockPtr> blocks(s.lock()->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<Layout::Page::Space::TextBlock> tb(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock>(b.lock()));
                if (tb)
                {
                    std::vector<Layout::Page::Space::TextBlock::TextLinePtr> lines(tb->GetTextLines());
                    for (const Layout::Page::Space::TextBlock::TextLinePtr &l : lines)
                    {
                        const std::shared_ptr<Layout::Page::Space::TextBlock::TextLine> sl(l.lock());
                        if (sl->GetId() == id)
                            return *sl;
                    } // lines
                } // text block
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Line not found."));
}

const Alto::Layout::Page::Space::TextBlock::TextLine& Alto::GetTextLine(const Id &id) const
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            std::vector<Layout::Page::Space::BlockPtr> blocks(s.lock()->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<const Layout::Page::Space::TextBlock> tb(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock>(b.lock()));
                if (tb)
                {
                    std::vector<Layout::Page::Space::TextBlock::TextLinePtr> lines(tb->GetTextLines());
                    for (const Layout::Page::Space::TextBlock::TextLinePtr &l : lines)
                    {
                        const std::shared_ptr<const Layout::Page::Space::TextBlock::TextLine> sl(l.lock());
                        if (sl->GetId() == id)
                            return *sl;
                    } // lines
                } // text block
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Line not found."));
}

Alto::Layout::Page::Space::TextBlock::TextLine::Word& Alto::GetWord(const Id &id)
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            std::vector<Layout::Page::Space::BlockPtr> blocks(s.lock()->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<Layout::Page::Space::TextBlock> tb(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock>(b.lock()));
                if (tb)
                {
                    std::vector<Layout::Page::Space::TextBlock::TextLinePtr> lines(tb->GetTextLines());
                    for (const Layout::Page::Space::TextBlock::TextLinePtr &l : lines)
                    {
                        std::vector<Layout::Page::Space::TextBlock::TextLine::LineElementPtr> lels(l.lock()->GetLineElements());
                        for (const Layout::Page::Space::TextBlock::TextLine::LineElementPtr lel : lels)
                        {
                            const std::shared_ptr<Layout::Page::Space::TextBlock::TextLine::Word> w(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock::TextLine::Word>(lel.lock()));
                            if (w)
                            {
                                if (w->GetId())
                                    if (w->GetId().Get() == id)
                                        return *w;
                            } // word
                        } // line elements
                    } // lines
                } // text block
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Word not found."));
}

const Alto::Layout::Page::Space::TextBlock::TextLine::Word& Alto::GetWord(const Id &id) const
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        std::vector<Layout::Page::SpacePtr> spaces(p.lock()->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            std::vector<Layout::Page::Space::BlockPtr> blocks(s.lock()->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<const Layout::Page::Space::TextBlock> tb(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock>(b.lock()));
                if (tb)
                {
                    std::vector<Layout::Page::Space::TextBlock::TextLinePtr> lines(tb->GetTextLines());
                    for (const Layout::Page::Space::TextBlock::TextLinePtr &l : lines)
                    {
                        std::vector<Layout::Page::Space::TextBlock::TextLine::LineElementPtr> lels(l.lock()->GetLineElements());
                        for (const Layout::Page::Space::TextBlock::TextLine::LineElementPtr lel : lels)
                        {
                            const std::shared_ptr<const Layout::Page::Space::TextBlock::TextLine::Word> w(std::dynamic_pointer_cast<const Layout::Page::Space::TextBlock::TextLine::Word>(lel.lock()));
                            if (w)
                            {
                                if (w->GetId())
                                    if (w->GetId().Get() == id)
                                        return *w;
                            } // word
                        } // line elements
                    } // lines
                } // text block
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Word not found."));
}

Element& Alto::GetElement(const Id &id)
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        const std::shared_ptr<Layout::Page> sp(p.lock());
        if (sp->GetId() == id)
            return *sp;
        std::vector<Layout::Page::SpacePtr> spaces(sp->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            const std::shared_ptr<Layout::Page::Space> ss(s.lock());
            if (ss->GetId())
                if (ss->GetId().Get() == id)
                    return *ss;
            std::vector<Layout::Page::Space::BlockPtr> blocks(ss->GetBlocks());
            for (Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<Layout::Page::Space::Block> sb(b.lock());
                if (sb->GetId() == id)
                    return *sb;
                const std::shared_ptr<Layout::Page::Space::TextBlock> tb(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock>(sb));
                if (tb)
                {
                    std::vector<Layout::Page::Space::TextBlock::TextLinePtr> lines(tb->GetTextLines());
                    for (const Layout::Page::Space::TextBlock::TextLinePtr &l : lines)
                    {
                        const std::shared_ptr<Layout::Page::Space::TextBlock::TextLine> sl(l.lock());
                        if (sl->GetId() == id)
                            return *sl;
                        std::vector<Layout::Page::Space::TextBlock::TextLine::LineElementPtr> lels(sl->GetLineElements());
                        for (const Layout::Page::Space::TextBlock::TextLine::LineElementPtr lel : lels)
                        {
                            const std::shared_ptr<Layout::Page::Space::TextBlock::TextLine::Word> w(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock::TextLine::Word>(lel.lock()));
                            if (w)
                            {
                                if (w->GetId())
                                    if (w->GetId().Get() == id)
                                        return *w;
                            } // word
                            else
                            {
                                const std::shared_ptr<Layout::Page::Space::TextBlock::TextLine::WhiteSpace> s(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock::TextLine::WhiteSpace>(lel.lock()));
                                if (s)
                                {
                                    if (s->GetId())
                                        if (s->GetId().Get() == id)
                                            return *s;
                                } // white space
                            }
                        } // line elements
                    } // lines
                } // text block
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Element not found."));
}

const Element& Alto::GetElement(const Id &id) const
{
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        const std::shared_ptr<const Layout::Page> sp(p);
        if (sp->GetId() == id)
            return *sp;
        std::vector<Layout::Page::SpacePtr> spaces(sp->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            const std::shared_ptr<const Layout::Page::Space> ss(s.lock());
            if (ss->GetId())
                if (ss->GetId().Get() == id)
                    return *ss;
            std::vector<Layout::Page::Space::BlockPtr> blocks(ss->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<const Layout::Page::Space::Block> sb(b.lock());
                if (sb->GetId() == id)
                    return *sb;
                const std::shared_ptr<const Layout::Page::Space::TextBlock> tb(std::dynamic_pointer_cast<const Layout::Page::Space::TextBlock>(sb));
                if (tb)
                {
                    std::vector<Layout::Page::Space::TextBlock::TextLinePtr> lines(tb->GetTextLines());
                    for (const Layout::Page::Space::TextBlock::TextLinePtr &l : lines)
                    {
                        const std::shared_ptr<const Layout::Page::Space::TextBlock::TextLine> sl(l.lock());
                        if (sl->GetId() == id)
                            return *sl;
                        std::vector<Layout::Page::Space::TextBlock::TextLine::LineElementPtr> lels(sl->GetLineElements());
                        for (const Layout::Page::Space::TextBlock::TextLine::LineElementPtr lel : lels)
                        {
                            const std::shared_ptr<const Layout::Page::Space::TextBlock::TextLine::Word> w(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock::TextLine::Word>(lel.lock()));
                            if (w)
                            {
                                if (w->GetId())
                                    if (w->GetId().Get() == id)
                                        return *w;
                            } // word
                            else
                            {
                                const std::shared_ptr<const Layout::Page::Space::TextBlock::TextLine::WhiteSpace> s(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock::TextLine::WhiteSpace>(lel.lock()));
                                if (s)
                                {
                                    if (s->GetId())
                                        if (s->GetId().Get() == id)
                                            return *s;
                                } // white space
                            }
                        } // line elements
                    } // lines
                } // text block
            } // blocks
        } // spaces
    } // pages
    throw ExceptionNotFound(_("Element not found."));
}

void Alto::register_ids()
{
    std::vector<Id> lst(GetStyles().GetTextStyles());
    ids.insert(lst.begin(), lst.end());
    lst = GetStyles().GetParagraphStyles();
    ids.insert(lst.begin(), lst.end());
    std::vector<Layout::PagePtr> pages(GetLayout().GetPages());
    for (const Layout::PagePtr &p : pages)
    {
        const std::shared_ptr<const Layout::Page> sp(p.lock());
        ids.insert(sp->GetId());
        std::vector<Layout::Page::SpacePtr> spaces(sp->GetSpaces());
        for (const Layout::Page::SpacePtr &s : spaces)
        {
            const std::shared_ptr<const Layout::Page::Space> ss(s.lock());
            if (ss->GetId())
                ids.insert(ss->GetId().Get());
            std::vector<Layout::Page::Space::BlockPtr> blocks(ss->GetBlocks());
            for (const Layout::Page::Space::BlockPtr &b : blocks)
            {
                const std::shared_ptr<const Layout::Page::Space::Block> sb(b.lock());
                ids.insert(sb->GetId());
                const std::shared_ptr<const Layout::Page::Space::TextBlock> tb(std::dynamic_pointer_cast<const Layout::Page::Space::TextBlock>(sb));
                if (tb)
                {
                    std::vector<Layout::Page::Space::TextBlock::TextLinePtr> lines(tb->GetTextLines());
                    for (const Layout::Page::Space::TextBlock::TextLinePtr &l : lines)
                    {
                        const std::shared_ptr<const Layout::Page::Space::TextBlock::TextLine> sl(l.lock());
                        ids.insert(sl->GetId());
                        std::vector<Layout::Page::Space::TextBlock::TextLine::LineElementPtr> lels(sl->GetLineElements());
                        for (const Layout::Page::Space::TextBlock::TextLine::LineElementPtr lel : lels)
                        {
                            const std::shared_ptr<const Layout::Page::Space::TextBlock::TextLine::Word> w(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock::TextLine::Word>(lel.lock()));
                            if (w)
                            {
                                if (w->GetId())
                                    ids.insert(w->GetId().Get());
                            } // word
                            else
                            {
                                const std::shared_ptr<const Layout::Page::Space::TextBlock::TextLine::WhiteSpace> s(std::dynamic_pointer_cast<Layout::Page::Space::TextBlock::TextLine::WhiteSpace>(lel.lock()));
                                if (s)
                                {
                                    if (s->GetId())
                                        ids.insert(s->GetId().Get());
                                } // white space
                            }
                        } // line elements
                    } // lines
                } // text block
            } // blocks
        } // spaces
    } // pages
}

Id Alto::CreateId()
{
    bool ok = false;
    Id id;
    while (!ok)
    {
        id = StringUTF8::CreateUniqueId();
        if (ids.find(id) == ids.end())
        {
            ids.insert(id);
            ok = true;
        }
    }
    return id;
}

bool Alto::CheckId(const Id &id) const
{
    return ids.find(id) == ids.end();
}

Id Alto::AddId(Element &el)
{
    try
    {
        el.GetAttribute<StringUTF8>("ID", false);
        throw crn::ExceptionInvalidArgument(_("The element already has an id."));
    }
    catch (crn::ExceptionNotFound&)
    { }
    Id id(CreateId());
    el.SetAttribute("ID", id);
    return id;
}

// Root

Alto::Root::Root(const Element &el):
    Element(el)
{
    if (!el)
        throw ExceptionInvalidArgument(_("Null node."));
    for (Element cel = BeginElement(); cel != EndElement(); ++cel)
    {
        StringUTF8 elname(cel.GetName());
        if (elname == "Description")
        {
            description.reset(new Description(cel));
        }
        else if (elname == "Styles")
        {
            styles.reset(new Styles(cel));
        }
        else if (elname == "Layout")
        {
            layout.reset(new Layout(cel));
        }
    }
    if (!layout) // mandatory element!
        throw crn::ExceptionNotFound(_("Cannot find layout."));
    init("file:///dev/null");
}

Alto::Root::Root(const Element &el, const Path &imagename, const StringUTF8 &ns):
    Element(el)
{
    if (ns.IsEmpty())
        throw crn::ExceptionInvalidArgument(_("Null namespace."));
    SetAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
    SetAttribute("xmlns", ns);
    StringUTF8 nsloc(ns);
    nsloc += " ";
    nsloc += "http://www.loc.gov/standards/alto/alto-v2.0.xsd";
    SetAttribute("xsi:schemaLocation", nsloc);
    SetAttribute("xmlns:xlink", "http://www.w3.org/TR/xlink");
    init(imagename);
}

void Alto::Root::init(const StringUTF8 &imgname)
{
    if (!description)
        description.reset(new Description(PushBackElement("Description"), imgname));
    if (!styles)
        styles.reset(new Styles(PushBackElement("Styles")));
    if (!layout)
        layout.reset(new Layout(PushBackElement("Layout")));
}