CRNAltoWrapper.h

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

#ifndef CRNAltoWrapper_HEADER
#define CRNAltoWrapper_HEADER

#include <CRNXml/CRNAlto.h>
#include <CRNDocument.h>
#include <CRNUtils/CRNProgress.h>
#include <vector>
#include <utility>

namespace crn
{
    namespace xml
    {
        struct PagePath
        {
            PagePath() { }
            PagePath(const String &v, const Id &p):view_id(v),page_id(p) { }
            PagePath(const String &p);
            PagePath(const PagePath&) = default;
            PagePath(PagePath&&) = default;
            virtual ~PagePath() {}
            PagePath& operator=(const PagePath&) = default;
            PagePath& operator=(PagePath&&) = default;

            inline bool operator==(const PagePath &other) const { return (view_id == other.view_id) && (page_id == other.page_id); }
            inline bool operator!=(const PagePath &other) const { return !operator==(other); }
            inline bool operator<(const PagePath &other) const
            { if (view_id < other.view_id) return true;
                else if ((view_id == other.view_id) && (page_id < other.page_id)) return true;
                return false; }
            String view_id;
            Id page_id;
            virtual String ToString() const { return view_id + Separator() + page_id; }
            static const crn::String& Separator();
            static const PagePath& NullPath();
        };
        struct SpacePath: public PagePath
        {
            SpacePath() { }
            SpacePath(const PagePath &p, const Id &s):PagePath(p),space_id(s) { }
            SpacePath(const String &p);
            SpacePath(const SpacePath&) = default;
            SpacePath(SpacePath&&) = default;
            virtual ~SpacePath() override {}
            SpacePath& operator=(const SpacePath&) = default;
            SpacePath& operator=(SpacePath&&) = default;

            inline bool operator==(const SpacePath &other) const { return PagePath::operator==(other) && (space_id == other.space_id); }
            inline bool operator!=(const SpacePath &other) const { return !operator==(other); }
            inline bool operator<(const SpacePath &other) const
            { if (PagePath::operator<(other)) return true;
                else if ((page_id == other.page_id) && (space_id < other.space_id)) return true;
                return false; }
            Id space_id;
            virtual String ToString() const override { return PagePath::ToString() + Separator() + space_id; }
            static const SpacePath& NullPath();
        };
        struct BlockPath: public SpacePath
        {
            BlockPath() { }
            BlockPath(const SpacePath &s, const Id &b):SpacePath(s),block_id(b) { }
            BlockPath(const String &p);
            BlockPath(const BlockPath&) = default;
            BlockPath(BlockPath&&) = default;
            virtual ~BlockPath() override { }
            BlockPath& operator=(const BlockPath&) = default;
            BlockPath& operator=(BlockPath&&) = default;

            inline bool operator==(const BlockPath &other) const { return SpacePath::operator==(other) && (block_id == other.block_id); }
            inline bool operator!=(const BlockPath &other) const { return !operator==(other); }
            inline bool operator<(const BlockPath &other) const
            { if (SpacePath::operator<(other)) return true;
                else if ((space_id == other.space_id) && (block_id < other.block_id)) return true;
                return false; }
            Id block_id;
            virtual String ToString() const override { return SpacePath::ToString() + Separator() + block_id; }
            static const BlockPath& NullPath();
        };
        struct TextLinePath: public BlockPath
        {
            TextLinePath() { }
            TextLinePath(const BlockPath &b, const Id &l):BlockPath(b),textline_id(l) { }
            TextLinePath(const String &p);
            TextLinePath(const TextLinePath&) = default;
            TextLinePath(TextLinePath&&) = default;
            virtual ~TextLinePath() override { }
            TextLinePath& operator=(const TextLinePath&) = default;
            TextLinePath& operator=(TextLinePath&&) = default;

            inline bool operator==(const TextLinePath &other) const { return BlockPath::operator==(other) && (textline_id == other.textline_id); }
            inline bool operator!=(const TextLinePath &other) const { return !operator==(other); }
            inline bool operator<(const TextLinePath &other) const
            { if (BlockPath::operator<(other)) return true;
                else if ((block_id == other.block_id) && (textline_id < other.textline_id)) return true;
                return false; }
            Id textline_id;
            virtual String ToString() const override { return BlockPath::ToString() + Separator() + textline_id; }
            static const TextLinePath& NullPath();
        };
        struct WordPath: public TextLinePath
        {
            WordPath() { }
            WordPath(const TextLinePath &l, const Id &w):TextLinePath(l),word_id(w) { }
            WordPath(const String &p);
            WordPath(const WordPath&) = default;
            WordPath(WordPath&&) = default;
            virtual ~WordPath() override { }
            WordPath& operator=(const WordPath&) = default;
            WordPath& operator=(WordPath&&) = default;

