pathops coincident work

src/pathops/SkOpCoincidence.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpCoincidence_DEFINED
 #define SkOpCoincidence_DEFINED
 
 #include "SkTDArray.h"
@@ skipping 138 matching lines @@
     bool addMissing();
     bool addUncommon();
     bool apply();
     bool contains(const SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd,
                   const SkOpPtT* oppPtTStart, const SkOpPtT* oppPtTEnd) const;
     void correctEnds();
 
 #if DEBUG_COINCIDENCE_VERBOSE
     void debugAddExpanded(const char* id, SkPathOpsDebug::GlitchLog* ) const;
     void debugAddMissing(const char* id, SkPathOpsDebug::GlitchLog* ) const;
-    void debugAddOrOverlap(const SkOpSegment* coinSeg, const SkOpSegment* oppSeg,
-                           double coinTs, double coinTe, double oppTs, double oppTe,
-                           const char* id, SkPathOpsDebug::GlitchLog* log) const;
+    void debugAddOrOverlap(const char* id, SkPathOpsDebug::GlitchLog* log,
+                           const SkOpSegment* coinSeg, const SkOpSegment* oppSeg,
+                           double coinTs, double coinTe, double oppTs, double oppTe) const;
 #endif
 
     const SkOpAngle* debugAngle(int id) const {
         return SkDEBUGRELEASE(fGlobalState->debugAngle(id), nullptr);
     }
 
 #if DEBUG_COINCIDENCE_VERBOSE
     void debugCheckOverlap(const char* id, SkPathOpsDebug::GlitchLog* log) const;
     void debugCheckValid(const char* id, SkPathOpsDebug::GlitchLog* log) const;
 #endif
 
-    SkOpContour* debugContour(int id) {
+    SkOpContour* debugContour(int id) const {
         return SkDEBUGRELEASE(fGlobalState->debugContour(id), nullptr);
     }
 
 #if DEBUG_COINCIDENCE_VERBOSE
     bool debugExpand(const char* id, SkPathOpsDebug::GlitchLog* ) const;
     void debugMark(const char* id, SkPathOpsDebug::GlitchLog* ) const;
     void debugMarkCollapsed(const char* id, SkPathOpsDebug::GlitchLog* ,
                             const SkCoincidentSpans* coin, const SkOpPtT* test) const;
     void debugMarkCollapsed(const char* id, SkPathOpsDebug::GlitchLog* , const SkOpPtT* test) const;
 #endif
 
     const SkOpPtT* debugPtT(int id) const {
         return SkDEBUGRELEASE(fGlobalState->debugPtT(id), nullptr);
     }
 
     const SkOpSegment* debugSegment(int id) const {
         return SkDEBUGRELEASE(fGlobalState->debugSegment(id), nullptr);
     }
 
 #if DEBUG_COINCIDENCE_VERBOSE
     void debugRemoveCollapsed(const char* id, SkPathOpsDebug::GlitchLog* ) const;
     void debugReorder(const char* id, SkPathOpsDebug::GlitchLog* ) const;
+    void debugRelease(const char* id, SkPathOpsDebug::GlitchLog* , const SkCoincidentSpans* ,
+                      const SkCoincidentSpans* ) const;
     void debugRelease(const char* id, SkPathOpsDebug::GlitchLog* , const SkOpSegment* ) const;
 #endif
     void debugShowCoincidence() const;
 
     const SkOpSpanBase* debugSpan(int id) const {
         return SkDEBUGRELEASE(fGlobalState->debugSpan(id), nullptr);
     }
 
     void debugValidate() const;
     void dump() const;
@@ skipping 14 matching lines @@
 
     bool mark();
     void markCollapsed(SkOpPtT* );
 
     static bool Ordered(const SkOpPtT* coinPtTStart, const SkOpPtT* oppPtTStart) {
       return Ordered(coinPtTStart->segment(), oppPtTStart->segment());
     }
 
     static bool Ordered(const SkOpSegment* coin, const SkOpSegment* opp);
     void release(const SkOpSegment* );
+    void releaseDeleted();
     bool removeCollapsed();
     bool reorder();
 
 private:
     void add(const SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd, const SkOpPtT* oppPtTStart,
              const SkOpPtT* oppPtTEnd) {
         this->add(const_cast<SkOpPtT*>(coinPtTStart), const_cast<SkOpPtT*>(coinPtTEnd),
             const_cast<SkOpPtT*>(oppPtTStart), const_cast<SkOpPtT*>(oppPtTEnd));
     }
 
@@ skipping 47 matching lines @@
                            const SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd,
                            const SkOpPtT* oppPtTStart, const SkOpPtT* oppPtTEnd,
                            const char* id, SkPathOpsDebug::GlitchLog*) const;
 #endif
     void fixUp(SkCoincidentSpans* coin, SkOpPtT* deleted, const SkOpPtT* kept);
     void markCollapsed(SkCoincidentSpans* head, SkOpPtT* test);
     bool overlap(const SkOpPtT* coinStart1, const SkOpPtT* coinEnd1,
                  const SkOpPtT* coinStart2, const SkOpPtT* coinEnd2,
                  double* overS, double* overE) const;
     bool release(SkCoincidentSpans* coin, SkCoincidentSpans* );
+    void releaseDeleted(SkCoincidentSpans* );
     void restoreHead();
     bool testForCoincidence(const SkCoincidentSpans* outer, const SkOpPtT* testS,
                             const SkOpPtT* testE) const;
     static void TRange(const SkOpPtT* overS, const SkOpPtT* overE, double tStart,
                        double tEnd, const SkOpPtT* coinPtTStart, const SkOpPtT* coinPtTEnd,
                        double* coinTs, double* coinTe);
 
     SkCoincidentSpans* fHead;
     SkCoincidentSpans* fTop;
     SkOpGlobalState* fGlobalState;
     bool fContinue;
     bool fSpanDeleted;
     bool fPtAllocated;
     bool fCoinExtended;
     bool fSpanMerged;
 };
 
 #endif