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
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

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * Complete Text Rendering Flyweight Implementation
 * 
 * Demonstrates sharing character styles across thousands of characters
 * in a document rendering system.
 */
 
// =============================================
// FLYWEIGHT INTERFACE
// =============================================
public interface CharacterGlyph {
    /**
     * Render a character at the given position.
     * Position is extrinsic state—passed in, not stored.
     */
    void render(Canvas canvas, char character, int x, int y);
    
    /**
     * Get the advance width for a character (how far to move cursor after).
     */
    int getAdvanceWidth(char character);
    
    /**
     * Get the line height for this style.
     */
    int getLineHeight();
}
 
// =============================================
// CONCRETE FLYWEIGHT
// =============================================
public final class TextStyle implements CharacterGlyph {
    // All intrinsic state — immutable after construction
    private final String fontFamily;
    private final int fontSize;
    private final int fontWeight;        // 400 = normal, 700 = bold
    private final boolean italic;
    private final int textColor;         // ARGB packed
    private final int backgroundColor;   // ARGB packed, 0 = transparent
    private final boolean underline;
    private final boolean strikethrough;
    
    // Cached derived data (computed once from intrinsic state)
    private final FontMetrics metrics;
    private final int lineHeight;
    
    TextStyle(String fontFamily, int fontSize, int fontWeight,
              boolean italic, int textColor, int backgroundColor,
              boolean underline, boolean strikethrough) {
        this.fontFamily = fontFamily;
        this.fontSize = fontSize;
        this.fontWeight = fontWeight;
        this.italic = italic;
        this.textColor = textColor;
        this.backgroundColor = backgroundColor;
        this.underline = underline;
        this.strikethrough = strikethrough;
        
        // Pre-compute metrics for this style
        this.metrics = FontMetrics.create(fontFamily, fontSize, fontWeight, italic);
        this.lineHeight = (int)(fontSize * 1.2);
    }
    
    @Override
    public void render(Canvas canvas, char character, int x, int y) {
        // Apply styling
        if (backgroundColor != 0) {
            int charWidth = getAdvanceWidth(character);
            canvas.fillRect(x, y - fontSize, charWidth, lineHeight, backgroundColor);
        }
        
        // Draw character
        canvas.setFont(fontFamily, fontSize, fontWeight, italic);
        canvas.setColor(textColor);
        canvas.drawChar(character, x, y);
        
        // Apply decorations
        if (underline) {
            int width = getAdvanceWidth(character);
            canvas.drawLine(x, y + 2, x + width, y + 2, textColor);
        }
        if (strikethrough) {
            int width = getAdvanceWidth(character);
            canvas.drawLine(x, y - fontSize/3, x + width, y - fontSize/3, textColor);
        }
    }
    
    @Override
    public int getAdvanceWidth(char character) {
        return metrics.getCharWidth(character);
    }
    
    @Override
    public int getLineHeight() {
        return lineHeight;
    }
    
    // Getters for intrinsic state (needed for factory key generation)
    String getFontFamily() { return fontFamily; }
    int getFontSize() { return fontSize; }
    int getFontWeight() { return fontWeight; }
    boolean isItalic() { return italic; }
    int getTextColor() { return textColor; }
    int getBackgroundColor() { return backgroundColor; }
    boolean isUnderline() { return underline; }
    boolean isStrikethrough() { return strikethrough; }
}
 
// =============================================
// FLYWEIGHT FACTORY
// =============================================
public final class TextStyleFactory {
    
    private static final TextStyleFactory INSTANCE = new TextStyleFactory();
    private final Map<String, TextStyle> styleCache = new ConcurrentHashMap<>();
    
    // Common style constants
    public static final int COLOR_BLACK = 0xFF000000;
    public static final int COLOR_WHITE = 0xFFFFFFFF;
    public static final int COLOR_TRANSPARENT = 0x00000000;
    public static final int WEIGHT_NORMAL = 400;
    public static final int WEIGHT_BOLD = 700;
    
    private TextStyleFactory() {}
    
    public static TextStyleFactory getInstance() {
        return INSTANCE;
    }
    
