[Design Patterns] 16. 메멘토와 비지터: 상태 보존과 연산 분리

1
2
3
4
5
6

import java.util.*;
import java.util.zip.*;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.time.*;
import java.time.format.DateTimeFormatter;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// Memento 패턴 없이 구현한다면?
class BadDocumentEditor {
    private String content;
    private int cursorPosition;
    private List<String> contentHistory = new ArrayList<>();
    private List<Integer> positionHistory = new ArrayList<>();
    
    public void saveState() {
        // 😱 내부 상태를 직접 노출
        contentHistory.add(content);
        positionHistory.add(cursorPosition);
    }
    
    public void undo() {
        if (!contentHistory.isEmpty()) {
            // 😱 캡슐화 깨짐, 상태 동기화 문제
            content = contentHistory.remove(contentHistory.size() - 1);
            cursorPosition = positionHistory.remove(positionHistory.size() - 1);
        }
    }
    
    // 😱 새로운 상태가 추가될 때마다 모든 히스토리 관련 코드 수정
    // 😱 외부에서 히스토리에 직접 접근 가능 (캡슐화 위반)
    // 😱 메모리 누수 위험 (히스토리 무제한 증가)
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321

// Memento 패턴의 우아함
// 1. Memento 인터페이스 (Marker Interface)
interface DocumentMemento {
    // 외부에서는 구체적인 내용을 알 수 없음
    LocalDateTime getTimestamp();
    String getDescription();
}

// 2. Originator - 상태를 가진 원본 객체
class DocumentEditor {
    private StringBuilder content;
    private int cursorPosition;
    private Map<String, Object> properties;
    private LocalDateTime lastModified;
    
    public DocumentEditor() {
        this.content = new StringBuilder();
        this.cursorPosition = 0;
        this.properties = new HashMap<>();
        this.lastModified = LocalDateTime.now();
    }
    
    // 문서 편집 메서드들
    public void insertText(String text) {
        content.insert(cursorPosition, text);
        cursorPosition += text.length();
        lastModified = LocalDateTime.now();
    }
    
    public void deleteText(int length) {
        if (length > 0 && cursorPosition >= length) {
            content.delete(cursorPosition - length, cursorPosition);
            cursorPosition -= length;
            lastModified = LocalDateTime.now();
        }
    }
    
    public void setCursorPosition(int position) {
        if (position >= 0 && position <= content.length()) {
            this.cursorPosition = position;
        }
    }
    
    public void setProperty(String key, Object value) {
        properties.put(key, value);
        lastModified = LocalDateTime.now();
    }
    
    // Memento 생성 - 현재 상태를 저장
    public DocumentMemento createMemento() {
        return new ConcreteDocumentMemento(
            content.toString(),
            cursorPosition,
            new HashMap<>(properties),
            lastModified
        );
    }
    
    // Memento로부터 상태 복원
    public void restoreFromMemento(DocumentMemento memento) {
        if (memento instanceof ConcreteDocumentMemento) {
            ConcreteDocumentMemento concreteMemento = (ConcreteDocumentMemento) memento;
            
            this.content = new StringBuilder(concreteMemento.content);
            this.cursorPosition = concreteMemento.cursorPosition;
            this.properties = new HashMap<>(concreteMemento.properties);
            this.lastModified = concreteMemento.lastModified;
            
            System.out.println("[OK] Document restored to state: " + memento.getDescription());
        }
    }
    
    // Nested Class로 Memento 구현 (캡슐화 보장)
    private static class ConcreteDocumentMemento implements DocumentMemento {
        private final String content;
        private final int cursorPosition;
        private final Map<String, Object> properties;
        private final LocalDateTime lastModified;
        private final LocalDateTime snapshotTime;
        
        private ConcreteDocumentMemento(String content, int cursorPosition,
                                      Map<String, Object> properties, LocalDateTime lastModified) {
            this.content = content;
            this.cursorPosition = cursorPosition;
            this.properties = properties;
            this.lastModified = lastModified;
            this.snapshotTime = LocalDateTime.now();
        }
        
