github.com/rochacon/deis@v1.0.2-0.20150903015341-6839b592a1ff/mesos/pkg/boot/extpoints/extpoints.go (about)

     1  // generated by go-extpoints -- DO NOT EDIT
     2  package extpoints
     3  
     4  import (
     5  	"reflect"
     6  	"runtime"
     7  	"strings"
     8  	"sync"
     9  )
    10  
    11  var extRegistry = &registryType{m: make(map[string]*extensionPoint)}
    12  
    13  type registryType struct {
    14  	sync.Mutex
    15  	m map[string]*extensionPoint
    16  }
    17  
    18  // Top level registration
    19  
    20  func extensionTypes(extension interface{}) []string {
    21  	var ifaces []string
    22  	typ := reflect.TypeOf(extension)
    23  	for name, ep := range extRegistry.m {
    24  		if ep.iface.Kind() == reflect.Func && typ.AssignableTo(ep.iface) {
    25  			ifaces = append(ifaces, name)
    26  		}
    27  		if ep.iface.Kind() != reflect.Func && typ.Implements(ep.iface) {
    28  			ifaces = append(ifaces, name)
    29  		}
    30  	}
    31  	return ifaces
    32  }
    33  
    34  func RegisterExtension(extension interface{}, name string) []string {
    35  	extRegistry.Lock()
    36  	defer extRegistry.Unlock()
    37  	var ifaces []string
    38  	for _, iface := range extensionTypes(extension) {
    39  		if extRegistry.m[iface].register(extension, name) {
    40  			ifaces = append(ifaces, iface)
    41  		}
    42  	}
    43  	return ifaces
    44  }
    45  
    46  func UnregisterExtension(name string) []string {
    47  	extRegistry.Lock()
    48  	defer extRegistry.Unlock()
    49  	var ifaces []string
    50  	for iface, extpoint := range extRegistry.m {
    51  		if extpoint.unregister(name) {
    52  			ifaces = append(ifaces, iface)
    53  		}
    54  	}
    55  	return ifaces
    56  }
    57  
    58  // Base extension point
    59  
    60  type extensionPoint struct {
    61  	sync.Mutex
    62  	iface      reflect.Type
    63  	extensions map[string]interface{}
    64  }
    65  
    66  func newExtensionPoint(iface interface{}) *extensionPoint {
    67  	ep := &extensionPoint{
    68  		iface:      reflect.TypeOf(iface).Elem(),
    69  		extensions: make(map[string]interface{}),
    70  	}
    71  	extRegistry.Lock()
    72  	extRegistry.m[ep.iface.Name()] = ep
    73  	extRegistry.Unlock()
    74  	return ep
    75  }
    76  
    77  func (ep *extensionPoint) lookup(name string) interface{} {
    78  	ep.Lock()
    79  	defer ep.Unlock()
    80  	ext, ok := ep.extensions[name]
    81  	if !ok {
    82  		return nil
    83  	}
    84  	return ext
    85  }
    86  
    87  func (ep *extensionPoint) all() map[string]interface{} {
    88  	ep.Lock()
    89  	defer ep.Unlock()
    90  	all := make(map[string]interface{})
    91  	for k, v := range ep.extensions {
    92  		all[k] = v
    93  	}
    94  	return all
    95  }
    96  
    97  func (ep *extensionPoint) register(extension interface{}, name string) bool {
    98  	ep.Lock()
    99  	defer ep.Unlock()
   100  	if name == "" {
   101  		typ := reflect.TypeOf(extension)
   102  		if typ.Kind() == reflect.Func {
   103  			nameParts := strings.Split(runtime.FuncForPC(
   104  				reflect.ValueOf(extension).Pointer()).Name(), ".")
   105  			name = nameParts[len(nameParts)-1]
   106  		} else {
   107  			name = typ.Elem().Name()
   108  		}
   109  	}
   110  	_, exists := ep.extensions[name]
   111  	if exists {
   112  		return false
   113  	}
   114  	ep.extensions[name] = extension
   115  	return true
   116  }
   117  
   118  func (ep *extensionPoint) unregister(name string) bool {
   119  	ep.Lock()
   120  	defer ep.Unlock()
   121  	_, exists := ep.extensions[name]
   122  	if !exists {
   123  		return false
   124  	}
   125  	delete(ep.extensions, name)
   126  	return true
   127  }
   128  
   129  // BootComponent
   130  
   131  var BootComponents = &bootComponentExt{
   132  	newExtensionPoint(new(BootComponent)),
   133  }
   134  
   135  type bootComponentExt struct {
   136  	*extensionPoint
   137  }
   138  
   139  func (ep *bootComponentExt) Unregister(name string) bool {
   140  	return ep.unregister(name)
   141  }
   142  
   143  func (ep *bootComponentExt) Register(extension BootComponent, name string) bool {
   144  	return ep.register(extension, name)
   145  }
   146  
   147  func (ep *bootComponentExt) Lookup(name string) BootComponent {
   148  	ext := ep.lookup(name)
   149  	if ext == nil {
   150  		return nil
   151  	}
   152  	return ext.(BootComponent)
   153  }
   154  
   155  func (ep *bootComponentExt) Select(names []string) []BootComponent {
   156  	var selected []BootComponent
   157  	for _, name := range names {
   158  		selected = append(selected, ep.Lookup(name))
   159  	}
   160  	return selected
   161  }
   162  
   163  func (ep *bootComponentExt) All() map[string]BootComponent {
   164  	all := make(map[string]BootComponent)
   165  	for k, v := range ep.all() {
   166  		all[k] = v.(BootComponent)
   167  	}
   168  	return all
   169  }
   170  
   171  func (ep *bootComponentExt) Names() []string {
   172  	var names []string
   173  	for k := range ep.all() {
   174  		names = append(names, k)
   175  	}
   176  	return names
   177  }