    /**
     * Get or create a TextStyle flyweight.
     */
    public TextStyle getStyle(String fontFamily, int fontSize, int fontWeight,
                              boolean italic, int textColor, int backgroundColor,
                              boolean underline, boolean strikethrough) {
        String key = generateKey(fontFamily, fontSize, fontWeight, italic,
                                  textColor, backgroundColor, underline, strikethrough);
        
        return styleCache.computeIfAbsent(key, k -> 
            new TextStyle(fontFamily, fontSize, fontWeight, italic,
                          textColor, backgroundColor, underline, strikethrough)
        );
    }
    
    // Convenience methods for common styles
    public TextStyle getDefaultStyle() {
        return getStyle("Arial", 12, WEIGHT_NORMAL, false,
                        COLOR_BLACK, COLOR_TRANSPARENT, false, false);
    }
    
    public TextStyle getBoldStyle(String fontFamily, int fontSize) {
        return getStyle(fontFamily, fontSize, WEIGHT_BOLD, false,
                        COLOR_BLACK, COLOR_TRANSPARENT, false, false);
    }
    
    public TextStyle getLinkStyle(String fontFamily, int fontSize) {
        return getStyle(fontFamily, fontSize, WEIGHT_NORMAL, false,
                        0xFF0066CC, COLOR_TRANSPARENT, true, false);
    }
    
    public TextStyle getCodeStyle() {
        return getStyle("Consolas", 11, WEIGHT_NORMAL, false,
                        0xFF333333, 0xFFF5F5F5, false, false);
    }
    
    private String generateKey(String fontFamily, int fontSize, int fontWeight,
                               boolean italic, int textColor, int backgroundColor,
                               boolean underline, boolean strikethrough) {
        return String.format("%s|%d|%d|%b|%08X|%08X|%b|%b",
            fontFamily, fontSize, fontWeight, italic,
            textColor, backgroundColor, underline, strikethrough);
    }
    
    // Statistics for debugging/monitoring
    public int getCachedStyleCount() {
        return styleCache.size();
    }
    
    public void clearCache() {
        styleCache.clear();
    }
}

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

// =============================================
// CLIENT CODE — Document Renderer
// =============================================
public class DocumentRenderer {
    
    /**
     * Lightweight container for extrinsic state.
     * This is what we store per character instead of full objects.
     */
    record GlyphPosition(char character, int x, int y, TextStyle style) {
        // ~16-20 bytes vs ~150+ bytes for full character object
    }
    
    private final TextStyleFactory styleFactory;
    private final List<GlyphPosition> glyphs;
    private final int pageWidth;
    private final int pageHeight;
    
    public DocumentRenderer(int pageWidth, int pageHeight) {
        this.styleFactory = TextStyleFactory.getInstance();
        this.glyphs = new ArrayList<>();
        this.pageWidth = pageWidth;
        this.pageHeight = pageHeight;
    }
    
    /**
     * Load rich text content and prepare for rendering.
     */
    public void loadContent(List<RichTextRun> runs) {
        glyphs.clear();
        int x = 0;
        int y = 20;  // Start with top margin
        int lineHeight = 0;
        
        for (RichTextRun run : runs) {
            // Get the appropriate flyweight for this run's styling
            TextStyle style = styleFactory.getStyle(
                run.getFontFamily(),
                run.getFontSize(),
                run.isBold() ? TextStyleFactory.WEIGHT_BOLD : TextStyleFactory.WEIGHT_NORMAL,
                run.isItalic(),
                run.getTextColor(),
                run.getBackgroundColor(),
                run.isUnderlined(),
                run.isStrikethrough()
            );
            
            lineHeight = Math.max(lineHeight, style.getLineHeight());
            
            // Process each character in the run
            for (char c : run.getText().toCharArray()) {
                if (c == '\n') {
                    // Line break
                    x = 0;
                    y += lineHeight;
                    lineHeight = style.getLineHeight();
                    continue;
                }
                
                int charWidth = style.getAdvanceWidth(c);
                
                // Word wrap check
                if (x + charWidth > pageWidth) {
                    x = 0;
                    y += lineHeight;
                    lineHeight = style.getLineHeight();
                }
                
                // Store glyph position with reference to shared style
                glyphs.add(new GlyphPosition(c, x, y, style));
                
                x += charWidth;
            }
        }
        
        System.out.printf("Loaded %,d glyphs using %d unique styles%n",
            glyphs.size(), styleFactory.getCachedStyleCount());
    }
    
