Returns property name to use or false if it should be treated as attribute
@param  {String}         attributeName Attribute to assign
@return {String|Boolean}               False if it should be an attribute, otherwise property name
778781
function transformPropertyName(attributeName) {
  if (propertiesToTransform[attributeName]) {
    return propertiesToTransform[attributeName];
  }
  if (nonTransformedProperties[attributeName] !== true) {
    return false;
  }
  return attributeName;
}
1042452
public Object getAttribute(String attributeName) {
    try {
      final int index = Integer.parseInt(attributeName) - 1;
      if (index < reportable.getMaxEntriesToKeep()) {
        return reportable.get(index).getValue();
      }
    } catch (NumberFormatException e) {
      LOGGER.error("Should never happen! Requested attribute should be an integer but was: " + attributeName);
    }
    return null;
  }
253242
private String getAttributeName(String fieldName) {
        String attributeName = fieldName;
        if (fieldName.indexOf(".") != -1) {
            attributeName = fieldName.substring(0, fieldName.indexOf("."));
        }
        return attributeName;
    }
1024053
public Attribute put(String attributeName) {
        Attribute attr = attributes.get(attributeName);
        if (attr == null) {
            attr = new Attribute();
        }
        attributes.put(attributeName, attr);
        return attr;
    }
6157
function(node, id, propertyName) {
			var rootids = [];
			if(!modules.domUtils.hasAttribute(node,'rootids')){
				return false;
			} else {
				rootids = modules.domUtils.getAttributeList(node, 'rootids');
				return (rootids.indexOf('id' + id + '-' + propertyName) > -1);
			}
		}
960781
function(items, propertyName) {
        if(!items) return false;

        var maxProperty;
        for(var i = 0; i < items.length; i++) {
            if(maxProperty == undefined)
                maxProperty = items[i][propertyName];
            else if(items[i][propertyName] > maxProperty)
                maxProperty = items[i][propertyName];
        }
        return maxProperty;
    }
875327
public static ResultAttribute valueOf(@Nonnull String attributeName) {
		ResultAttribute value;
		switch (attributeName) {
			case "TYPE_NAME":
				value = TYPE_NAME;
				break;
			case "OBJ_DOMAIN":
				value = OBJ_DOMAIN;
				break;
			case "CLASS_NAME":
				value = CLASS_NAME;
				break;
			case "ATTRIBUTE_NAME":
				value = ATTRIBUTE_NAME;
				break;
			default:
				throw new IllegalArgumentException("Invalid value " + attributeName);
		}
		return value;
	}
774188
function propertyNameToAttribute(propertyName) {
  let attribute = propertyNamesToAttributes[propertyName];
  if (!attribute) {
    // Convert and memoize.
    const uppercaseRegEx = /([A-Z])/g;
    attribute = propertyName.replace(uppercaseRegEx, '-$1').toLowerCase();
  }
  return attribute;
}
254984
protected String getElementName(String attributeName) {

        if (attributeName.contains("/")) {
            return attributeName.substring(attributeName.lastIndexOf("/") + 1);
        }
        return attributeName;
    }
436364
protected String getAttribute(String attributeName) {
    String factoryAttribute = contextName + "." + attributeName;
    return (String) factory.getAttribute(factoryAttribute);  
  }
171518
public AttributePropertiesImpl getAttributeProperties(final String attributeName) throws DevFailed {
        final AttributeImpl attr = AttributeGetterSetter.getAttribute(attributeName, device.getAttributeList());
        return attr.getProperties();
    }
753316
private static AttributeKey getAttributeKey(final String schemaArn, final String facetName, final String attributeName) {
        return new AttributeKey().withFacetName(facetName).withSchemaArn(schemaArn).withName(attributeName);
    }
289365
function (name, value) {
    if (DOMProperty.isReservedProp(name)) {
      return false;
    }
    if ((name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
      return false;
    }
    if (value === null) {
      return true;
    }
    switch (typeof value) {
      case 'boolean':
        return DOMProperty.shouldAttributeAcceptBooleanValue(name);
      case 'undefined':
      case 'number':
      case 'string':
      case 'object':
        return true;
      default:
        // function, symbol
        return false;
    }
  }
214105
function (node, attribute) {
    switch (attribute.name) {
      case 'style':
        return this._getStyleAttribute(attribute.value);
      default:
        var tagName = jsxTagName(node.tagName);
        var name =
          (ELEMENT_ATTRIBUTE_MAPPING[tagName] &&
            ELEMENT_ATTRIBUTE_MAPPING[tagName][attribute.name]) ||
          ATTRIBUTE_MAPPING[attribute.name] ||
          attribute.name;
        var result = name;

        // Numeric values should be output as {123} not "123"
        if (isNumeric(attribute.value)) {
          result += '={' + attribute.value + '}';
        } else if (attribute.value.length > 0) {
          result += '="' + attribute.value.replace(/"/gm, '&quot;') + '"';
        }
        return result;
    }
  }
994542
public function getAttribute($attributeName)
    {
        // init
        $result = null;

        // action
        foreach ($this->attributes as $attribute) {
            if ($attribute->Name == $attributeName) {
                $result = $attribute;
                break;
            }
        }

        // --- result ---
        return $result;
    }
1006865
function(name) {
      var props = this.jCal[PROPERTY_INDEX];
      var len = props.length;

      var i = 0;
      for (; i < len; i++) {
        // 0 is property name
        if (props[i][NAME_INDEX] === name) {
          return true;
        }
      }

      return false;
    }
361625
function getAttribute(node, attrName) {
	attrName = attrName.toLowerCase();
	return node && node.open.attributes.find(attr => attr.name.value.toLowerCase() === attrName);
}