Flyweight Pattern #

// Wrong way: all data in one struct — no sharing
type Bullet struct {
    // Intrinsic — the same for all bullets of the same type
    SpritePath string    // ← should be in the Flyweight
    Damage     int       // ← should be in the Flyweight
    Speed      float64   // ← should be in the Flyweight

    // Extrinsic — different for every bullet
    X, Y    float64
    VelX, VelY float64
    OwnerID string
}
// 1000 bullets = 1000 copies of SpritePath, Damage, Speed

// Correct way: separate intrinsic and extrinsic
type BulletType struct { // Flyweight — shared
    SpritePath string
    Damage     int
    Speed      float64
}

type BulletInstance struct { // Context — per instance
    bulletType *BulletType // reference to the flyweight
    X, Y       float64
    VelX, VelY float64
    OwnerID    string
}
// 1000 bullets = 1 BulletType + 1000 BulletInstance (much smaller)

package texteditor

import "fmt"

// GlyphStyle defines a character's visual appearance.
// This is intrinsic state — the same for all instances of the same character.
type GlyphStyle struct {
    Font      string
    Size      int
    Bold      bool
    Italic    bool
    BaseColor string
}

// CharacterGlyph is the Flyweight — it stores data identical for all
// occurrences of the same character with the same style.
// IMPORTANT: this struct is immutable after creation; there are no setters.
type CharacterGlyph struct {
    char  rune
    style GlyphStyle
}

// ExtrinsicState stores data that differs for every character occurrence.
// This is NOT stored in the CharacterGlyph — it is supplied when Render is called.
type ExtrinsicState struct {
    X, Y            int
    SelectionColor  string
    IsSelected      bool
}

// Render displays the character at the given position.
// Extrinsic state (position, selection) comes from outside, not stored in the glyph.
func (g *CharacterGlyph) Render(state ExtrinsicState) {
    color := g.style.BaseColor
    if state.IsSelected && state.SelectionColor != "" {
        color = state.SelectionColor
    }

    style := ""
    if g.style.Bold {
        style += "bold "
    }
    if g.style.Italic {
        style += "italic"
    }

    fmt.Printf("Render '%c' [%s %s%dpt %s] at (%d,%d)\n",
        g.char,
        g.style.Font,
        style,
        g.style.Size,
        color,
        state.X, state.Y,
    )
}

// Char returns the character this glyph represents.
func (g *CharacterGlyph) Char() rune { return g.char }

// Style returns the glyph's style.
func (g *CharacterGlyph) Style() GlyphStyle { return g.style }

// MemorySize estimates this glyph's memory footprint in bytes (for demonstration).
func (g *CharacterGlyph) MemorySize() int {
    return 4 + // rune (char)
        len(g.style.Font) +
        4 + // int (size)
        1 + // bool (bold)
        1 + // bool (italic)
        len(g.style.BaseColor)
}

package texteditor

import (
    "fmt"
    "sync"
)

// GlyphPool is the FlyweightFactory — it manages the CharacterGlyph pool.
// Thread-safe for use from multiple goroutines.
type GlyphPool struct {
    mu    sync.RWMutex
    glyphs map[string]*CharacterGlyph
}

// NewGlyphPool creates an empty, ready-to-use pool.
func NewGlyphPool() *GlyphPool {
    return &GlyphPool{
        glyphs: make(map[string]*CharacterGlyph),
    }
}

// Get returns the flyweight for the requested character + style combination.
// If it already exists in the pool, the old one is returned. If not, a new one is created.
func (p *GlyphPool) Get(char rune, style GlyphStyle) *CharacterGlyph {
    key := buildKey(char, style)

    // Optimistic read — most cases are cache hits
    p.mu.RLock()
    if glyph, ok := p.glyphs[key]; ok {
        p.mu.RUnlock()
        return glyph
    }
    p.mu.RUnlock()

    // Acquire the write lock to create a new glyph
    p.mu.Lock()
    defer p.mu.Unlock()

    // Double-check after acquiring the write lock — race condition prevention
    if glyph, ok := p.glyphs[key]; ok {
        return glyph
    }

    glyph := &CharacterGlyph{char: char, style: style}
    p.glyphs[key] = glyph
    return glyph
}