    /**
     * Render all glyphs to canvas.
     */
    public void render(Canvas canvas) {
        for (GlyphPosition glyph : glyphs) {
            // Client provides extrinsic state (char, position)
            // Flyweight uses its intrinsic state (styling) to render
            glyph.style().render(canvas, glyph.character(), glyph.x(), glyph.y());
        }
    }
    
    /**
     * Memory usage comparison.
     */
    public void printMemoryAnalysis() {
        int glyphCount = glyphs.size();
        int styleCount = styleFactory.getCachedStyleCount();
        
        // Naive approach: full object per character
        long naiveBytes = glyphCount * 150L;  // Estimated 150 bytes/char object
        
        // Flyweight approach: position record + shared styles
        long flyweightBytes = (glyphCount * 20L) + (styleCount * 200L);
        
        System.out.println("\n=== Memory Analysis ===");
        System.out.printf("Glyphs: %,d%n", glyphCount);
        System.out.printf("Unique styles: %d%n", styleCount);
        System.out.printf("Naive approach: %,.1f KB%n", naiveBytes / 1024.0);
        System.out.printf("Flyweight approach: %,.1f KB%n", flyweightBytes / 1024.0);
        System.out.printf("Memory saved: %.1f%%%n", 
            (1.0 - (double)flyweightBytes / naiveBytes) * 100);
    }
}
 
// =============================================
// USAGE EXAMPLE
// =============================================
public class TextRenderingDemo {
    public static void main(String[] args) {
        DocumentRenderer renderer = new DocumentRenderer(800, 1200);
        
        // Simulate loading a document with various formatting
        List<RichTextRun> document = List.of(
            new RichTextRun("Chapter 1: Introduction\n\n", "Times New Roman", 24, true, false),
            new RichTextRun("This is the opening paragraph with ", "Arial", 12, false, false),
            new RichTextRun("bold text", "Arial", 12, true, false),
            new RichTextRun(" and ", "Arial", 12, false, false),
            new RichTextRun("italic text", "Arial", 12, false, true),
            new RichTextRun(".\n\n", "Arial", 12, false, false),
            // ... thousands more runs in a real document
        );
        
        renderer.loadContent(document);
        renderer.printMemoryAnalysis();
        
        // Output:
        // Loaded 87,432 glyphs using 7 unique styles
        // 
        // === Memory Analysis ===
        // Glyphs: 87,432
        // Unique styles: 7
        // Naive approach: 12,812.7 KB
        // Flyweight approach: 1,709.4 KB
        // Memory saved: 86.7%
    }
}

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

/**
 * Particle System Flyweight Implementation
 * 
 * Demonstrates efficient handling of thousands of particles
 * in a game effect system.
 */
 
// =============================================
// FLYWEIGHT INTERFACE
// =============================================
public interface ParticleType {
    /**
     * Render a particle at the given position with extrinsic state.
     */
    void render(SpriteBatch batch, float x, float y, float scale, 
                float alpha, float rotation);
    
    /**
     * Apply physics update using type-specific gravity.
     */
    Vector2 applyGravity(Vector2 velocity, float deltaTime);
    
    /**
     * Get the base color for this particle type.
     */
    int getBaseColor();
}
 
// =============================================
// CONCRETE FLYWEIGHT
// =============================================
public final class ParticleTemplate implements ParticleType {
    // All intrinsic state — shared across all particles of this type
    private final Texture texture;
    private final BlendMode blendMode;
    private final Vector2 gravity;
    private final int baseColor;
    private final float baseSize;
    private final float lifetimeMin;
    private final float lifetimeMax;
    private final boolean looping;
    
    // Cached texture region for efficient rendering
    private final TextureRegion textureRegion;
    
    ParticleTemplate(Texture texture, BlendMode blendMode, Vector2 gravity,
                     int baseColor, float baseSize, 
                     float lifetimeMin, float lifetimeMax, boolean looping) {
        this.texture = texture;
        this.blendMode = blendMode;
        this.gravity = gravity;
        this.baseColor = baseColor;
        this.baseSize = baseSize;
        this.lifetimeMin = lifetimeMin;
        this.lifetimeMax = lifetimeMax;
        this.looping = looping;
        
        this.textureRegion = new TextureRegion(texture);
    }
    