            inline bool operator==(const WordPath &other) const { return TextLinePath::operator==(other) && (word_id == other.word_id); }
            inline bool operator!=(const WordPath &other) const { return !operator==(other); }
            inline bool operator<(const WordPath &other) const
            { if (TextLinePath::operator<(other)) return true;
                else if ((textline_id == other.textline_id) && (word_id < other.word_id)) return true;
                return false; }
            Id word_id;
            virtual String ToString() const override { return TextLinePath::ToString() + Separator() + word_id; }
            static const WordPath& NullPath();
        };
        class AltoWrapper
        {
            public:
                AltoWrapper(const AltoWrapper&) = delete;
                AltoWrapper(AltoWrapper&&) = default;
                ~AltoWrapper() {}
                AltoWrapper& operator=(const AltoWrapper&) = delete;
                AltoWrapper& operator=(AltoWrapper&&) = default;

                static std::unique_ptr<AltoWrapper> NewFromDir(const crn::Path &directory, const crn::Path &documentname, const crn::Path &imagedirectory = "", crn::Progress *prog = nullptr, bool throw_exceptions = true);
                static std::unique_ptr<AltoWrapper> NewFromDirs(const crn::Path &image_directory, const crn::Path &xml_directory, const crn::Path &documentname, crn::Progress *prog = nullptr, bool throw_exceptions = true);
                static std::unique_ptr<AltoWrapper> NewFromDocument(const crn::SDocument &document, bool create_altos = false, bool throw_exceptions = true);
                static std::unique_ptr<AltoWrapper> NewFromDocument(const crn::Path &documentname, bool create_altos = false, bool throw_exceptions = true);
                template<typename Iter> static std::unique_ptr<AltoWrapper> NewFromImages(Iter begin_, Iter end_, const crn::Path &documentname, bool throw_exceptions = true)
                {
                    auto doc = std::make_shared<crn::Document>();
                    for (Iter it = begin_; it != end_; ++it)
                        doc->AddView(*it);
                    doc->Save(documentname);
                    return NewFromDocument(doc, true, throw_exceptions);
                }
                template<typename Iter> static std::unique_ptr<AltoWrapper> NewFromList(Iter begin_, Iter end_, const crn::Path &documentname, crn::Progress *prog = nullptr, bool throw_exceptions = true)
                {
                    std::vector<std::pair<crn::Path, crn::Path>> imgxml;
                    for (Iter it = begin_; it != end_; ++it)
                        imgxml.push_back(std::make_pair(it->first, it->second));
                    return newFromList(imgxml, documentname, prog, throw_exceptions);
                }

                void Synchronize(bool reset = false);

                const String AddView(const Path &imagename, const Path &altoname = "");

                SDocument GetDocument() { return doc; }
                SCDocument GetDocument() const { return doc; }

                class ViewLock
                {
                    public:
                        ViewLock(const ViewLock&) = delete;
                        ViewLock(ViewLock &&v):block(std::move(v.block)),alto(std::move(v.alto)) {}
                        ~ViewLock() { if (block) block->Save(); if (alto) alto->Save(); }
                        ViewLock& operator=(const ViewLock&) = delete;
                        ViewLock& operator=(ViewLock &&v) { block = std::move(v.block); alto = std::move(v.alto); return *this; }

                        SBlock GetBlock() { return block; }
                        SCBlock GetBlock() const { return block; }
                        SAlto GetAlto() { return alto; }
                        SCAlto GetAlto() const { return alto; }

                    private:
                        ViewLock(const SBlock &b, const SAlto &a):block(b),alto(a) { }

                        SBlock block;
                        SAlto alto;