// Count returns the number of unique flyweights stored in the pool.
func (p *GlyphPool) Count() int {
    p.mu.RLock()
    defer p.mu.RUnlock()
    return len(p.glyphs)
}

// TotalMemory returns an estimate of the total memory used by the pool (bytes).
func (p *GlyphPool) TotalMemory() int {
    p.mu.RLock()
    defer p.mu.RUnlock()
    total := 0
    for _, g := range p.glyphs {
        total += g.MemorySize()
    }
    return total
}

// buildKey creates a unique key for a character + style combination.
func buildKey(char rune, style GlyphStyle) string {
    boldStr := "0"
    if style.Bold {
        boldStr = "1"
    }
    italicStr := "0"
    if style.Italic {
        italicStr = "1"
    }
    return fmt.Sprintf("%d|%s|%d|%s|%s|%s",
        char, style.Font, style.Size, boldStr, italicStr, style.BaseColor)
}

package texteditor

// CharacterEntry links a flyweight with its extrinsic state.
// This is what is stored per character — much smaller than storing all the data.
type CharacterEntry struct {
    glyph *CharacterGlyph // reference to the flyweight (shared)
    state ExtrinsicState  // extrinsic state (per instance)
}

// Document is the client that manages many characters using Flyweight.
type Document struct {
    pool       *GlyphPool
    characters []CharacterEntry
    cursorX    int
    cursorY    int
    lineHeight int
    charWidth  int
}

// NewDocument creates a new document with the configured glyph pool.
func NewDocument(pool *GlyphPool, lineHeight, charWidth int) *Document {
    return &Document{
        pool:       pool,
        characters: make([]CharacterEntry, 0),
        lineHeight: lineHeight,
        charWidth:  charWidth,
    }
}

// AddChar adds a character to the document with the given style.
// The position is calculated automatically based on typing order.
func (d *Document) AddChar(char rune, style GlyphStyle) {
    // Get the flyweight from the pool — create a new one only if it does not exist
    glyph := d.pool.Get(char, style)

    entry := CharacterEntry{
        glyph: glyph,
        state: ExtrinsicState{
            X: d.cursorX,
            Y: d.cursorY,
        },
    }
    d.characters = append(d.characters, entry)

    // Update the cursor position
    if char == '\n' {
        d.cursorX = 0
        d.cursorY += d.lineHeight
    } else {
        d.cursorX += d.charWidth
    }
}

// AddText adds a string of text with the same style for all characters.
func (d *Document) AddText(text string, style GlyphStyle) {
    for _, char := range text {
        d.AddChar(char, style)
    }
}

// SetSelection marks a range of characters as selected.
func (d *Document) SetSelection(start, end int, selectionColor string) {
    for i := start; i < end && i < len(d.characters); i++ {
        d.characters[i].state.IsSelected = true
        d.characters[i].state.SelectionColor = selectionColor
    }
}

// Render displays the entire document on screen.
func (d *Document) Render() {
    for _, entry := range d.characters {
        entry.glyph.Render(entry.state)
    }
}

// CharCount returns the number of characters in the document.
func (d *Document) CharCount() int { return len(d.characters) }

// MemoryReport displays a memory usage report.
func (d *Document) MemoryReport() {
    uniqueGlyphs := d.pool.Count()
    poolMemory := d.pool.TotalMemory()
    // Each CharacterEntry: pointer (8B) + ExtrinsicState (~32B) ≈ 40B
    contextMemory := len(d.characters) * 40

    fmt.Printf("\n=== Memory Report ===\n")
    fmt.Printf("Total characters: %d\n", len(d.characters))
    fmt.Printf("Unique glyphs in pool: %d\n", uniqueGlyphs)
    fmt.Printf("Pool memory: %d bytes\n", poolMemory)
    fmt.Printf("Context memory: %d bytes\n", contextMemory)
    fmt.Printf("Total memory: %d bytes\n", poolMemory+contextMemory)
    fmt.Printf("Without Flyweight (est): %d bytes\n", len(d.characters)*(poolMemory/uniqueGlyphs+40))
}