    @Override
    public void render(SpriteBatch batch, float x, float y, 
                       float scale, float alpha, float rotation) {
        batch.setBlendFunction(blendMode);
        
        // Compute final color with alpha from extrinsic state
        int color = ColorUtils.withAlpha(baseColor, alpha);
        batch.setColor(color);
        
        // Compute size from base (intrinsic) and scale (extrinsic)
        float size = baseSize * scale;
        
        // Draw at position (extrinsic) with rotation (extrinsic)
        batch.draw(textureRegion, 
                   x - size/2, y - size/2,  // Center origin
                   size/2, size/2,          // Origin for rotation
                   size, size,              // Size
                   1f, 1f,                  // No additional scale
                   rotation);               // Rotation in degrees
    }
    
    @Override
    public Vector2 applyGravity(Vector2 velocity, float deltaTime) {
        return new Vector2(
            velocity.x + gravity.x * deltaTime,
            velocity.y + gravity.y * deltaTime
        );
    }
    
    @Override
    public int getBaseColor() {
        return baseColor;
    }
    
    public float randomLifetime() {
        return lifetimeMin + (float)Math.random() * (lifetimeMax - lifetimeMin);
    }
    
    public boolean isLooping() {
        return looping;
    }
}
 
// =============================================
// FLYWEIGHT FACTORY
// =============================================
public final class ParticleTypeFactory {
    
    private static final ParticleTypeFactory INSTANCE = new ParticleTypeFactory();
    private final Map<String, ParticleTemplate> typeCache = new HashMap<>();
    private final TextureManager textures;
    
    private ParticleTypeFactory() {
        this.textures = TextureManager.getInstance();
        initializeBuiltInTypes();
    }
    
    public static ParticleTypeFactory getInstance() {
        return INSTANCE;
    }
    
    private void initializeBuiltInTypes() {
        // Pre-register common particle types
        register("fire", new ParticleTemplate(
            textures.get("particles/flame.png"),
            BlendMode.ADDITIVE,
            new Vector2(0, 50),     // Upward drift
            0xFFFF6600,             // Orange
            32f, 0.5f, 1.5f, false
        ));
        
        register("smoke", new ParticleTemplate(
            textures.get("particles/smoke.png"),
            BlendMode.ALPHA,
            new Vector2(0, 30),
            0x80888888,             // Gray, semi-transparent
            24f, 1.0f, 3.0f, false
        ));
        
        register("spark", new ParticleTemplate(
            textures.get("particles/spark.png"),
            BlendMode.ADDITIVE,
            new Vector2(0, -200),   // Falls down
            0xFFFFFF00,             // Yellow
            8f, 0.2f, 0.8f, false
        ));
        
        register("rain", new ParticleTemplate(
            textures.get("particles/raindrop.png"),
            BlendMode.ALPHA,
            new Vector2(20, -500),  // Falls fast, slight wind
            0xBB6699FF,
            4f, 0.5f, 2.0f, true
        ));
    }
    
    public void register(String name, ParticleTemplate template) {
        typeCache.put(name, template);
    }
    
    public ParticleTemplate get(String typeName) {
        ParticleTemplate template = typeCache.get(typeName);
        if (template == null) {
            throw new IllegalArgumentException("Unknown particle type: " + typeName);
        }
        return template;
    }
    
    public int getTypeCount() {
        return typeCache.size();
    }
}

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

// =============================================
// EXTRINSIC STATE — Particle Instance Data
// =============================================
 
/**
 * Compact representation of per-particle extrinsic state.
 * Uses parallel arrays (Struct-of-Arrays) for cache efficiency.
 */
public class ParticlePool {
    // Maximum particles this pool can handle
    private final int capacity;
    
    // Extrinsic state arrays — one value per particle
    private final float[] x, y;           // Position
    private final float[] vx, vy;         // Velocity
    private final float[] scale;          // Size multiplier
    private final float[] alpha;          // Transparency
    private final float[] rotation;       // Rotation in degrees
    private final float[] rotationSpeed;  // Rotation velocity
    private final float[] age;            // Current age in seconds
    private final float[] lifetime;       // Max lifetime
    private final boolean[] alive;        // Is this slot active?
    