        @Override
        public LocalDateTime getTimestamp() {
            return snapshotTime;
        }
        
        @Override
        public String getDescription() {
            return String.format("Content: %d chars, Cursor: %d, Modified: %s",
                               content.length(), cursorPosition, 
                               lastModified.format(DateTimeFormatter.ofPattern("HH:mm:ss")));
        }
    }
    
    // 현재 상태 출력
    public void printStatus() {
        System.out.printf("Content: '%s' | Cursor: %d | Length: %d\n",
                         content.toString(), cursorPosition, content.length());
    }
    
    public String getContent() {
        return content.toString();
    }
    
    public int getCursorPosition() {
        return cursorPosition;
    }
}

// 3. Caretaker - Memento 관리자
class DocumentHistory {
    private final Deque<DocumentMemento> undoStack;
    private final Deque<DocumentMemento> redoStack;
    private final int maxHistorySize;
    private final DocumentEditor editor;
    
    public DocumentHistory(DocumentEditor editor, int maxHistorySize) {
        this.editor = editor;
        this.maxHistorySize = maxHistorySize;
        this.undoStack = new ArrayDeque<>();
        this.redoStack = new ArrayDeque<>();
    }
    
    // 현재 상태를 히스토리에 저장
    public void saveState() {
        DocumentMemento memento = editor.createMemento();
        undoStack.addLast(memento);
        redoStack.clear(); // 새로운 상태 저장 시 redo 스택 클리어
        
        // 히스토리 크기 제한
        while (undoStack.size() > maxHistorySize) {
            undoStack.removeFirst();
        }
        
        System.out.println("💾 State saved: " + memento.getDescription());
    }
    
    // Undo 수행
    public boolean undo() {
        if (undoStack.isEmpty()) {
            System.out.println("[Info] No more states to undo");
            return false;
        }
        
        // 현재 상태를 redo 스택에 저장
        redoStack.addLast(editor.createMemento());
        
        // 이전 상태로 복원
        DocumentMemento previousState = undoStack.removeLast();
        editor.restoreFromMemento(previousState);
        
        System.out.println("↶ Undo performed");
        return true;
    }
    
    // Redo 수행
    public boolean redo() {
        if (redoStack.isEmpty()) {
            System.out.println("[Info] No more states to redo");
            return false;
        }
        
        // 현재 상태를 undo 스택에 저장
        undoStack.addLast(editor.createMemento());
        
        // redo 상태로 복원
        DocumentMemento redoState = redoStack.removeLast();
        editor.restoreFromMemento(redoState);
        
        System.out.println("↷ Redo performed");
        return true;
    }
    
    // 히스토리 정보
    public void printHistory() {
        System.out.println("=== Document History ===");
        System.out.println("Undo available: " + undoStack.size());
        System.out.println("Redo available: " + redoStack.size());
        
        if (!undoStack.isEmpty()) {
            System.out.println("Recent states:");
            int count = 0;
            for (DocumentMemento memento : undoStack) {
                if (count++ >= 3) break; // 최근 3개만 표시
                System.out.println("  " + memento.getDescription());
            }
        }
    }
    
    public boolean canUndo() {
        return !undoStack.isEmpty();
    }
    
    public boolean canRedo() {
        return !redoStack.isEmpty();
    }
    
    public void clearHistory() {
        undoStack.clear();
        redoStack.clear();
        System.out.println("🗑️ History cleared");
    }
}

// 4. 고급 Memento - 압축 및 최적화
class OptimizedDocumentMemento implements DocumentMemento {
    private final byte[] compressedContent;
    private final int cursorPosition;
    private final LocalDateTime timestamp;
    private final String description;
    
    public OptimizedDocumentMemento(String content, int cursorPosition) {
        this.compressedContent = compressString(content);
        this.cursorPosition = cursorPosition;
        this.timestamp = LocalDateTime.now();
        this.description = String.format("Compressed: %d bytes, Cursor: %d",
                                        compressedContent.length, cursorPosition);
    }
    