                        friend class AltoWrapper;
                };
                class Word
                {
                    public:
                        Word(const SBlock &b, Alto::Layout::Page::Space::TextBlock::TextLine::Word &w, const std::shared_ptr<ViewLock> &l, const TextLinePath &t):block(b),word(&w),lock(l),path(t, w.GetId().Get()) { }
                        Word(const Word&) = default;
                        Word(Word&&) = default;
                        ~Word() { }
                        Word& operator=(const Word&) = default;
                        Word& operator=(Word&&) = default;

                        SAlto GetAlto() { return lock->GetAlto(); }
                        SCAlto GetAlto() const { return lock->GetAlto(); }
                        Alto::Layout::Page::Space::TextBlock::TextLine::Word& GetElement() { return *word; }
                        const Alto::Layout::Page::Space::TextBlock::TextLine::Word& GetElement() const { return *word; }

                        const WordPath& GetPath() const { return path; }

                        const Id& GetId() const { return word->GetId().Get(); }
                        std::vector<Id> GetStyles() const { return word->GetStyles(); }
                        std::vector<Alto::Styles::Text> GetTextStyles();
                        std::vector<Alto::Styles::Paragraph> GetParagraphStyles();
                        void AddStyle(const Id &styleid) { word->AddStyle(styleid); }
                        void RemoveStyle(const Id &styleid) { word->RemoveStyle(styleid); }
                        const Rect& GetBBox() const { return block->GetAbsoluteBBox(); }
                        void SetBBox(const crn::Rect &r);
                        StringUTF8 GetContent() const { return word->GetContent(); }
                        void SetContent(const StringUTF8 &s) { word->SetContent(s); }
                        Option<Alto::Styles::Text::FontStyle> GetFontStyle() const { return word->GetFontStyle(); }
                        void SetFontStyle(Alto::Styles::Text::FontStyle fs) { word->SetFontStyle(fs); }
                        void UnsetFontStyle() { word->UnsetFontStyle(); }
                        Option<AltoWord::SubstitutionType> GetSubstitutionType() const { return word->GetSubstitutionType(); }
                        Option<StringUTF8> GetSubstitutionContent() { return word->GetSubstitutionContent(); }
                        void SetSubstitution(AltoWord::SubstitutionType stype, const StringUTF8 &scontent) { word->SetSubstitution(stype, scontent); }
                        SBlock GetBlock() { return block; }
                        SCBlock GetBlock() const { return block; }

                        Option<double> GetWC() const { return word->GetWC(); }
                        void SetWC(double conf) { word->SetWC(conf); }

                    private:
                        SBlock block;
                        Alto::Layout::Page::Space::TextBlock::TextLine::Word *word;
                        std::shared_ptr<ViewLock> lock;
                        WordPath path;
                };
                Word GetWord(const WordPath &p);

                class TextLine
                {
                    public:
                        TextLine(const SBlock &b, Alto::Layout::Page::Space::TextBlock::TextLine &t, const std::shared_ptr<ViewLock> &l, const BlockPath &bp):block(b),textline(&t),lock(l),path(bp, t.GetId()) { }
                        TextLine(const TextLine&) = default;
                        TextLine(TextLine&&) = default;
                        ~TextLine() { }
                        TextLine& operator=(const TextLine&) = default;
                        TextLine& operator=(TextLine&&) = default;

                        SAlto GetAlto() { return lock->GetAlto(); }
                        SCAlto GetAlto() const { return lock->GetAlto(); }
                        Alto::Layout::Page::Space::TextBlock::TextLine& GetElement() { return *textline; }
                        const Alto::Layout::Page::Space::TextBlock::TextLine& GetElement() const { return *textline; }

                        const TextLinePath& GetPath() const { return path; }

                        const Id& GetId() const { return textline->GetId(); }
                        std::vector<Id> GetStyles() const { return textline->GetStyles(); }
                        std::vector<Alto::Styles::Text> GetTextStyles();
                        std::vector<Alto::Styles::Paragraph> GetParagraphStyles();
                        void AddStyle(const Id &styleid) { textline->AddStyle(styleid); }
                        void RemoveStyle(const Id &styleid) { textline->RemoveStyle(styleid); }
                        const Rect& GetBBox() const { return block->GetAbsoluteBBox(); }
                        void SetBBox(const crn::Rect &r, bool erase_oob);
                        Option<double> GetBaseline() const { return textline->GetBaseline(); }
                        void SetBaseline(double d, bool check_bounds = true) { textline->SetBaseline(d, check_bounds); }
                        void UnsetBaseline() { textline->UnsetBaseline(); }
                        Option<bool> GetManuallyCorrected() { return textline->GetManuallyCorrected(); }// CS element