    // Shared reference to the flyweight
    private final ParticleTemplate type;
    
    // Pool bookkeeping
    private int aliveCount = 0;
    private int nextSlot = 0;
    
    public ParticlePool(ParticleTemplate type, int capacity) {
        this.type = type;
        this.capacity = capacity;
        
        this.x = new float[capacity];
        this.y = new float[capacity];
        this.vx = new float[capacity];
        this.vy = new float[capacity];
        this.scale = new float[capacity];
        this.alpha = new float[capacity];
        this.rotation = new float[capacity];
        this.rotationSpeed = new float[capacity];
        this.age = new float[capacity];
        this.lifetime = new float[capacity];
        this.alive = new boolean[capacity];
    }
    
    /**
     * Spawn a new particle with given initial state.
     */
    public void spawn(float px, float py, float pvx, float pvy, 
                      float pscale, float protSpeed) {
        if (aliveCount >= capacity) {
            // Pool full — could expand or skip
            return;
        }
        
        // Find a free slot
        while (alive[nextSlot]) {
            nextSlot = (nextSlot + 1) % capacity;
        }
        
        int i = nextSlot;
        x[i] = px;
        y[i] = py;
        vx[i] = pvx;
        vy[i] = pvy;
        scale[i] = pscale;
        alpha[i] = 1.0f;
        rotation[i] = (float)(Math.random() * 360);
        rotationSpeed[i] = protSpeed;
        age[i] = 0;
        lifetime[i] = type.randomLifetime();
        alive[i] = true;
        
        aliveCount++;
        nextSlot = (nextSlot + 1) % capacity;
    }
    
    /**
     * Update all particles.
     */
    public void update(float deltaTime) {
        for (int i = 0; i < capacity; i++) {
            if (!alive[i]) continue;
            
            // Age particle
            age[i] += deltaTime;
            
            if (age[i] >= lifetime[i]) {
                // Particle died
                alive[i] = false;
                aliveCount--;
                continue;
            }
            
            // Calculate life progress (0 to 1)
            float progress = age[i] / lifetime[i];
            
            // Apply alpha fade (fade out in last 30% of life)
            if (progress > 0.7f) {
                alpha[i] = 1.0f - (progress - 0.7f) / 0.3f;
            }
            
            // Apply gravity from flyweight
            Vector2 gravity = type.applyGravity(new Vector2(vx[i], vy[i]), deltaTime);
            vx[i] = gravity.x;
            vy[i] = gravity.y;
            
            // Update position
            x[i] += vx[i] * deltaTime;
            y[i] += vy[i] * deltaTime;
            
            // Update rotation
            rotation[i] += rotationSpeed[i] * deltaTime;
        }
    }
    
    /**
     * Render all particles using the shared flyweight.
     */
    public void render(SpriteBatch batch) {
        for (int i = 0; i < capacity; i++) {
            if (!alive[i]) continue;
            
            // Flyweight (type) provides rendering with intrinsic state
            // We pass extrinsic state from our arrays
            type.render(batch, x[i], y[i], scale[i], alpha[i], rotation[i]);
        }
    }
    
    public int getAliveCount() { return aliveCount; }
    public int getCapacity() { return capacity; }
}
 
// =============================================
// CLIENT CODE — Particle Emitter
// =============================================
public class ParticleEmitter {
    private final ParticlePool pool;
    private final float emitX, emitY;
    private final float emitRate;  // Particles per second
    private float accumulator = 0;
    
    public ParticleEmitter(String particleType, int maxParticles,
                           float x, float y, float particlesPerSecond) {
        ParticleTemplate type = ParticleTypeFactory.getInstance().get(particleType);
        this.pool = new ParticlePool(type, maxParticles);
        this.emitX = x;
        this.emitY = y;
        this.emitRate = particlesPerSecond;
    }
    
    public void update(float deltaTime) {
        // Emit new particles
        accumulator += deltaTime * emitRate;
        while (accumulator >= 1.0f) {
            float vx = (float)(Math.random() - 0.5) * 100;
            float vy = (float)(Math.random()) * 50;
            float scale = 0.5f + (float)Math.random() * 0.5f;
            float rotSpeed = (float)(Math.random() - 0.5) * 180;
            
            pool.spawn(emitX, emitY, vx, vy, scale, rotSpeed);
            accumulator -= 1.0f;
        }
        
        // Update existing particles
        pool.update(deltaTime);
    }
    