    public String getDecompressedContent() {
        return decompressString(compressedContent);
    }
    
    public int getCursorPosition() {
        return cursorPosition;
    }
    
    @Override
    public LocalDateTime getTimestamp() {
        return timestamp;
    }
    
    @Override
    public String getDescription() {
        return description;
    }
    
    // 간단한 압축 시뮬레이션
    private byte[] compressString(String content) {
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            GZIPOutputStream gzos = new GZIPOutputStream(baos);
            gzos.write(content.getBytes(StandardCharsets.UTF_8));
            gzos.close();
            return baos.toByteArray();
        } catch (Exception e) {
            return content.getBytes(StandardCharsets.UTF_8);
        }
    }
    
    private String decompressString(byte[] compressed) {
        try {
            ByteArrayInputStream bais = new ByteArrayInputStream(compressed);
            GZIPInputStream gzis = new GZIPInputStream(bais);
            return new String(gzis.readAllBytes(), StandardCharsets.UTF_8);
        } catch (Exception e) {
            return new String(compressed, StandardCharsets.UTF_8);
        }
    }
}

// 사용 예시
class MementoPatternDemo {
    public static void main(String[] args) {
        DocumentEditor editor = new DocumentEditor();
        DocumentHistory history = new DocumentHistory(editor, 10);
        
        System.out.println("=== Document Editor Demo ===\n");
        
        // 초기 상태 저장
        history.saveState();
        
        // 텍스트 편집
        editor.insertText("Hello");
        editor.printStatus();
        history.saveState();
        
        editor.insertText(" World");
        editor.printStatus();
        history.saveState();
        
        editor.setCursorPosition(5);
        editor.insertText(" Beautiful");
        editor.printStatus();
        history.saveState();
        
        // 히스토리 출력
        System.out.println();
        history.printHistory();
        
        // Undo 테스트
        System.out.println("\n=== Undo/Redo Test ===");
        
        history.undo();
        editor.printStatus();
        
        history.undo();
        editor.printStatus();
        
        history.redo();
        editor.printStatus();
        
        // 새로운 편집 (redo 스택 클리어 테스트)
        editor.insertText("!");
        editor.printStatus();
        
        System.out.println("\nTrying to redo after new edit:");
        history.redo(); // 실패해야 함
        
        System.out.println();
        history.printHistory();
    }
}

1

import java.util.*;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Visitor 패턴 없이 구현한다면?
abstract class BadShape {
    // 😱 새로운 연산을 추가할 때마다 모든 Shape 클래스 수정
    public abstract double calculateArea();
    public abstract void draw();
    public abstract String exportToSVG();
    public abstract void applyTexture();
    // 😱 계속 메서드가 추가됨... 개방-폐쇄 원칙 위배
}

class BadCircle extends BadShape {
    // 😱 모든 연산이 Circle 클래스 안에 존재
    @Override
    public double calculateArea() { /* calculateArea 구현 */ }
    
    @Override
    public void draw() { /* draw 구현 */ }
    
    @Override
    public String exportToSVG() { /* exportToSVG 구현 */ }
    
    @Override
    public void applyTexture() { /* applyTexture 구현 */ }
    
    // 😱 새로운 연산 추가 시 모든 Shape 클래스 수정 필요
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

// Visitor 패턴의 우아함
// 1. Visitor 인터페이스
interface ShapeVisitor {
    void visit(Circle circle);
    void visit(Rectangle rectangle);
    void visit(Triangle triangle);
    void visit(CompoundShape compoundShape);
}

// 2. Element 인터페이스
interface Shape {
    void accept(ShapeVisitor visitor);
    String getName();
}

// 3. Concrete Elements
class Circle implements Shape {
    private final double radius;
    private final Point center;
    
    public Circle(double radius, Point center) {
        this.radius = radius;
        this.center = center;
    }
    
