실현 실행 취소

위임 메커니즘

메인 패키지

수입 (
    " 오류 " 
    " FMT " 
    " 일종의 " 
    " 문자열 "
)

삽입 형 구조체 {
    데이터 맵은 [ INT ] BOOL
    undo Undo
}

UndoableInSet 형 구조체 {
    삽입 된 페이지
    함수 [] FUNC ()
}

FUNC NewUndoableInSet () {UndoableInSet
    반환 UndoableInSet {NewInSet (), 전무}
}

FUNC ( 세트 * UndoableInSet) (X 삭제 INT ) {
     경우  설정 .Contains (X) {
        (삭제 세트 .DATA, x)를
         설정 .functions = APPEND ( 세트 .functions, FUNC를 () {
             설정 .Add (X)
        })
    }
}

FUNC ( 세트 * UndoableInSet ()가 추가 x INT ) {
     경우 ! 세트 .Contains (X) {
         집합 .DATA [X] = true로 
        설정 .functions = APPEND ( 세트 .functions, FUNC () {
             설정 .Delete (X)
        })
    }
}

FUNC ( 세트 * UndoableInSet) 실행 취소 () 오류 {
     경우 렌 ( 설정 .functions) == 0 {
         반환 (errors.New를 " 어떤 기능을 취소 없음 " )
    }
    인덱스 : = LEN ( 세트 .functions) - 1 
    의 경우 함수 = 세트 .functions [인덱스]; 기능! = 전무 {
        함수()
        세트 .functions [지수 = 전무
    }
    세트 .functions = 세트 .functions [: 인덱스]
     복귀 전무
}



FUNC NewInSet () {삽입
    창 삽입물 {데이터 : 화장 (맵 [ INT ] 불리언 )}
}

FUNC ( 세트 * 삽입 된) 추가 (X INT ) {
     경우  설정 .Contains (X) {
         집합 .DATA [X] = 참 
        세트 .undo.Add (FUNC () {
             설정 .Delete (X)
        })
    } 다른 {
         세트 .undo.Add (전무)
    }
}

FUNC ( 세트 * 인셋) (X 삭제 INT ) {
     경우  설정 .Contains (X) {
        삭제 ( 설정 .DATA x는)
         설정 .undo.Add (FUNC는 () {
             집합 ) .Add (X를
        })
    } 다른 {
         세트 .undo.Add (전무)
    }
}

FUNC ( 세트 * 삽입 된) (X 포함 INT ) BOOL {
     복귀  세트 .DATA [X]
}

FUNC ( 세트 * 삽입) 실행 취소 () 오류 {
     반환  세트 .undo.Undo ()
}

FUNC ( 세트 * 삽입) 문자열 () 문자열 {
     경우 렌 ( 설정 .DATA) == 0 {
         반환  " {} "
    }
    int 치의 : = 메이크업 ([] INT , 0 , 렌 ( 세트 .DATA))
     에 대한 전 : 범위 = 세트 {.DATA을
        의 int = APPEND (int 치의 난)
    }
    sort.Ints (INT)로
    : 부품 = 메이크업 ([] 문자열 , 0 , 렌 (INT)로)
     대 _ 난 = 범위의 int {
        부품 = APPEND (부품 fmt.Sprint (I))
    }
    창  " { " + strings.Join (부분 " , " ) + " } "
}

FUNC 주 () {
    개미 : = NewUndoableInSet ()
     대 _, I = 범위 [] INT { 1 , 2 , 3 , 4 } {
        ints.Add (I)
        fmt.Println (INT)로
    }
    fmt.Println ()
    대 {
         만약 ERR = ints.Undo (); ERR! = 전무 {
             휴식
        }
        fmt.Println (INT)로
    }
}

취소를 입력 [] FUNC ()

FUNC가 (취소 * 취소 () 함수를 FUNC ()) {추가
     * 취소 = APPEND (* 취소) 함수
}

FUNC (취소 * 실행 취소) 실행 취소 () 오류 {
    기능 : = * 실행 취소
     하는 경우 렌 (기능) == 0 {
         반환 errors.New ( " 취소 할 기능 " )
    }
    인덱스 : = LEN (함수) - 1 
    의 경우 함수 = 함수 [인덱스]; 기능! = 전무 {
        함수()
        함수 [인덱스] = 전무
    }
    * 취소 = 함수 [: 인덱스]
     복귀 전무
}

 

첸 하오 괴짜 시간에서 참조  https://time.geekbang.org/column/article/2748

종료