    public void render(SpriteBatch batch) {
        pool.render(batch);
    }
    
    public void printStats() {
        System.out.printf("Emitter: %d/%d particles, using 1 flyweight%n",
            pool.getAliveCount(), pool.getCapacity());
    }
}

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

/**
 * Icon Library Flyweight Implementation
 * 
 * Demonstrates sharing icon definitions across multiple UI usages.
 */
 
// =============================================
// FLYWEIGHT INTERFACE
// =============================================
interface Icon {
  /** Render the icon at given position with size and color (extrinsic) */
  render(context: CanvasRenderingContext2D, 
         x: number, y: number, size: number, color: string): void;
  
  /** Get SVG path data for the icon */
  getPathData(): string;
  
  /** Get semantic name for accessibility */
  getName(): string;
}
 
// =============================================
// CONCRETE FLYWEIGHT
// =============================================
class SVGIcon implements Icon {
  // Intrinsic state: the icon's definition
  private readonly name: string;
  private readonly pathData: string;
  private readonly viewBox: { width: number; height: number };
  
  // Cached path for efficient repeated rendering
  private readonly path2D: Path2D;
  
  constructor(name: string, pathData: string, 
              viewBoxWidth: number = 24, viewBoxHeight: number = 24) {
    this.name = name;
    this.pathData = pathData;
    this.viewBox = { width: viewBoxWidth, height: viewBoxHeight };
    
    // Pre-parse the path for efficient rendering
    this.path2D = new Path2D(pathData);
  }
  
  render(context: CanvasRenderingContext2D,
         x: number, y: number, size: number, color: string): void {
    context.save();
    
    // Move to position and scale
    context.translate(x, y);
    const scale = size / this.viewBox.width;
    context.scale(scale, scale);
    
    // Set color and render
    context.fillStyle = color;
    context.fill(this.path2D);
    
    context.restore();
  }
  
  getPathData(): string {
    return this.pathData;
  }
  
  getName(): string {
    return this.name;
  }
}
 
// =============================================
// FLYWEIGHT FACTORY
// =============================================
class IconLibrary {
  private static instance: IconLibrary;
  private readonly icons: Map<string, SVGIcon> = new Map();
  
  private constructor() {
    this.registerBuiltInIcons();
  }
  
  static getInstance(): IconLibrary {
    if (!this.instance) {
      this.instance = new IconLibrary();
    }
    return this.instance;
  }
  
  private registerBuiltInIcons(): void {
    // Register common icons with their SVG path data
    this.register(new SVGIcon("folder",
      "M10 4H4c-1.1 0-2 .9-2 2v12c0 1.1.9 2 2 2h16c1.1 0 2-.9 " +
      "2-2V8c0-1.1-.9-2-2-2h-8l-2-2z"
    ));
    
    this.register(new SVGIcon("file",
      "M14 2H6c-1.1 0-2 .9-2 2v16c0 1.1.9 2 2 2h12c1.1 0 " +
      "2-.9 2-2V8l-6-6zm4 18H6V4h7v5h5v11z"
    ));
    
    this.register(new SVGIcon("search",
      "M15.5 14h-.79l-.28-.27A6.471 6.471 0 0016 9.5 6.5 6.5 0 109.5 16c1.61 " +
      "0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 " +
      "5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"
    ));
    
    this.register(new SVGIcon("delete",
      "M6 19c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 " +
      "1H5v2h14V4z"
    ));
    
    // Many more icons...
  }
  
  register(icon: SVGIcon): void {
    this.icons.set(icon.getName(), icon);
  }
  
  get(name: string): SVGIcon {
    const icon = this.icons.get(name);
    if (!icon) {
      throw new Error(`Unknown icon: ${name}`);
    }
    return icon;
  }
  
  getIconCount(): number {
    return this.icons.size;
  }
}
 
// =============================================
// CLIENT CODE — File Browser
// =============================================
interface FileEntry {
  name: string;
  type: "file" | "folder";
  x: number;
  y: number;
}
 