func main() {
    pool := texteditor.NewGlyphPool()
    doc := texteditor.NewDocument(pool, 20, 10)

    // Commonly used styles
    normalStyle := texteditor.GlyphStyle{Font: "Arial", Size: 12, BaseColor: "#000000"}
    boldStyle   := texteditor.GlyphStyle{Font: "Arial", Size: 12, Bold: true, BaseColor: "#000000"}
    headerStyle := texteditor.GlyphStyle{Font: "Arial", Size: 18, Bold: true, BaseColor: "#1a1a2e"}

    // Add a heading
    doc.AddText("Financial Report Q1 2024\n", headerStyle)

    // Add thousands of lines of text with normal and bold styles
    for i := 0; i < 500; i++ {
        doc.AddText("Revenue: ", boldStyle)
        doc.AddText("Rp 1,500,000,000\n", normalStyle)
    }

    // Despite thousands of characters, the pool only stores unique glyphs
    fmt.Printf("Total characters: %d\n", doc.CharCount())
    fmt.Printf("Unique glyphs in pool: %d\n", pool.Count())

    // Mark some text as selected
    doc.SetSelection(0, 24, "#4a90d9")

    // Show the memory report
    doc.MemoryReport()
}

package particle

import (
    "fmt"
    "sync"
    "time"
)

// ParticleType is the Flyweight — it stores data identical for all particles
// of the same type (fire, smoke, spark, snow).
type ParticleType struct {
    Name        string
    SpritePath  string  // path to the texture file — can be several MB
    FrameCount  int     // number of animation frames
    BlendMode   string  // "additive", "alpha", "multiply"
    DefaultSize float64
}

// Render draws one particle with the state supplied from outside.
func (pt *ParticleType) Render(x, y, size, opacity, rotation float64) {
    fmt.Printf("[%s] pos=(%.0f,%.0f) size=%.1f opacity=%.2f rot=%.0f°\n",
        pt.Name, x, y, size, opacity, rotation)
}

// ParticleTypeRegistry is the FlyweightFactory for particle types.
type ParticleTypeRegistry struct {
    mu    sync.RWMutex
    types map[string]*ParticleType
}

func NewParticleTypeRegistry() *ParticleTypeRegistry {
    return &ParticleTypeRegistry{
        types: make(map[string]*ParticleType),
    }
}

// Register adds a new particle type to the registry.
func (r *ParticleTypeRegistry) Register(name, spritePath, blendMode string, frameCount int, defaultSize float64) {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.types[name] = &ParticleType{
        Name:        name,
        SpritePath:  spritePath,
        FrameCount:  frameCount,
        BlendMode:   blendMode,
        DefaultSize: defaultSize,
    }
}

// Get fetches a particle type from the registry.
func (r *ParticleTypeRegistry) Get(name string) (*ParticleType, bool) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    pt, ok := r.types[name]
    return pt, ok
}

// ParticleInstance is the Context — it stores per-particle extrinsic state.
// This struct is very small because all heavy data lives in ParticleType (shared).
type ParticleInstance struct {
    particleType *ParticleType // reference to the flyweight — only 8 bytes (pointer)
    X, Y         float64       // position
    VelX, VelY   float64       // velocity
    Size         float64       // current size (can differ from the default)
    Opacity      float64       // transparency (0-1)
    Rotation     float64       // rotation in degrees
    BornAt       time.Time     // birth time — to compute age
    TTL          time.Duration // time to live
}

// IsAlive checks whether the particle is still active.
func (p *ParticleInstance) IsAlive() bool {
    return time.Since(p.BornAt) < p.TTL
}

// Update updates the particle's position and opacity based on elapsed time.
func (p *ParticleInstance) Update(dt float64) {
    p.X += p.VelX * dt
    p.Y += p.VelY * dt
    // Fade out over time
    age := time.Since(p.BornAt).Seconds()
    totalLife := p.TTL.Seconds()
    p.Opacity = 1.0 - (age / totalLife)
    if p.Opacity < 0 {
        p.Opacity = 0
    }
}

// Render displays the particle using the flyweight type.
func (p *ParticleInstance) Render() {
    p.particleType.Render(p.X, p.Y, p.Size, p.Opacity, p.Rotation)
}

// ParticleSystem manages thousands of active particles.
type ParticleSystem struct {
    registry  *ParticleTypeRegistry
    particles []*ParticleInstance
}

func NewParticleSystem(registry *ParticleTypeRegistry) *ParticleSystem {
    return &ParticleSystem{
        registry:  registry,
        particles: make([]*ParticleInstance, 0, 10000),
    }
}

