textdocumentscopes.h

Go to the documentation of this file.

#pragma once

#include <QHash>
#include <QObject>
#include <QStringList>
#include <QVector>

#include "edbee/models/textrange.h"
#include "edbee/models/textlinedata.h"
#include "edbee/util/gapvector.h"

namespace edbee {

class MultiLineScopedTextRange;
class RegExp;
class ScopedTextRange;
class TextDocumentScopes;
class TextGrammarRule;
class TextScope;

typedef short TextScopeAtomId;

/*
    ScopeElement
    FullScope =   ScopeElement.ScopeElement.ScopeElement
*/

class TextScope
{
public:
    const QString name();
    int atomCount();
    TextScopeAtomId atomAt(int idx) const;

    bool startsWith( TextScope* scope );
    int rindexOf( TextScope* scope );

private:
    TextScope( const QString& fullScope );
    TextScope();
    ~TextScope();

    char scopeAtomCount_;                 
    TextScopeAtomId* scopeAtoms_;         

    friend class TextScopeManager;
};

//===========================================

class TextScopeList : public QVector<TextScope*>
{
public:
    TextScopeList();
    TextScopeList( int initialSize );
    TextScopeList( QVector<ScopedTextRange*>& ranges );

    int atomCount() const;

    QString toString();
};


//===========================================

class TextScopeSelector
{
public:
    TextScopeSelector( const QString& selector );
    virtual ~TextScopeSelector();

    double calculateMatchScore(const TextScopeList* scopeList );
    QString toString();

private:
    double calculateMatchScoreForSelector( TextScopeList* selector, const TextScopeList* scopeList );


private:
    QVector<TextScopeList*> selectorList_;
};


//===========================================

class TextScopeManager
{
public:
    TextScopeManager();
    virtual ~TextScopeManager();

public:

    void reset();

    TextScopeAtomId wildcardId();

    TextScopeAtomId findOrRegisterScopeAtom( const QString& atom );
    TextScope* refTextScope( const QString& scopeString );
    TextScope* refEmptyScope();

    TextScopeList* createTextScopeList(const QString &scopeListString );

    const QString& atomName( TextScopeAtomId id );

private:
    TextScopeAtomId wildCardId_;                            

    // scope atoms
    QList<QString> atomNameList_;                           
    QHash<QString,TextScopeAtomId> atomNameMap_;            

    // full scopes
    QList<TextScope*> textScopeList_;                       
    QHash<QString,TextScope*> textScopeRefMap_;             
};


//===========================================


class ScopedTextRange : public TextRange
{
public:
    ScopedTextRange( int anchor, int caret, TextScope* scope );
//    ScopedTextRange( const MultiLineScopedTextRange& range );
    virtual ~ScopedTextRange();

    void setScope( TextScope* scope );
    TextScope* scope() const;
    QString toString() const;

    virtual MultiLineScopedTextRange* multiLineScopedTextRange() { return 0; }


private:
    TextScope* scopeRef_;      

};


//===========================================


class MultiLineScopedTextRangeReference : public ScopedTextRange
{
public:
    MultiLineScopedTextRangeReference( MultiLineScopedTextRange& range );
    virtual ~MultiLineScopedTextRangeReference();

    virtual MultiLineScopedTextRange* multiLineScopedTextRange();

private:
    MultiLineScopedTextRange* multiScopeRef_;       
};



//===========================================

class ScopedTextRangeList
{
    Q_DISABLE_COPY(ScopedTextRangeList)
public:

    explicit ScopedTextRangeList();
    virtual ~ScopedTextRangeList();

    int size() const;
    ScopedTextRange* at( int idx );
    void giveRange( ScopedTextRange* at );
    void giveAndPrependRange(ScopedTextRange* range );

    void squeeze();
    void setIndependent(bool enable=true);
    bool isIndependent() const;

    QString toString();


private:

    QVector<ScopedTextRange*> ranges_;  
    bool independent_;                  

//    int size_;                      /// The number of ranges
//    ScopedTextRange* ranges_;       /// The list of ranges
};


//===========================================


class MultiLineScopedTextRange : public ScopedTextRange
{
public:
    MultiLineScopedTextRange(int anchor, int caret, TextScope* scope);
    virtual ~MultiLineScopedTextRange();

    void setGrammarRule( TextGrammarRule* rule );
    TextGrammarRule* grammarRule() const;

    void giveEndRegExp( RegExp* regExp );
    RegExp* endRegExp();

    static bool lessThan( MultiLineScopedTextRange* r1, MultiLineScopedTextRange* r2);

private:
    TextGrammarRule* ruleRef_;     
    RegExp* endRegExp_;        
};


//===========================================


class MultiLineScopedTextRangeSet : public TextRangeSetBase
{
public:
    MultiLineScopedTextRangeSet( TextDocument* textDocument, TextDocumentScopes* textDocumentScopes );
    virtual ~MultiLineScopedTextRangeSet();
    void reset();

  // text range functionality
    virtual int rangeCount() const;
    virtual TextRange& range(int idx);
    virtual const TextRange& constRange(int idx) const;
    virtual void addRange( int anchor, int caret );
    virtual void addRange(const TextRange& range);

    virtual void removeRange( int idx );
    virtual void clear();
    virtual void toSingleRange();
    virtual void sortRanges();
    virtual MultiLineScopedTextRange& scopedRange(int idx);
    virtual MultiLineScopedTextRange& addRange(int anchor, int caret, const QString& name , TextGrammarRule *rule);

    void removeAndInvalidateRangesAfterOffset( int offset );

  // adds a text scope
    void giveScopedTextRange( MultiLineScopedTextRange* textScope );
    void processChangesIfRequired( bool joinBorders );

    QString toString();

    TextDocumentScopes* textDocumentScopes();

private:

    TextDocumentScopes* textDocumentScopesRef_;     
    QList<MultiLineScopedTextRange*> scopedRangeList_;       
};



//===========================================


class TextDocumentScopes : public QObject
{
Q_OBJECT

public:
    TextDocumentScopes( TextDocument* textDocument);
    virtual ~TextDocumentScopes();

    int lastScopedOffset();
    void setLastScopedOffset( int offset );


  // scope management
    void setDefaultScope(const QString& name, TextGrammarRule *rule);

    void giveLineScopedRangeList( int line, ScopedTextRangeList* list);
    ScopedTextRangeList* scopedRangesAtLine( int line );
    int scopedLineCount();

    void giveMultiLineScopedTextRange( MultiLineScopedTextRange* range );
    void removeScopesAfterOffset( int offset );
    MultiLineScopedTextRange& defaultScopedRange();

    QVector<MultiLineScopedTextRange*> multiLineScopedRangesBetweenOffsets( int offsetBegin, int offsetEnd );
    TextScopeList scopesAtOffset( int offset );
    QVector<ScopedTextRange*> createScopedRangesAtOffsetList( int offset );

    QString toString();
    QStringList scopesAsStringList();

    void dumpScopedLineAddresses( const QString& text = QString() );

  // getters
    TextDocument* textDocument();

protected slots:

    void grammarChanged();

signals:
    void lastScopedOffsetChanged(int previousOffset, int lastScopedOffset );

private:

    TextDocument* textDocumentRef_;             

//    TextScope* defaultScope_;                   ///< The default scope
    MultiLineScopedTextRange defaultScopedRange_;          
//    QHash<QString,TextScope*> scopeMap_;                 ///< A list of all defined/used scopes (pointers to these scopes are smaller then full strings)
    MultiLineScopedTextRangeSet scopedRanges_;             
    GapVector<ScopedTextRangeList*>  lineRangeList_;       

    int lastScopedOffset_;            

};


} // edbee