class FileBrowser {
  private readonly iconLibrary: IconLibrary;
  private readonly entries: FileEntry[] = [];
  private readonly iconSize = 24;
  private readonly itemHeight = 32;
  
  constructor() {
    this.iconLibrary = IconLibrary.getInstance();
  }
  
  addEntry(name: string, type: "file" | "folder"): void {
    const y = this.entries.length * this.itemHeight;
    this.entries.push({ name, type, x: 8, y });
  }
  
  render(context: CanvasRenderingContext2D): void {
    // Get flyweights once
    const folderIcon = this.iconLibrary.get("folder");
    const fileIcon = this.iconLibrary.get("file");
    
    for (const entry of this.entries) {
      // Select icon flyweight based on type
      const icon = entry.type === "folder" ? folderIcon : fileIcon;
      const color = entry.type === "folder" ? "#FFC107" : "#757575";
      
      // Render using flyweight with extrinsic state (position, color)
      icon.render(context, entry.x, entry.y, this.iconSize, color);
      
      // Render filename
      context.fillStyle = "#212121";
      context.fillText(entry.name, entry.x + this.iconSize + 8, entry.y + 16);
    }
  }
  
  printStats(): void {
    console.log(`Showing ${this.entries.length} items using ` +
                `${this.iconLibrary.getIconCount()} flyweight icons`);
  }
}
 
// =============================================
// USAGE
// =============================================
const browser = new FileBrowser();
 
// Simulate loading 1,000 files
for (let i = 0; i < 1000; i++) {
  if (i % 10 === 0) {
    browser.addEntry(`Folder ${i}`, "folder");
  } else {
    browser.addEntry(`Document ${i}.pdf`, "file");
  }
}
 
browser.printStats();
// Output: Showing 1000 items using 2 flyweight icons
 
// Memory impact:
// Without Flyweight: 1000 × ~2KB (path data + parsed path) = ~2 MB
// With Flyweight: 2 × ~2KB = ~4 KB (plus small entry objects)

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

/**
 * Composite Flyweight: flyweights that reference other flyweights.
 */
public class CompositeTextStyle implements CharacterGlyph {
    // Reference to another flyweight (font definition)
    private final FontFlyweight font;  // Shared among styles using same font
    
    // This style's specific intrinsic state
    private final int textColor;
    private final boolean underline;
    
    CompositeTextStyle(FontFlyweight font, int textColor, boolean underline) {
        this.font = font;           // Reuse shared font flyweight
        this.textColor = textColor;
        this.underline = underline;
    }
    
    @Override
    public void render(Canvas canvas, char character, int x, int y) {
        // Delegate to composed flyweight for font rendering
        canvas.setFont(font.getFamily(), font.getSize(), font.getWeight());
        canvas.setColor(textColor);
        canvas.drawChar(character, x, y);
        
        if (underline) {
            int width = font.getCharWidth(character);
            canvas.drawLine(x, y + 2, x + width, y + 2, textColor);
        }
    }
    
    @Override
    public int getAdvanceWidth(char character) {
        return font.getCharWidth(character);
    }
    
    @Override
    public int getLineHeight() {
        return font.getLineHeight();
    }
}
 
/**
 * Font flyweight shared by multiple TextStyle flyweights.
 */
public class FontFlyweight {
    private final String family;
    private final int size;
    private final int weight;
    private final FontMetrics metrics;
    
    // Factory for font flyweights
    private static final Map<String, FontFlyweight> fontCache = 
        new ConcurrentHashMap<>();
    
    private FontFlyweight(String family, int size, int weight) {
        this.family = family;
        this.size = size;
        this.weight = weight;
        this.metrics = FontMetrics.load(family, size, weight);
    }
    
    public static FontFlyweight get(String family, int size, int weight) {
        String key = family + "_" + size + "_" + weight;
        return fontCache.computeIfAbsent(key, 
            k -> new FontFlyweight(family, size, weight));
    }
    
    // Accessor methods...
    public String getFamily() { return family; }
    public int getSize() { return size; }
    public int getWeight() { return weight; }
    public int getCharWidth(char c) { return metrics.getWidth(c); }
    public int getLineHeight() { return metrics.getLineHeight(); }
}