    @Override
    public void accept(ShapeVisitor visitor) {
        visitor.visit(this); // Double Dispatch
    }
    
    @Override
    public String getName() {
        return "Circle";
    }
    
    public double getRadius() { return radius; }
    public Point getCenter() { return center; }
}

class Rectangle implements Shape {
    private final double width;
    private final double height;
    private final Point topLeft;
    
    public Rectangle(double width, double height, Point topLeft) {
        this.width = width;
        this.height = height;
        this.topLeft = topLeft;
    }
    
    @Override
    public void accept(ShapeVisitor visitor) {
        visitor.visit(this);
    }
    
    @Override
    public String getName() {
        return "Rectangle";
    }
    
    public double getWidth() { return width; }
    public double getHeight() { return height; }
    public Point getTopLeft() { return topLeft; }
}

class Triangle implements Shape {
    private final Point[] vertices;
    
    public Triangle(Point p1, Point p2, Point p3) {
        this.vertices = new Point[]{p1, p2, p3};
    }
    
    @Override
    public void accept(ShapeVisitor visitor) {
        visitor.visit(this);
    }
    
    @Override
    public String getName() {
        return "Triangle";
    }
    
    public Point[] getVertices() { return vertices.clone(); }
}

// Composite 패턴과 결합
class CompoundShape implements Shape {
    private final List<Shape> children;
    private final String name;
    
    public CompoundShape(String name) {
        this.name = name;
        this.children = new ArrayList<>();
    }
    
    public void addShape(Shape shape) {
        children.add(shape);
    }
    
    @Override
    public void accept(ShapeVisitor visitor) {
        visitor.visit(this);
        // 자식 Shape들도 방문
        for (Shape child : children) {
            child.accept(visitor);
        }
    }
    
    @Override
    public String getName() {
        return name;
    }
    
