Converts provided name from the backing namespace into a container lookup name.
Examples:
App.FooBarHelper -> helper:foo-bar
App.THelper -> helper:t
@method translateToContainerFullname
@param {String} type
@param {String} name
@private
496619
function (type, name) {
      var suffix = _emberRuntimeSystemString.classify(type);
      var namePrefix = name.slice(0, suffix.length * -1);
      var dasherizedName = _emberRuntimeSystemString.dasherize(namePrefix);

      return type + ':' + dasherizedName;
    }
1272043
function requireTypeByName(typeName) {
    var type = typeByName[typeName];
    if (!type) {
        var msg = 'Unable to retrieve a Type by Name [' + typeName + ']';
        registryLogger.error(msg);
        throw new Error(msg);
    }
    if (registryLogger.isDebugEnabled()) {
        registryLogger.debug('Require Type \'%s\' by name [%s]', type.id, typeName);
    }
    return type;
}
1105648
function( name ) {
			var type = _.reduce( name.split('.'), function( memo, val ) {
				return memo[ val ];
			}, exports);
			return type !== exports ? type: null;
		}
499709
private <T extends NamedDescriptor> T getOrCreateNamedDescriptor(Class<T> type, String name, Map<String, T> descriptors, Store store) {
        T descriptor = descriptors.get(name);
        if (descriptor == null) {
            descriptor = store.create(type);
            descriptor.setName(name);
            descriptors.put(name, descriptor);
        }
        return descriptor;
    }
516510
function byType(appName, type, callback) {
    var url = format('/%s/apps/%s/containers/%s/', deis.version, appName, type);
    commons.get(url, callback);
  }
175151
function (parsedName) {
      var templateName = parsedName.fullNameWithoutType.replace(/\./g, '/');

      return _emberHtmlbarsTemplate_registry.get(templateName) || _emberHtmlbarsTemplate_registry.get(_emberRuntimeSystemString.decamelize(templateName));
    }
1003762
function typeName(item) {
  if (isNull(item)) {
    return "null";
  }
  else if (isUndefined(item)) {
    return "undefined";
  }

  return /\[.+ ([^\]]+)/.exec(toString(item))[1].toLowerCase();
}
1004386
def register_type_name(t, name):
    
    assert isinstance(t, type)
    assert isinstance(name, unicode)
    __type_names[t] = name
23817
function toTypeRefName(Type) {
    var ref = toTypeRef(Type);
    return ref instanceof Function ? ref.name : ref;
  }
279700
function getTypeName(namespace, type) {
    let namespaceName = namespace.fullName;
    let finalName;
    for (let title of type.titles) {
        let name = titleToTypeName(namespaceName, title);
        if (finalName) {
            if (name[1]) {
                // An explicit type name, so make sure it isn't masking anything
                if (finalName[1] && name[0] !== finalName[0]) {
                    // Previous explicit name from another title is different
                    throw new Error(title + '\'s override to ' + name[0]
                        + ' would shadow explicit name of ' + finalName[0]);
                }
                // Otherwise take this name since it either is the same, or overrides
                // a non-explicit name
                finalName = name;
            }
            else if (!finalName[1] && name[0].length < finalName[0].length) {
                // Take the shorter of the generated names
                finalName = name;
            }
        }
        else {
            // First valid name
            finalName = name;
        }
    }
    if (finalName) {
        return finalName;
    }
    else {
        throw new Error('Unable to generate typename for ' + type.titles[0]);
    }
}
327967
function(obj, type, name) {
    var nameMap = this._store[type]
      , objList = nameMap ? nameMap[name] : null
      , ind
    if (!objList) return
    ind = objList.indexOf(obj)
    if (ind === -1) return 
    objList.splice(ind, 1)
    exports.emitter.emit('namedObjects:unregistered:' + type, obj)
  }
