attempt to get the wrapped component's name
430431
function getComponentName(target) {
  if (target.displayName && typeof target.displayName === 'string') {
    return target.displayName;
  }

  return target.name || 'Component';
}
1126044
function getName(name, width, separator) {

        // handle empty separator as no separator
        if (typeof separator === 'undefined') {
            separator = '';
        }

        if (name) {
            return separator + name;
        } else {
            return separator + width;
        }
    }
954269
private String getFixedName (Class<? extends ComponentSystemEvent> cls)
    {
        StringBuilder result = new StringBuilder();
        String className;
        
        // Get the unqualified class name.
        
        className = cls.getSimpleName();
        
        // Strip the trailing "event" off the class name if present.
        
        if (className.toLowerCase().endsWith ("event"))
        {
            className = className.substring (0, result.length() - 5);
        }
        
        // Prepend the package name.
        
        if (cls.getPackage() != null)
        {
            result.append (cls.getPackage().getName());
            result.append ('.');
        }
        
        result.append (className);
        
        return result.toString();
    }
873958
public String getLabel(JComponent component) {
        String label = component2LabelMap.get(component);
        if (label != null) {
            return label;
        } else {
            return "";
        }
    }
706379
function getItemAsNameVal (item) {
    if (!item) {
      return undefined;
    }

    var locals = {};
    if (ctrl.itemName) {
      locals[ ctrl.itemName ] = item;
    }

    return locals;
  }
1204937
def stripped_name(self):
        """"""

        name = self.name

        # Strip function parameters from name by recursively removing paired parenthesis
        while True:
            name, n = self._parenthesis_re.subn('', name)
            if not n:
                break

        # Strip const qualifier
        name = self._const_re.sub('', name)

        # Strip template parameters from name by recursively removing paired angles
        while True:
            name, n = self._angles_re.subn('', name)
            if not n:
                break

        return name
169521
def getName(self, innerFlag=False):
        
        if self._currentIdx is None:
            raise error.PyAsn1Error('Component not chosen')
        else:
            if innerFlag:
                c = self._componentValues[self._currentIdx]
                if isinstance(c, Choice):
                    return c.getName(innerFlag)
            return self.componentType.getNameByPosition(self._currentIdx)
922277
function getNewComponents(components, registry) {
    var componentNameHelper = {};
    components.forEach(function (component) { return (componentNameHelper[component._componentName] = true); });
    var componentNames = Object.keys(componentNameHelper);
    return componentNames.filter(function (componentName) { return !registry._activeComponents[componentName]; });
}
86335
public static String getPayloadVariableName(GraphRewrite event, EvaluationContext ctx) throws IllegalStateException
    {
        Variables variables = Variables.instance(event);
        Map<String, Iterable<? extends WindupVertexFrame>> topLayer = variables.peek();
        if (topLayer.keySet().size() != 1)
        {
            throw new IllegalStateException("Cannot determine Iteration payload variable name because the top "
                        + "layer of " + Variables.class.getSimpleName() + " stack contains " + topLayer.keySet().size() + " variables: "
                        + topLayer.keySet());
        }
        String name = topLayer.keySet().iterator().next();
        return name;
    }
1032417
public static String getterName(Class<?> componentClass) {
      if (componentClass == null) return null;
      StringBuilder sb = new StringBuilder("get");
      sb.append(componentClass.getSimpleName());
      return sb.toString();
   }
26638
public String getName()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getName");
    String name = null;
    if(_outputHandler!=null)
    {
      name = _outputHandler.getDestinationName();
    }
    else
    {
      name = _anycastInputHandler.getDestName();
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "getName", name);
    return name;  
  }
306835
function getProjectName(componentPath, optionsName){
		if (typeof optionsName == 'string') return optionsName;
		var projectName;
		for (var prj in optionsName){
			if(~componentPath.indexOf(optionsName[prj])) projectName = prj;
		}
		if (!projectName) grunt.fail.warn('Missing name in options for component with path: ' + componentPath);
		return projectName;
	}
883223
private String getNamingContextName() {    	
	    if (namingContextName == null) {
			Container parent = getParent();
			if (parent == null) {
				namingContextName = getName();
			} else {
				Stack<String> stk = new Stack<String>();
				StringBuffer buff = new StringBuffer();
				while (parent != null) {
					stk.push(parent.getName());
					parent = parent.getParent();
				}
				while (!stk.empty()) {
					buff.append("/" + stk.pop());
				}
				buff.append(getName());
				namingContextName = buff.toString();
			}
		}
		return namingContextName;
    }
900858
function getComponentPath (componentName) {
  let entry = COMPONENTS.find(({ name }) => name === componentName)
  if (!entry) {
    return null
  }
  return `veui/${COMPONENTS_DIRNAME}/${entry.path}`
}
769669
function getInstanceNameFromElement(element) {
  let nameFromName = getAttribute(element, 'name');

  if (nameFromName !== null && nameFromName !== undefined && nameFromName !== '')
    return nameFromName;
  else
    return null;
}
827802
function getMarkupWrap(nodeName) {
	  !!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Markup wrapping node not initialized') : invariant(false) : void 0;
	  if (!markupWrap.hasOwnProperty(nodeName)) {
	    nodeName = '*';
	  }
	  if (!shouldWrap.hasOwnProperty(nodeName)) {
	    if (nodeName === '*') {
	      dummyNode.innerHTML = '<link />';
	    } else {
	      dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';
	    }
	    shouldWrap[nodeName] = !dummyNode.firstChild;
	  }
	  return shouldWrap[nodeName] ? markupWrap[nodeName] : null;
	}
829029
function getComponentName(node) {

  // var Hello = React.createClass({ ... });
  if (
    node.parent && node.parent.parent &&
    node.parent.parent.type === 'VariableDeclarator' &&
    node.parent.parent.id.name) {
    return node.parent.parent.id.name;
  }

  // class Hello extends React.Component { }
  if (node.type === 'ClassDeclaration' &&
    node.id.type === 'Identifier' &&
    node.id.name) {
    return node.id.name;
  }

  // var DontLook = function() { return (<div>Hello {this.props.name}</div>); };
  if (
    node.parent && node.parent.id &&
    (node.type === 'FunctionExpression' ||
    node.type === 'ArrowFunctionExpression') &&
    node.id === null &&
    node.parent.type === 'VariableDeclarator' &&
    node.parent.id.type === 'Identifier') {
    return node.parent.id.name;
  }

  // function FolksWolves() { return (<div>Hello {this.props.name}</div>); }
  if (
    node.type === 'FunctionDeclaration' &&
    node.id) {
    return node.id.name;
  }

  return null;
}