    public List<Shape> getChildren() {
        return new ArrayList<>(children);
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302

// 4. Concrete Visitors - 다양한 연산 구현
class AreaCalculatorVisitor implements ShapeVisitor {
    private double totalArea = 0;
    private final Map<String, Double> areaByShape = new HashMap<>();
    
    @Override
    public void visit(Circle circle) {
        double area = Math.PI * circle.getRadius() * circle.getRadius();
        totalArea += area;
        areaByShape.put("Circle_" + System.identityHashCode(circle), area);
        
        System.out.printf("📐 Circle area: %.2f (radius: %.2f)\n", area, circle.getRadius());
    }
    
    @Override
    public void visit(Rectangle rectangle) {
        double area = rectangle.getWidth() * rectangle.getHeight();
        totalArea += area;
        areaByShape.put("Rectangle_" + System.identityHashCode(rectangle), area);
        
        System.out.printf("📐 Rectangle area: %.2f (%.2f x %.2f)\n", 
                         area, rectangle.getWidth(), rectangle.getHeight());
    }
    
    @Override
    public void visit(Triangle triangle) {
        // 신발끈 공식 (Shoelace formula) 사용
        Point[] vertices = triangle.getVertices();
        double area = Math.abs(
            (vertices[0].x * (vertices[1].y - vertices[2].y) +
             vertices[1].x * (vertices[2].y - vertices[0].y) +
             vertices[2].x * (vertices[0].y - vertices[1].y)) / 2.0
        );
        
        totalArea += area;
        areaByShape.put("Triangle_" + System.identityHashCode(triangle), area);
        
        System.out.printf("📐 Triangle area: %.2f\n", area);
    }
    
    @Override
    public void visit(CompoundShape compoundShape) {
        System.out.printf("📐 Compound shape '%s' contains %d children\n",
                         compoundShape.getName(), compoundShape.getChildren().size());
    }
    
    public double getTotalArea() {
        return totalArea;
    }
    
    public Map<String, Double> getAreaByShape() {
        return new HashMap<>(areaByShape);
    }
    
    public void reset() {
        totalArea = 0;
        areaByShape.clear();
    }
}

class DrawingVisitor implements ShapeVisitor {
    private final StringBuilder canvas = new StringBuilder();
    private int indentLevel = 0;
    
    @Override
    public void visit(Circle circle) {
        addIndent();
        canvas.append(String.format("🔵 Drawing Circle: center(%.1f, %.1f), radius=%.1f\n",
                                   circle.getCenter().x, circle.getCenter().y, circle.getRadius()));
    }
    
    @Override
    public void visit(Rectangle rectangle) {
        addIndent();
        canvas.append(String.format("⬜ Drawing Rectangle: top-left(%.1f, %.1f), size=%.1fx%.1f\n",
                                   rectangle.getTopLeft().x, rectangle.getTopLeft().y,
                                   rectangle.getWidth(), rectangle.getHeight()));
    }
    
    @Override
    public void visit(Triangle triangle) {
        addIndent();
        Point[] vertices = triangle.getVertices();
        canvas.append(String.format("🔺 Drawing Triangle: vertices[(%.1f,%.1f), (%.1f,%.1f), (%.1f,%.1f)]\n",
                                   vertices[0].x, vertices[0].y,
                                   vertices[1].x, vertices[1].y,
                                   vertices[2].x, vertices[2].y));
    }
    
    @Override
    public void visit(CompoundShape compoundShape) {
        addIndent();
        canvas.append(String.format("📦 Drawing Compound Shape: '%s'\n", compoundShape.getName()));
        indentLevel++;
    }
    
    private void addIndent() {
        for (int i = 0; i < indentLevel; i++) {
            canvas.append("  ");
        }
    }
    
    public String getCanvas() {
        return canvas.toString();
    }
    
    public void reset() {
        canvas.setLength(0);
        indentLevel = 0;
    }
}

class SVGExportVisitor implements ShapeVisitor {
    private final StringBuilder svg = new StringBuilder();
    private boolean headerAdded = false;
    
    public SVGExportVisitor() {
        addSVGHeader();
    }
    
    @Override
    public void visit(Circle circle) {
        if (!headerAdded) addSVGHeader();
        
        svg.append(String.format(
            "  <circle cx=\"%.1f\" cy=\"%.1f\" r=\"%.1f\" fill=\"blue\" stroke=\"black\" stroke-width=\"1\"/>\n",
            circle.getCenter().x, circle.getCenter().y, circle.getRadius()
        ));
    }
    
    @Override
    public void visit(Rectangle rectangle) {
        if (!headerAdded) addSVGHeader();
        
        svg.append(String.format(
            "  <rect x=\"%.1f\" y=\"%.1f\" width=\"%.1f\" height=\"%.1f\" fill=\"red\" stroke=\"black\" stroke-width=\"1\"/>\n",
            rectangle.getTopLeft().x, rectangle.getTopLeft().y,
            rectangle.getWidth(), rectangle.getHeight()
        ));
    }
    
    @Override
    public void visit(Triangle triangle) {
        if (!headerAdded) addSVGHeader();
        
        Point[] vertices = triangle.getVertices();
        String points = String.format("%.1f,%.1f %.1f,%.1f %.1f,%.1f",
                                     vertices[0].x, vertices[0].y,
                                     vertices[1].x, vertices[1].y,
                                     vertices[2].x, vertices[2].y);
        
        svg.append(String.format(
            "  <polygon points=\"%s\" fill=\"green\" stroke=\"black\" stroke-width=\"1\"/>\n",
            points
        ));
    }
    
    @Override
    public void visit(CompoundShape compoundShape) {
        svg.append(String.format("  <!-- Compound Shape: %s -->\n", compoundShape.getName()));
    }
    
    private void addSVGHeader() {
        svg.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
        svg.append("<svg width=\"800\" height=\"600\" xmlns=\"http://www.w3.org/2000/svg\">\n");
        headerAdded = true;
    }
    
    public String getSVG() {
        return svg.toString() + "</svg>\n";
    }
}

class ValidationVisitor implements ShapeVisitor {
    private final List<String> errors = new ArrayList<>();
    private final List<String> warnings = new ArrayList<>();
    
    @Override
    public void visit(Circle circle) {
        if (circle.getRadius() <= 0) {
            errors.add("Circle has invalid radius: " + circle.getRadius());
        }
        if (circle.getRadius() > 1000) {
            warnings.add("Circle has very large radius: " + circle.getRadius());
        }
    }
    
    @Override
    public void visit(Rectangle rectangle) {
        if (rectangle.getWidth() <= 0 || rectangle.getHeight() <= 0) {
            errors.add("Rectangle has invalid dimensions: " + 
                      rectangle.getWidth() + "x" + rectangle.getHeight());
        }
        if (rectangle.getWidth() * rectangle.getHeight() > 1000000) {
            warnings.add("Rectangle has very large area");
        }
    }
    
    @Override
    public void visit(Triangle triangle) {
        Point[] vertices = triangle.getVertices();
        // 삼각형의 세 점이 일직선상에 있는지 확인
        double area = Math.abs(
            (vertices[0].x * (vertices[1].y - vertices[2].y) +
             vertices[1].x * (vertices[2].y - vertices[0].y) +
             vertices[2].x * (vertices[0].y - vertices[1].y)) / 2.0
        );
        
        if (area < 0.001) {
            errors.add("Triangle vertices are collinear");
        }
    }
    
    @Override
    public void visit(CompoundShape compoundShape) {
        if (compoundShape.getChildren().isEmpty()) {
            warnings.add("Compound shape '" + compoundShape.getName() + "' is empty");
        }
    }
    
    public List<String> getErrors() {
        return new ArrayList<>(errors);
    }
    
    public List<String> getWarnings() {
        return new ArrayList<>(warnings);
    }
    
    public boolean isValid() {
        return errors.isEmpty();
    }
    
    public void reset() {
        errors.clear();
        warnings.clear();
    }
}

// Point 클래스
class Point {
    final double x, y;
    
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

// 사용 예시
class VisitorPatternDemo {
    public static void main(String[] args) {
        // 도형 생성
        Circle circle = new Circle(5.0, new Point(10, 10));
        Rectangle rectangle = new Rectangle(8.0, 6.0, new Point(0, 0));
        Triangle triangle = new Triangle(
            new Point(0, 0), new Point(4, 0), new Point(2, 3)
        );
        
        // 복합 도형 생성
        CompoundShape group = new CompoundShape("Main Group");
        group.addShape(circle);
        group.addShape(rectangle);
        group.addShape(triangle);
        
        System.out.println("=== Visitor Pattern Demo ===\n");
        
        // 1. 넓이 계산
        System.out.println("1. Area Calculation:");
        AreaCalculatorVisitor areaCalculator = new AreaCalculatorVisitor();
        group.accept(areaCalculator);
        System.out.printf("Total area: %.2f\n\n", areaCalculator.getTotalArea());
        
        // 2. 그리기
        System.out.println("2. Drawing:");
        DrawingVisitor drawer = new DrawingVisitor();
        group.accept(drawer);
        System.out.println(drawer.getCanvas());
        
        // 3. SVG 내보내기
        System.out.println("3. SVG Export:");
        SVGExportVisitor svgExporter = new SVGExportVisitor();
        group.accept(svgExporter);
        System.out.println(svgExporter.getSVG());
        
        // 4. 유효성 검증
        System.out.println("4. Validation:");
        ValidationVisitor validator = new ValidationVisitor();
        group.accept(validator);
        
        if (validator.isValid()) {
            System.out.println("[OK] All shapes are valid");
        } else {
            System.out.println("[Error] Validation errors found:");
            validator.getErrors().forEach(error -> System.out.println("  - " + error));
        }
        
        if (!validator.getWarnings().isEmpty()) {
            System.out.println("[Warning] Warnings:");
            validator.getWarnings().forEach(warning -> System.out.println("  - " + warning));
        }
    }
}