// Emit releases a number of particles from a given position.
func (ps *ParticleSystem) Emit(typeName string, x, y float64, count int) error {
    pt, ok := ps.registry.Get(typeName)
    if !ok {
        return fmt.Errorf("particle type %q not registered", typeName)
    }

    for i := 0; i < count; i++ {
        // Only a ParticleInstance is created per particle — ParticleType is shared
        p := &ParticleInstance{
            particleType: pt,                         // pointer to the flyweight
            X:            x + randomOffset(),
            Y:            y + randomOffset(),
            VelX:         randomVelocity(),
            VelY:         randomVelocity() - 2,       // slight upward bias
            Size:         pt.DefaultSize * randomScale(),
            Opacity:      1.0,
            Rotation:     randomRotation(),
            BornAt:       time.Now(),
            TTL:          randomTTL(),
        }
        ps.particles = append(ps.particles, p)
    }
    return nil
}

// Update updates all particles and removes the dead ones.
func (ps *ParticleSystem) Update(dt float64) {
    alive := ps.particles[:0] // reuse the slice without new allocation
    for _, p := range ps.particles {
        if p.IsAlive() {
            p.Update(dt)
            alive = append(alive, p)
        }
    }
    ps.particles = alive
}

// Render displays all active particles.
func (ps *ParticleSystem) Render() {
    for _, p := range ps.particles {
        p.Render()
    }
}

// Stats returns particle system statistics.
func (ps *ParticleSystem) Stats() (active, uniqueTypes int) {
    return len(ps.particles), ps.registry.Count()
}

func randomOffset() float64   { return float64(time.Now().UnixNano()%20 - 10) }
func randomVelocity() float64 { return float64(time.Now().UnixNano()%10-5) * 0.5 }
func randomScale() float64    { return 0.8 + float64(time.Now().UnixNano()%40)*0.01 }
func randomRotation() float64 { return float64(time.Now().UnixNano() % 360) }
func randomTTL() time.Duration { return time.Duration(500+time.Now().UnixNano()%1500) * time.Millisecond }

func (r *ParticleTypeRegistry) Count() int {
    r.mu.RLock()
    defer r.mu.RUnlock()
    return len(r.types)
}

func main() {
    registry := particle.NewParticleTypeRegistry()

    // Register particle types — done once at startup
    registry.Register("fire",   "assets/fire_sprite.png",   "additive", 16, 24.0)
    registry.Register("smoke",  "assets/smoke_sprite.png",  "alpha",    8,  32.0)
    registry.Register("spark",  "assets/spark_sprite.png",  "additive", 1,  4.0)
    registry.Register("debris", "assets/debris_sprite.png", "alpha",    1,  8.0)

    ps := particle.NewParticleSystem(registry)

    // Simulate an explosion — emit thousands of particles
    _ = ps.Emit("fire",   400, 300, 200)
    _ = ps.Emit("smoke",  400, 300, 100)
    _ = ps.Emit("spark",  400, 300, 500)
    _ = ps.Emit("debris", 400, 300, 50)

    active, uniqueTypes := ps.Stats()
    fmt.Printf("Active particles: %d, Unique types: %d\n", active, uniqueTypes)
    // "Active particles: 850, Unique types: 4"
    // 850 small ParticleInstances + 4 shared ParticleTypes

    // Game loop simulation
    for frame := 0; frame < 60; frame++ {
        ps.Update(1.0 / 60.0) // 60fps
    }
}

// Approach 1: sync.RWMutex — more granular control
type ThreadSafePool struct {
    mu   sync.RWMutex
    pool map[string]*CharacterGlyph
}

func (p *ThreadSafePool) Get(key string, createFn func() *CharacterGlyph) *CharacterGlyph {
    // Optimistic read — most requests are cache hits
    p.mu.RLock()
    if glyph, ok := p.pool[key]; ok {
        p.mu.RUnlock()
        return glyph
    }
    p.mu.RUnlock()

    // Write lock to create a new one — with double-check
    p.mu.Lock()
    defer p.mu.Unlock()
    if glyph, ok := p.pool[key]; ok { // re-check after locking
        return glyph
    }
    glyph := createFn()
    p.pool[key] = glyph
    return glyph
}