                        SBlock GetBlock() { return block; }
                        SCBlock GetBlock() const { return block; }

                        std::vector<Id> GetWords() const;
                        size_t GetNbWords() const { return textline->GetNbWords(); }
                        Word GetWord(const Id &id);
                        const Word GetWord(const Id &id) const;
                        Word AddWord(const StringUTF8 &text, const crn::Rect &bbox);
                        Word AddWordAfter(const Id &pred, const StringUTF8 &text, const crn::Rect &bbox);
                        Word AddWordBefore(const Id &next, const StringUTF8 &text, const crn::Rect &bbox);

                        void RemoveWord(const Id &wid);

                    private:
                        SBlock block;
                        Alto::Layout::Page::Space::TextBlock::TextLine *textline;
                        std::shared_ptr<ViewLock> lock;
                        TextLinePath path;
                };
                TextLine GetTextLine(const TextLinePath &p);

                class TextBlock
                {
                    public:
                        TextBlock(const SBlock &b, Alto::Layout::Page::Space::TextBlock &t, const std::shared_ptr<ViewLock> &l, const SpacePath &s):block(b),textblock(&t),lock(l),path(s, t.GetId()) { }
                        TextBlock(const TextBlock&) = default;
                        TextBlock(TextBlock&&) = default;
                        ~TextBlock() { }
                        TextBlock& operator=(const TextBlock&) = default;
                        TextBlock& operator=(TextBlock&&) = default;

                        SAlto GetAlto() { return lock->GetAlto(); }
                        SCAlto GetAlto() const { return lock->GetAlto(); }
                        Alto::Layout::Page::Space::TextBlock& GetElement() { return *textblock; }
                        const Alto::Layout::Page::Space::TextBlock& GetElement() const { return *textblock; }

                        const BlockPath& GetPath() const { return path; }

                        const Id& GetId() const { return textblock->GetId(); }
                        std::vector<Id> GetStyles() const { return textblock->GetStyles(); }
                        std::vector<Alto::Styles::Text> GetTextStyles();
                        std::vector<Alto::Styles::Paragraph> GetParagraphStyles();
                        void AddStyle(const Id &styleid) { textblock->AddStyle(styleid); }
                        void RemoveStyle(const Id &styleid) { textblock->RemoveStyle(styleid); }
                        const Rect& GetBBox() const { return block->GetAbsoluteBBox(); }
                        void SetBBox(const crn::Rect &r, bool erase_oob);
                        Option<StringUTF8> GetLanguage() const { return textblock->GetLanguage(); }

                        SBlock GetBlock() { return block; }
                        SCBlock GetBlock() const { return block; }

                        std::vector<Id> GetTextLines() const;
                        size_t GetNbTextLines() const { return textblock->GetNbTextLines(); }
                        TextLine GetTextLine(const Id &id);
                        TextLine AddTextLine(const crn::Rect &bbox);
                        TextLine AddTextLineAfter(const Id &pred, const crn::Rect &bbox);
                        TextLine AddTextLineBefore(const Id &next, const crn::Rect &bbox);

                        void RemoveTextLine(const Id &tid);

                    private:
                        SBlock block;
                        Alto::Layout::Page::Space::TextBlock *textblock;
                        std::shared_ptr<ViewLock> lock;
                        BlockPath path;
                };
                TextBlock GetTextBlock(const BlockPath &p);

                class Space
                {
                    public:
                        Space(const SBlock &b, Alto::Layout::Page::Space &s, const std::shared_ptr<ViewLock> &l, const PagePath &p):block(b),space(&s),lock(l),path(p, s.GetId().Get()) { }
                        Space(const Space&) = default;
                        Space(Space&&) = default;
                        ~Space() { }
                        Space& operator=(const Space&) = default;
                        Space& operator=(Space&&) = default;

                        SAlto GetAlto() { return lock->GetAlto(); }
                        SCAlto GetAlto() const { return lock->GetAlto(); }
                        Alto::Layout::Page::Space& GetElement() { return *space; }
                        const Alto::Layout::Page::Space& GetElement() const { return *space; }

