File indexing completed on 2024-04-28 17:01:39

 /*
 SPDX-FileCopyrightText: 2001-2004,2009 Otto Bruggeman <bruggie@gmail.com>
 SPDX-FileCopyrightText: 2001-2003 John Firebaugh <jfirebaugh@kde.org>
 
 SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #ifndef KOMPAREDIFF2_DIFFERENCE_H
 #define KOMPAREDIFF2_DIFFERENCE_H
 
 #include <QVector>
 #include <QObject>
 
 #include "komparediff2_export.h"
 #include "marker.h"
 
 // #include <komparediffdebug.h>
 
 class QString;
 
 namespace Diff2
 {
 
 /**
  * @class DifferenceString difference.h <KompareDiff2/Difference>
  *
  * A difference string.
  */
 class KOMPAREDIFF2_EXPORT DifferenceString
 {
 public:
     DifferenceString()
     {
 //         qCDebug(LIBKOMPAREDIFF2) << "DifferenceString::DifferenceString()";
     }
     explicit DifferenceString(const QString& string, const MarkerList& markerList = MarkerList()) :
         m_string(string),
         m_markerList(markerList)
     {
 //         qCDebug(LIBKOMPAREDIFF2) << "DifferenceString::DifferenceString( " << string << ", " << markerList << " )";
         calculateHash();
     }
     DifferenceString(const DifferenceString& ds) :
         m_string(ds.m_string),
         m_conflict(ds.m_conflict),
         m_hash(ds.m_hash),
         m_markerList(ds.m_markerList)
     {
 //         qCDebug(LIBKOMPAREDIFF2) << "DifferenceString::DifferenceString( const DifferenceString& " << ds << " )";
     }
     ~DifferenceString()
     {
         qDeleteAll(m_markerList);
     }
 
 public:
     const QString& string() const
     {
         return m_string;
     }
     const QString& conflictString() const
     {
         return m_conflict;
     }
     const MarkerList& markerList()
     {
         return m_markerList;
     }
     void setString(const QString& string)
     {
         m_string = string;
         calculateHash();
     }
     void setConflictString(const QString& conflict)
     {
         m_conflict = conflict;
     }
     void setMarkerList(const MarkerList& markerList)
     {
         m_markerList = markerList;
     }
     void prepend(Marker* marker)
     {
         m_markerList.prepend(marker);
     }
     bool operator==(const DifferenceString& ks)
     {
         if (m_hash != ks.m_hash)
             return false;
         return m_string == ks.m_string;
     }
 
 protected:
     void calculateHash()
     {
         unsigned short const* str = reinterpret_cast<unsigned short const*>(m_string.unicode());
         const unsigned int len = m_string.length();
 
         m_hash = 1315423911;
 
         for (unsigned int i = 0; i < len; ++i)
         {
             m_hash ^= (m_hash << 5) + str[i] + (m_hash >> 2);
         }
     }
 
 private:
     QString      m_string;
     QString      m_conflict;
     unsigned int m_hash;
     MarkerList   m_markerList;
 };
 
 using DifferenceStringList =              QVector<DifferenceString*>;
 using DifferenceStringListIterator =      QVector<DifferenceString*>::iterator;
 using DifferenceStringListConstIterator = QVector<DifferenceString*>::const_iterator;
 
 /**
  * @class Difference difference.h <KompareDiff2/Difference>
  *
  * A difference.
  */
 class KOMPAREDIFF2_EXPORT Difference : public QObject
 {
     Q_OBJECT
 public:
     enum Type { Change, Insert, Delete, Unchanged };
 
 public:
     Difference(int sourceLineNo, int destinationLineNo, int type = Difference::Unchanged);
     ~Difference() override;
 
 public:
     int type() const { return m_type; };
 
     int sourceLineNumber() const { return m_sourceLineNo; }
     int destinationLineNumber() const { return m_destinationLineNo; }
 
     int sourceLineCount() const;
     int destinationLineCount() const;
 
     int sourceLineEnd() const;
     int destinationLineEnd() const;
 
     /// Destination line number that tracks applying/unapplying of other differences
     /// Essentially a line number in a patch consisting of applied diffs only
     int trackingDestinationLineNumber() const { return m_trackingDestinationLineNo; }
     int trackingDestinationLineEnd() const;
     void setTrackingDestinationLineNumber(int i) { m_trackingDestinationLineNo = i; }
 
     DifferenceString* sourceLineAt(int i) const { return m_sourceLines[i]; }
     DifferenceString* destinationLineAt(int i) const { return m_destinationLines[i]; }
 
     const DifferenceStringList sourceLines() const { return m_sourceLines; }
     const DifferenceStringList destinationLines() const { return m_destinationLines; }
 
     bool hasConflict() const
     {
         return m_conflicts;
     }
     void setConflict(bool conflicts)
     {
         m_conflicts = conflicts;
     }
 
     bool isUnsaved() const
     {
         return m_unsaved;
     }
     void setUnsaved(bool unsaved)
     {
         m_unsaved = unsaved;
     }
 
     void apply(bool apply);
     /// Apply without emitting any signals
     void applyQuietly(bool apply);
     bool applied() const { return m_applied; }
 
     void setType(int type) { m_type = type; }
 
     void addSourceLine(QString line);
     void addDestinationLine(QString line);
 
     /** This method will calculate the differences between the individual strings and store them as Markers */
     void determineInlineDifferences();
 
     QString recreateDifference() const;
 
 Q_SIGNALS:
     void differenceApplied(Difference*);
 
 private:
     int                   m_type;
 
     int                   m_sourceLineNo;
     int                   m_destinationLineNo;
     int                   m_trackingDestinationLineNo;
 
     DifferenceStringList  m_sourceLines;
     DifferenceStringList  m_destinationLines;
 
     bool                  m_applied;
     bool                  m_conflicts;
     bool                  m_unsaved;
 };
 
 using DifferenceList =              QList<Difference*>;
 using DifferenceListIterator =      QList<Difference*>::iterator;
 using DifferenceListConstIterator = QList<Difference*>::const_iterator;
 
 } // End of namespace Diff2
 
 #endif