// Approach 2: sync.Map — simpler, suitable for read-heavy workloads
type SyncMapPool struct {
    pool sync.Map
}

func (p *SyncMapPool) Get(key string, createFn func() *CharacterGlyph) *CharacterGlyph {
    // LoadOrStore: atomic check-and-store
    actual, loaded := p.pool.LoadOrStore(key, createFn())
    if loaded {
        // Already exists — discard the one we just created
    }
    return actual.(*CharacterGlyph)
}
// Note: sync.Map.LoadOrStore still calls createFn() before the check
// For expensive creation, use sync.RWMutex with double-check


// Approach 3: singleflight — prevents multiple goroutines from creating the same thing
import "golang.org/x/sync/singleflight"

type SingleflightPool struct {
    group singleflight.Group
    mu    sync.RWMutex
    pool  map[string]*CharacterGlyph
}

func (p *SingleflightPool) Get(key string, createFn func() (*CharacterGlyph, error)) (*CharacterGlyph, error) {
    p.mu.RLock()
    if glyph, ok := p.pool[key]; ok {
        p.mu.RUnlock()
        return glyph, nil
    }
    p.mu.RUnlock()

    // singleflight ensures createFn is called only ONCE even when many
    // goroutines request the same key at the same time
    result, err, _ := p.group.Do(key, func() (interface{}, error) {
        return createFn()
    })
    if err != nil {
        return nil, err
    }
    glyph := result.(*CharacterGlyph)

    p.mu.Lock()
    p.pool[key] = glyph
    p.mu.Unlock()

    return glyph, nil
}

func TestGlyphPool_ReturnsSameInstanceForSameKey(t *testing.T) {
    pool := texteditor.NewGlyphPool()
    style := texteditor.GlyphStyle{Font: "Arial", Size: 12, BaseColor: "#000"}

    glyph1 := pool.Get('A', style)
    glyph2 := pool.Get('A', style)

    // Must be the exact same pointer — not just equal values
    if glyph1 != glyph2 {
        t.Error("expected same pointer for same key, got different instances")
    }
    if pool.Count() != 1 {
        t.Errorf("expected 1 glyph in pool, got %d", pool.Count())
    }
}

func TestGlyphPool_DifferentStylesCreateDifferentGlyphs(t *testing.T) {
    pool := texteditor.NewGlyphPool()

    normalStyle := texteditor.GlyphStyle{Font: "Arial", Size: 12}
    boldStyle   := texteditor.GlyphStyle{Font: "Arial", Size: 12, Bold: true}

    glyph1 := pool.Get('A', normalStyle)
    glyph2 := pool.Get('A', boldStyle)

    if glyph1 == glyph2 {
        t.Error("expected different instances for different styles")
    }
    if pool.Count() != 2 {
        t.Errorf("expected 2 glyphs in pool, got %d", pool.Count())
    }
}

func TestGlyphPool_ThreadSafety(t *testing.T) {
    pool := texteditor.NewGlyphPool()
    style := texteditor.GlyphStyle{Font: "Arial", Size: 12}
    chars := []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")

    var wg sync.WaitGroup
    for goroutine := 0; goroutine < 100; goroutine++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for _, char := range chars {
                _ = pool.Get(char, style)
            }
        }()
    }
    wg.Wait()

    // After 100 goroutines finish, the pool must only hold len(chars) glyphs
    if pool.Count() != len(chars) {
        t.Errorf("expected %d unique glyphs, got %d (possible duplicate creation)", len(chars), pool.Count())
    }
}

func TestDocument_FlyweightReducesUniqueObjects(t *testing.T) {
    pool := texteditor.NewGlyphPool()
    doc := texteditor.NewDocument(pool, 20, 10)
    style := texteditor.GlyphStyle{Font: "Arial", Size: 12}

    // Add 1000 'A' characters
    for i := 0; i < 1000; i++ {
        doc.AddChar('A', style)
    }

    // Despite 1000 characters, the pool only has 1 glyph
    if pool.Count() != 1 {
        t.Errorf("expected 1 flyweight for 1000 identical chars, got %d", pool.Count())
    }
    if doc.CharCount() != 1000 {
        t.Errorf("expected 1000 characters in document, got %d", doc.CharCount())
    }
}