                        const SpacePath& GetPath() const { return path; }

                        const Id& GetId() const { return space->GetId().Get(); }
                        std::vector<Id> GetStyles() const { return space->GetStyles(); }
                        std::vector<Alto::Styles::Text> GetTextStyles();
                        std::vector<Alto::Styles::Paragraph> GetParagraphStyles();
                        void AddStyle(const Id &styleid) { space->AddStyle(styleid); }
                        void RemoveStyle(const Id &styleid) { space->RemoveStyle(styleid); }
                        const Rect& GetBBox() const { return block->GetAbsoluteBBox(); }
                        void SetBBox(const crn::Rect &r, bool erase_oob);

                        SBlock GetBlock() { return block; }
                        SCBlock GetBlock() const { return block; }

                        std::vector<Id> GetTextBlocks() const;
                        TextBlock GetTextBlock(const Id &id);
                        TextBlock AddTextBlock(const crn::Rect &bbox);
                        TextBlock AddTextBlockAfter(const Id &pred, const crn::Rect &bbox);
                        TextBlock AddTextBlockBefore(const Id &next, const crn::Rect &bbox);

                        void RemoveBlock(const Id &bid);

                    private:
                        SBlock block;
                        Alto::Layout::Page::Space *space;
                        std::shared_ptr<ViewLock> lock;
                        SpacePath path;
                };
                Space GetSpace(const SpacePath &p);

                class Page
                {
                    public:
                        Page(const SBlock &b, Alto::Layout::Page &p, const std::shared_ptr<ViewLock> &l, const String &vid):block(b),page(&p),lock(l),path(vid, p.GetId()) { }
                        Page(const Page&) = default;
                        Page(Page&&) = default;
                        ~Page() {}
                        Page& operator=(const Page&) = default;
                        Page& operator=(Page&&) = default;

                        SAlto GetAlto() { return lock->GetAlto(); }
                        SCAlto GetAlto() const { return lock->GetAlto(); }
                        Alto::Layout::Page& GetElement() { return *page; }
                        const Alto::Layout::Page& GetElement() const { return *page; }

                        const PagePath& GetPath() const { return path; }

                        const Id& GetId() const { return page->GetId(); }
                        Option<StringUTF8> GetPageClass() const { return page->GetPageClass(); }
                        void SetPageClass(const StringUTF8 &s) { page->SetPageClass(s); }
                        std::vector<Id> GetStyles() const { return page->GetStyles(); }
                        std::vector<Alto::Styles::Text> GetTextStyles();
                        std::vector<Alto::Styles::Paragraph> GetParagraphStyles();
                        void AddStyle(const Id &styleid) { page->AddStyle(styleid); }
                        void RemoveStyle(const Id &styleid) { page->RemoveStyle(styleid); }
                        const Rect& GetBBox() const { return block->GetAbsoluteBBox(); }
                        void SetBBox(const crn::Rect &r, bool erase_oob);
                        int GetPhysicalImageNumber() const { return page->GetPhysicalImageNumber(); }
                        void SetPhysicalImageNumber(int pnum) { page->SetPhysicalImageNumber(pnum); }
                        Option<StringUTF8> GetPrintedImageNumber() const { return page->GetPrintedImageNumber(); }
                        void SetPrintedImageNumber(const StringUTF8 &s) { page->SetPrintedImageNumber(s); }
                        Option<AltoPage::Quality> GetQuality() const { return page->GetQuality(); }
                        void SetQuality(AltoPage::Quality q) { page->SetQuality(q); }
                        Option<StringUTF8> GetQualityDetail() const { return page->GetQualityDetail(); }
                        void SetQualityDetail(const StringUTF8 &s) { page->SetQualityDetail(s); }
                        Option<AltoPage::Position> GetPosition() const { return page->GetPosition(); }
                        Option<Id> GetProcessing() const { return page->GetProcessing(); }
                        Option<double> GetAccuracy() const { return page->GetAccuracy(); }
                        void SetAccuracy(double acc) { page->SetAccuracy(acc); }
                        Option<double> GetPageConfidence() const { return page->GetPageConfidence(); }
                        void SetPageConfidence(double c) { page->SetPageConfidence(c); }

                        SBlock GetBlock() { return block; }
                        SCBlock GetBlock() const { return block; }

