class_loader.go

// GNU GPL v3 License
// Copyright (c) 2017 github.com/ymhhh

// Package classloader provides a reflection-based class loader inspired by Java/Akka.
// Types are registered by name or by Go package path, and can be looked up concurrently.
//
// Version: v1.0.1
package classloader

import (
	"fmt"
	"reflect"
	"sync"
)

// ClassLoader registers and resolves reflect.Type values, optionally delegating to a parent loader.
type ClassLoader interface {
	// GetParent returns the parent loader, or nil for the root loader.
	GetParent() ClassLoader
	// LoadClass registers the element type of v. Pass a typed nil pointer such as (*MyType)(nil).
	// When name is empty, the key defaults to "PkgPath.TypeName".
	LoadClass(name string, v interface{}) error
	// FindClass looks up a type by custom name (string) or by typed nil / composite value.
	FindClass(name interface{}) (reflect.Type, bool)
	// FindLoadedClass reports whether name is registered locally or in an ancestor loader.
	FindLoadedClass(name string) bool
}

// Default is the process-wide root class loader.
var Default = NewClassLoader(nil)

type defaultClassLoader struct {
	parent ClassLoader
	// nameTypes maps user-defined names (e.g. "app:Actor") to element types.
	nameTypes map[string]reflect.Type
	// pathTypes maps "PkgPath.TypeName" keys to element types for type-based lookup.
	pathTypes map[string]reflect.Type

	locker sync.RWMutex
}

// NewClassLoader creates a loader that falls back to parent when a type is not found locally.
func NewClassLoader(parent ClassLoader) ClassLoader {
	return &defaultClassLoader{
		parent:    parent,
		nameTypes: make(map[string]reflect.Type),
		pathTypes: make(map[string]reflect.Type),
	}
}

func (p *defaultClassLoader) FindLoadedClass(name string) (exist bool) {
	_, exist = p.FindClass(name)
	return
}

func (p *defaultClassLoader) GetParent() (loader ClassLoader) {
	p.locker.RLock()
	loader = p.parent
	p.locker.RUnlock()
	return
}

func (p *defaultClassLoader) LoadClass(name string, v interface{}) error {
	if v == nil {
		return ErrNilClassValue
	}

	vType := reflect.TypeOf(v)
	if vType == nil {
		// Untyped nil has no reflect.Type and cannot identify a class.
		return ErrNilClassValue
	}

	switch vType.Kind() {
	case reflect.Ptr, reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
	default:
		return ErrInvalidClassType
	}

	elemType := vType.Elem()
	pathKey := genKey(elemType)
	if name == "" {
		name = pathKey
	}

	// Hold the write lock for the entire check-then-act sequence so concurrent
	// readers never observe a partially updated registry.
	p.locker.Lock()
	defer p.locker.Unlock()

	if _, exist := p.findClassLocal(name); exist {
		return nil
	}
	// Skip local registration when an ancestor already owns this name.
	if p.parent != nil {
		if _, exist := p.parent.FindClass(name); exist {
			return nil
		}
	}

	if _, exist := p.findClassLocal(v); !exist {
		p.pathTypes[pathKey] = elemType
	}

	if _, exist := p.findClassLocal(name); !exist {
		p.nameTypes[name] = elemType
	}

	return nil
}

func (p *defaultClassLoader) FindClass(name interface{}) (typ reflect.Type, exist bool) {
	p.locker.RLock()
	typ, exist = p.findClassLocal(name)
	p.locker.RUnlock()
	if exist {
		return
	}
	if p.parent != nil {
		return p.parent.FindClass(name)
	}
	return
}

// findClassLocal reads the local maps. The caller must hold at least a read lock,
// or the write lock when called from LoadClass.
func (p *defaultClassLoader) findClassLocal(name interface{}) (typ reflect.Type, exist bool) {
	vType := reflect.TypeOf(name)
	if vType == nil {
		return nil, false
	}

	switch vType.Kind() {
	case reflect.String:
		typ, exist = p.nameTypes[name.(string)]
	case reflect.Ptr, reflect.Array, reflect.Chan, reflect.Map, reflect.Slice:
		typ, exist = p.pathTypes[genKey(vType.Elem())]
	}
	return
}

// genKey builds the canonical type key used in pathTypes, e.g. "main.MyStruct".
func genKey(v reflect.Type) string {
	return fmt.Sprintf("%s.%s", v.PkgPath(), v.Name())
}