If the map has a define serializer for the given attr, run it.
3418
function(map, attr, val) {
	var serializer = attr === "*" ? false : getPropDefineBehavior("serialize", attr, map.define);
	if (serializer === undefined) {
		return oldSingleSerialize.call(map, attr, val);
	} else if (serializer !== false) {
		return typeof serializer === "function" ? serializer.call(map, val, attr) : oldSingleSerialize.call(map, attr, val);
	}
}
53675
private static boolean mapsDiffer(Map last, Map attrs) {
        if (last == null) {
            return (attrs != null && attrs.size() > 0);
        }
        return (!last.equals(attrs));
    }
936847
public void addAttr(String attr, Object val) throws NamingException {
//  System.out.println("addAttr " + attr);

    Attribute a = findAttr(attr);

    if (a == null) {
      setAttr(attr, val);
    } else {
      a.add(val);
    }
  }
473479
def rsetattr(obj, name, value):
    """"""

    # See goo.gl/BVJ7MN
    path = name.split('.')
    setattr(reduce(getattr, path[:-1], obj), path[-1], value)
685280
def _required_attr(self, attr, key):
        """"""
        assert isinstance(attr, dict)
        if key not in attr:
            raise AttributeError("Required attribute {} not found.".format(key))
        return attr[key]
498556
def active_serialize_add *attrs, named: nil, to: nil, group: nil
      active_serialize_map attrs[0] => named if named
      return _active_serialize[:groups][group] = attrs.map(&:to_sym) if group
      _active_serialize[to || :add].concat attrs.map(&:to_sym)
    end
1275554
def use_model_attr(attr):
    """"""

    def use_model_validator(instance, attribute, value):
        getattr(instance, attr)(instance, attribute, value)
    return use_model_validator
374757
static private void astifyMap(StringBuilder strb, java.util.Map<?,?> map) {
    strb.append("{");
    if (map != null && map.size() > 0) {
      boolean isFirst = true;
      for (java.util.Map.Entry<?, ?> entry: map.entrySet()) {
        if (isFirst) {
          isFirst = false;
        } else {
          strb.append(", ");
        }
        strb.append("\"");
        strb.append(entry.getKey().toString());
        strb.append("\"");
        strb.append(":");
        astifyObject(strb, entry.getValue());
      }
    }
    strb.append("}");
  }
264142
def mock_attr(self, *args, **kwargs):
        
        self.path.extend(args)
        self.qs.update(kwargs)
        return self
11041
function getAttrMap(attrs)
{
	var i;
	var map = {};
	var numAttrs = attrs.length;
	
	for (i=0; i<numAttrs; i++)
	{
		map[ attrs[i].name ] = attrs[i].value;
	}
	
	return map;
}
488300
def hasattr(self, attr, ns=None):
        
        if not self.__attributes:
            self.setAttributeDictionary()
        if ns:
            return self.__attributes.get(ns,{}).has_key(attr)
        return self.__attributes.has_key(attr)
1241868
def attr(key, value=None):
    '''
    
    '''
    key = target(key)

    if key is False:
        return False
    elif os.path.isdir(key):
        return key
    elif value is not None:
        return write(key, value)
    else:
        return read(key)
444822
public void setAttributeMap( Map savedAttrs )
    {
        assert savedAttrs != null : "Map of attributes must be non-null";

        Map currentAttrs = _scopedContainer.getAttrMap();

        Map attrs = new HashMap();
        attrs.putAll( savedAttrs );

        if ( currentAttrs != null )
        {
            attrs.putAll( currentAttrs );
        }

        _scopedContainer.setAttrMap( attrs  );
    }
662634
def _wrap_attribute(self, attr):
        """"""
        if not attr:
            const = const_factory(attr)
            const.parent = self
            return const
        return attr
804847
private String _serializeMap(String name, Map map, StringBuilder sb, Set<Object> done) throws ConverterException {

	if (useShortcuts) sb.append("{}");
	else sb.append("new Object();");
	Iterator it = map.keySet().iterator();
	while (it.hasNext()) {
	    Object key = it.next();
	    String skey = StringUtil.toLowerCase(StringUtil.escapeJS(key.toString(), '"'));
	    sb.append(name + "[" + skey + "]=");
	    _serialize(name + "[" + skey + "]", map.get(key), sb, done);
	    // sb.append(";");
	}
	return sb.toString();
    }
551456
def run(self, **kwargs):
        """"""
        if 'timestamp' not in kwargs:
            kwargs['timestamp'] = datetime.datetime.utcnow().isoformat()
        if 'version' not in kwargs:
            kwargs['version'] = "Not Defined" #bibcat.__version__
        # log.debug("kwargs: %s", pprint.pformat({k:v for k, v in kwargs.items()
        #                                         if k != "dataset"}))
        # log.debug("parents: %s", self.parents)
        for map_key, triple_map in self.triple_maps.items():
            if map_key not in self.parents:
                self.execute(triple_map, **kwargs)
246753
def map_run(self, path=None, **kwargs):
        '''
        
        '''
        kwarg = {}
        if path:
            kwarg['map'] = path
        kwarg.update(kwargs)
        mapper = salt.cloud.Map(self._opts_defaults(**kwarg))
        dmap = mapper.map_data()
        return salt.utils.data.simple_types_filter(
            mapper.run_map(dmap)
        )