                        std::vector<Id> GetSpaces() const;
                        Space GetSpace(const Id &spaceid);
                        Space GetTopMargin();
                        Space AddTopMargin(const crn::Rect &bbox);
                        Space GetLeftMargin();
                        Space AddLeftMargin(const crn::Rect &bbox);
                        Space GetBottomMargin();
                        Space AddBottomMargin(const crn::Rect &bbox);
                        Space GetRightMargin();
                        Space AddRightMargin(const crn::Rect &bbox);
                        Space GetPrintSpace();
                        Space AddPrintSpace(const crn::Rect &bbox);

                        void RemoveSpace(const Id &sid);

                        //void ImportContent(Page &other, const crn::Rect &crop = crn::Rect());

                    private:
                        SBlock block;
                        Alto::Layout::Page *page;
                        std::shared_ptr<ViewLock> lock;
                        PagePath path;
                };
                Page GetPage(const PagePath &p);

                class View
                {
                    public:
                        View(const std::shared_ptr<ViewLock> &l, const String &view_id):lock(l), id(view_id) { }
                        View(const View&) = default;
                        View(View&&) = default;
                        ~View() { }
                        View& operator=(const View&) = default;
                        View& operator=(View&&) = default;

                        const String& GetId() const { return id; }
                        SBlock GetBlock() { return lock->GetBlock(); }
                        SCBlock GetBlock() const { return lock->GetBlock(); }
                        SAlto GetAlto() { return lock->GetAlto(); }
                        SCAlto GetAlto() const { return lock->GetAlto(); }

                        Alto::Description& GetDescription() { return lock->GetAlto()->GetDescription(); }

                        Alto::Styles& GetStyles() { return lock->GetAlto()->GetStyles(); }

                        std::vector<Id> GetPages();
                        Page GetPage(const Id &pageId);
                        Page AddPage(int image_number, int w, int h, Option<AltoPage::Position> pos = Option<AltoPage::Position>());
                        Page AddPageAfter(const Id &pred, int image_number, int w, int h, Option<AltoPage::Position> pos = Option<AltoPage::Position>());
                        Page AddPageBefore(const Id &next, int image_number, int w, int h, Option<AltoPage::Position> pos = Option<AltoPage::Position>());
                        void RemovePage(const Id &pageId);

                        void ResizeWord(const WordPath &p, const crn::Rect &r);
                        void ResizeTextLine(const TextLinePath &p, const crn::Rect &r, bool erase_oob);
                        void ResizeTextBlock(const BlockPath &p, const crn::Rect &r, bool erase_oob);
                        void ResizeSpace(const SpacePath &p, const crn::Rect &r, bool erase_oob);
                    private:

                        std::shared_ptr<ViewLock> lock;
                        String id;
                };
                std::vector<String> GetViewIds() const { return doc->GetViewIds(); }
                View GetView(const String &view_id);
                size_t GetNbViews() const { return doc->GetNbViews(); }
                View GetView(size_t index);

                void ResizeWord(const WordPath &p, const crn::Rect &r);
                void ResizeTextLine(const TextLinePath &p, const crn::Rect &r, bool erase_oob);
                void ResizeTextBlock(const BlockPath &p, const crn::Rect &r, bool erase_oob);
                void ResizeSpace(const SpacePath &p, const crn::Rect &r, bool erase_oob);

                static const String& AltoPathKey(); 
                static const String& PageKey(); 
                static const String& SpaceKey(); 
                static const String& TextBlockKey(); 
                static const String& IllustrationKey(); 
                static const String& GraphicalElementKey(); 
                static const String& ComposedBlockKey(); 
                static const String& TextLineKey(); 
                static const String& WordKey(); 
            private:
                static std::unique_ptr<AltoWrapper> newFromList(const std::vector<std::pair<crn::Path, crn::Path> > &filelist, const crn::Path &documentname, crn::Progress *prog, bool throw_exceptions);
                AltoWrapper(bool throw_exceptions);
                void createAltos();

                std::shared_ptr<ViewLock> getLock(const String &view_id) const;

                SDocument doc;
                mutable std::map<String, std::weak_ptr<ViewLock> > viewLocks;
                bool throws;
        };
        CRN_ALIAS_SMART_PTR(AltoWrapper)
    }
}


#endif