textdocumentscopes.h

Go to the documentation of this file.

// edbee - Copyright (c) 2012-2025 by Rick Blommers and contributors
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "edbee/exports.h"
 
#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 EDBEE_EXPORT 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 EDBEE_EXPORT TextScope {…};
 
//===========================================

class EDBEE_EXPORT TextScopeList : public QVector<TextScope*>
{
public:
    TextScopeList();
    TextScopeList( int initialSize );
    TextScopeList( QVector<ScopedTextRange*>& ranges );
 
    int atomCount() const;
 
    QString toString();
};
class EDBEE_EXPORT TextScopeList : public QVector<TextScope*> {…};
 
 
//===========================================

class EDBEE_EXPORT 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 EDBEE_EXPORT TextScopeSelector {…};
 
 
//===========================================

class EDBEE_EXPORT 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 EDBEE_EXPORT TextScopeManager {…};
 
 
//===========================================
 

class EDBEE_EXPORT 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 EDBEE_EXPORT ScopedTextRange : public TextRange {…};
 
 
//===========================================
 

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

    virtual MultiLineScopedTextRange* multiLineScopedTextRange();
 
private:
    MultiLineScopedTextRange* multiScopeRef_;       
};
class EDBEE_EXPORT MultiLineScopedTextRangeReference : public ScopedTextRange {…};
 
 
 
//===========================================

class EDBEE_EXPORT 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 EDBEE_EXPORT ScopedTextRangeList {…};
 
 
//===========================================
 

class EDBEE_EXPORT 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 EDBEE_EXPORT MultiLineScopedTextRange : public ScopedTextRange {…};
 
 
//===========================================
 

class EDBEE_EXPORT 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 EDBEE_EXPORT MultiLineScopedTextRangeSet : public TextRangeSetBase {…};
 
 
 
//===========================================
 

class EDBEE_EXPORT 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 , bool includeEnd=false );
    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_;            
 
};
class EDBEE_EXPORT TextDocumentScopes : public QObject {…};
 
 
} // edbee