dotcloud/docker

package container // import "github.com/docker/docker/container"

import (
    "sync"
)

// memoryStore implements a Store in memory.
type memoryStore struct {
    s map[string]*Container
    sync.RWMutex
}

// NewMemoryStore initializes a new memory store.
func NewMemoryStore() Store {
    return &memoryStore{
        s: make(map[string]*Container),
    }
}

// Add appends a new container to the memory store.
// It overrides the id if it existed before.
func (c *memoryStore) Add(id string, cont *Container) {
    c.Lock()
    c.s[id] = cont
    c.Unlock()
}

// Get returns a container from the store by id.
func (c *memoryStore) Get(id string) *Container {
    var res *Container
    c.RLock()
    res = c.s[id]
    c.RUnlock()
    return res
}

// Delete removes a container from the store by id.
func (c *memoryStore) Delete(id string) {
    c.Lock()
    delete(c.s, id)
    c.Unlock()
}

// List returns a sorted list of containers from the store.
// The containers are ordered by creation date.
func (c *memoryStore) List() []*Container {
    containers := History(c.all())
    containers.sort()
    return containers
}

// Size returns the number of containers in the store.
func (c *memoryStore) Size() int {
    c.RLock()
    defer c.RUnlock()
    return len(c.s)
}

// First returns the first container found in the store by a given filter.
func (c *memoryStore) First(filter StoreFilter) *Container {
    for _, cont := range c.all() {
        if filter(cont) {
            return cont
        }
    }
    return nil
}

// ApplyAll calls the reducer function with every container in the store.
// This operation is asynchronous in the memory store.
// NOTE: Modifications to the store MUST NOT be done by the StoreReducer.
func (c *memoryStore) ApplyAll(apply StoreReducer) {
    wg := new(sync.WaitGroup)
    for _, cont := range c.all() {
        wg.Add(1)
        go func(container *Container) {
            apply(container)
            wg.Done()
        }(cont)
    }

    wg.Wait()
}

func (c *memoryStore) all() []*Container {
    c.RLock()
    containers := make([]*Container, 0, len(c.s))
    for _, cont := range c.s {
        containers = append(containers, cont)
    }
    c.RUnlock()
    return containers
}

var _ Store = &memoryStore{}