193941
function anyTypeAlias(name: string): BabelAST {
  return t.typeAlias(t.identifier(name), null, t.anyTypeAnnotation());
}
1033504
def get_object_by_name(content, object_type, name, regex=False):
    '''
    
    '''
    container = content.viewManager.CreateContainerView(
        content.rootFolder, [object_type], True
    )
    for c in container.view:
        if regex:
            if re.match(name, c.name):
                return c
        elif c.name == name:
            return c
673827
function(typePrefix, name) {
            var vcapServices = (typeof process.env.VCAP_SERVICES === 'string' ?
                                JSON.parse(process.env.VCAP_SERVICES) : {});
            var matchType = new RegExp('^' + typePrefix);
            for (var type in vcapServices) {
                if (matchType.test(type)) {
                    var svcDef = vcapServices[type];
                    if (Array.isArray(svcDef)) {
                        if (name) {
                            for (var svc in svcDef) {
                                var val = svcDef[svc];
                                if ((typeof val === 'object') &&
                                    (val.name === name)) {
                                    return val.credentials;
                                }
                            }
                        } else {
                            var service = svcDef[0];
                            if (typeof service === 'object') {
                                return service.credentials;
                            }
                        }
                    }
                }
            }
            return undefined;
        }
673607
function(name) {
    return {
      // the key
      key: name + '._index_',
      // returns the index
      all: function() {
        var a  = storage.getItem(this.key)
        if (a) {
          a = JSON.parse(a)
        }
        if (a === null) storage.setItem(this.key, JSON.stringify([])) // lazy init
        return JSON.parse(storage.getItem(this.key))
      },
      // adds a key to the index
      add: function (key) {
        var a = this.all()
        a.push(key)
        storage.setItem(this.key, JSON.stringify(a))
      },
      // deletes a key from the index
      del: function (key) {
        var a = this.all(), r = []
        // FIXME this is crazy inefficient but I'm in a strata meeting and half concentrating
        for (var i = 0, l = a.length; i < l; i++) {
          if (a[i] != key) r.push(a[i])
        }
        storage.setItem(this.key, JSON.stringify(r))
      },
      // returns index for a key
      find: function (key) {
        var a = this.all()
        for (var i = 0, l = a.length; i < l; i++) {
          if (key === a[i]) return i
        }
        return false
      }
    }
  }
776858
function (name, separator) {

                var fullName, sep = separator || "/";

                if (name.indexOf(sep) >= 0) {
                    fullName = name; //already got fully-qualified (theoretically)
                } else if (name.indexOf("Service") >= 0) {
                    fullName = "Schema" + sep + "services" + sep + name; //just got the service class name
                } else {
                    fullName = "Schema" + sep + "services" + sep + name + "Service"; //just got the service "object" name
                }

                logger.debug("Service util created full name [" + fullName + "] from [" + name + "]");

                return fullName;

            }
465590
def from_type_name(cls, typ, name):
        """"""
        # Try aliases first.
        for k, nt in cls.defined_aliases.items():
            if typ is not None and typ != nt.type: continue
            #print(name, nt.name)
            if name == nt.name:
                if len(k) == 1: return cls(xc=k)
                if len(k) == 2: return cls(x=k[0], c=k[1])
                raise ValueError("Wrong key: %s" % k)

        # At this point, we should have something in the form
        # name="GGA_X_PBE+GGA_C_PBE" or  name=""LDA_XC_TETER93"
        if "+" in name:
            #if typ is not None: raise ValueError("typ: `%s` but name: `%s`" % (typ, name))
            x, c = (s.strip() for s in name.split("+"))
            x, c = LibxcFunc[x], LibxcFunc[c]
            return cls(x=x, c=c)
        else:
            #if typ is not None: raise ValueError("typ: `%s` but name: `%s`" % (typ, name))
            xc = LibxcFunc[name]
            return cls(xc=xc)

        if typ is None:
            raise ValueError("Cannot find name=%s in defined_aliases" % name)
        else:
            raise ValueError("Cannot find type=%s, name=%s in defined_aliases" % (typ, name))