Flyweight Pattern: Efficient Object Sharing

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

/**
 * Handling edge cases in state classification.
 */
public class StateClassificationEdgeCases {
    
    // EDGE CASE 1: Derived state - don't store, compute
    public class CharacterMetrics {
        // Intrinsic
        private final String fontFamily;
        private final int fontSize;
        
        // DON'T store derived state:
        // private final int lineHeight;  // Can compute from fontSize
        // private final int averageWidth; // Can compute from font
        
        // Instead, compute on demand:
        public int getLineHeight() {
            return (int)(fontSize * 1.2); // Computed, not stored
        }
        
        public int getAverageCharWidth() {
            return FontMetrics.forFont(fontFamily, fontSize).getAverageWidth();
        }
    }
    
    // EDGE CASE 2: Rarely varying state - default with override
    public class CellStyle {
        // Intrinsic: the style definition
        private final NumberFormat format;
        private final Font font;
        private final Color backgroundColor;
        
        // Most cells use default validation (none)
        // But some have custom validation
        // Solution: Validation is extrinsic, stored only when non-default
    }
    
    // Client stores sparse map for overrides:
    public class SpreadsheetClient {
        private final Map<CellAddress, ValidationRule> customValidations;
        private final Map<CellAddress, CellStyle> cellStyles;
        
        public ValidationRule getValidation(CellAddress cell) {
            return customValidations.getOrDefault(cell, ValidationRule.NONE);
        }
    }
    
    // EDGE CASE 3: State that must change -> create new flyweight
    public class DocumentEditor {
        private final StyleFactory factory;
        private final Map<TextRange, CharacterStyle> rangeStyles;
        
        public void changeFontSize(TextRange range, int newSize) {
            CharacterStyle oldStyle = rangeStyles.get(range);
            
            // DON'T mutate oldStyle - other ranges share it!
            // DO get/create a new flyweight with desired state:
            CharacterStyle newStyle = factory.getStyle(
                oldStyle.getFontFamily(),
                newSize,  // Changed value
                oldStyle.getColor(),
                oldStyle.isBold(),
                oldStyle.isItalic(),
                oldStyle.isUnderline()
            );
            
            rangeStyles.put(range, newStyle);
            // Old flyweight remains valid for other users
        }
    }
    
    // EDGE CASE 4: Lazy-loaded intrinsic state
    public class TextureReference {
        // Intrinsic: the identity of the texture
        private final String texturePath;
        
        // Loaded lazily, but conceptually part of intrinsic state
        private volatile Image loadedTexture;
        
        public Image getTexture() {
            if (loadedTexture == null) {
                synchronized (this) {
                    if (loadedTexture == null) {
                        loadedTexture = ImageLoader.load(texturePath);
                    }
                }
            }
            return loadedTexture;
        }
    }
}

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

/**
 * Examples of common Flyweight mistakes and their corrections.
 */
public class FlyweightMistakes {
    
    // MISTAKE 1: Storing extrinsic state in flyweight
    public class BrokenCharacterStyle {
        // Intrinsic - correct
        private final String fontFamily;
        private final int fontSize;
        
        // BUG! This is extrinsic - should not be here!
        private int x, y;  // Position belongs to client!
        
        public void setPosition(int x, int y) {
            this.x = x;  // Corrupts for all sharing clients!
            this.y = y;
        }
    }
    
    // CORRECTION: Position is extrinsic, passed to operations
    public class CorrectCharacterStyle {
        private final String fontFamily;
        private final int fontSize;
        
        // No position stored here!
        
        public void render(Canvas c, char ch, int x, int y) {
            // Position passed as argument - extrinsic
            c.drawChar(ch, x, y, fontFamily, fontSize);
        }
    }
    
    // MISTAKE 2: Mutating flyweight state  
    public class BrokenMutableFlyweight {
        private String fontFamily;
        private int fontSize;
        
        public void setFontSize(int size) {
            this.fontSize = size;  // All users see this change!
        }
    }
    
    // CORRECTION: Create new flyweight for new state
    public class ImmutableFlyweight {
        private final String fontFamily;
        private final int fontSize;
        
        // No setters! To change, get new flyweight from factory:
        // newStyle = factory.getStyle(oldStyle.fontFamily, newSize);
    }
    
    // MISTAKE 3: Incomplete cache key
    public class BrokenFactory {
        private Map<String, Style> cache;
        
        public Style getStyle(String font, int size, Color color) {
            // BUG! Key ignores color - different colors get same flyweight!
            String key = font + "_" + size;  // Missing color!
            // ...
        }
    }
    
    // CORRECTION: Key includes all intrinsic state
    public class CorrectFactory {
        public Style getStyle(String font, int size, Color color) {
            String key = font + "_" + size + "_" + color.getRGB();
            // All intrinsic state in key
        }
    }
}