Responsible for handling the addition and/or removal of properties
 defined on the resource through a PROPPATCH request (see section 9.2 of
 RFC4918).

 Used in PROPPATCH requests.
776511
def proppatch(nodes)
      init_pstore unless exists?

      actions = { set: [], remove: [] }

      @store.transaction do
        @store[:properties] = {} unless @store[:properties].is_a? Hash

        add_remove_properties nodes, actions
      end

      get_custom_property nil
      actions
    end
1107609
def project_set_properties(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/setProperties' % object_id, input_params, always_retry=always_retry, **kwargs)
578770
function (layer, props) {
		if (props.handle || objectContainsPathCoords(props)) {
			// Add handles if handle property was added
			removeHandles(layer);
			addHandles(layer);
		} else if (props.handle === null) {
			removeHandles(layer);
		}
		if (isRectLayer(layer)) {
			// If width/height was changed
			if (props.width !== undefined || props.height !== undefined || props.x !== undefined || props.y !== undefined) {
				// Update handle positions
				updateRectHandles(layer);
			}
		} else if (isPathLayer(layer)) {
			updatePathHandles(layer);
		}

	}
1188896
function handleProtocol(schema, value, prop) {
    var protocols = schema.protocols
    var protocol
    var first
    var colon
    var length
    var index

    protocols = own.call(protocols, prop) ? protocols[prop].concat() : []

    if (protocols.length === 0) {
        return true
    }

    value = String(value)
    first = value.charAt(0)

    if (first === '#' || first === '/') {
        return true
    }

    colon = value.indexOf(':')

    if (colon === -1) {
        return true
    }

    length = protocols.length
    index = -1

    while (++index < length) {
        protocol = protocols[index]

        if (
            colon === protocol.length &&
            value.slice(0, protocol.length) === protocol
        ) {
            return true
        }
    }

    index = value.indexOf('?')

    if (index !== -1 && colon > index) {
        return true
    }

    index = value.indexOf('#')

    if (index !== -1 && colon > index) {
        return true
    }

    return false
}
1135491
protected void modified(Map<?, ?> properties) {
        if (properties instanceof Dictionary) {
            processConfig((Dictionary<?, ?>) properties);
        } else {
            Dictionary<?, ?> newconfig = new Hashtable<Object, Object>(properties);
            processConfig(newconfig);
        }
    }
105933
protected static <K, V> void addOrRemoveProperty(Map<K, V> props, K key, V value)
    {
        if (value == null) {
            // Generic properties have already been added to the map.  Remove them
            // so they aren't confused with the builtin properties.
            props.remove(key);
        } else {
            props.put(key, value);
        }
    }
95542
protected void handleProperty(final String name, final LexicalUnit value,
            final boolean important, final Locator locator) {
        getDocumentHandler().property(name, value, important, locator);
    }
981575
private void handleChangeConfigurationRequest(final int executorId, final String actionName,
      final HttpServletRequest req, final HashMap<String, Object> ret)
      throws ServletException, IOException {
    try {
      final Map<String, Object> result =
          this.execManagerAdapter
              .callExecutorStats(executorId, actionName, getAllParams(req));
      if (result.containsKey(ConnectorParams.RESPONSE_ERROR)) {
        ret.put(ConnectorParams.RESPONSE_ERROR,
            result.get(ConnectorParams.RESPONSE_ERROR).toString());
      } else {
        ret.put(ConnectorParams.STATUS_PARAM,
            result.get(ConnectorParams.STATUS_PARAM));
      }
    } catch (final ExecutorManagerException ex) {
      logger.error(ex.getMessage(), ex);
      ret.put("error", "Failed to change config change");
    }
  }
279717
def proppatch(path, body, initheader = nil)
      request(Proppatch.new(path, initheader), body)
    end
625123
public void executePropertyModification(CmsPropertyModification propMod) {

        CmsClientSitemapEntry entry = getEntryById(propMod.getId());
        if (entry != null) {
            Map<String, CmsClientProperty> props = getPropertiesForId(propMod.getId());
            if (props != null) {
                propMod.updatePropertyInMap(props);
                entry.setOwnProperties(props);
            }
        }
    }
400434
@SuppressWarnings("unchecked")
    protected void modified(Map<?, ?> newProperties) {
        if (newProperties instanceof Dictionary) {
            _props = (Dictionary<String, Object>) newProperties;
        } else {
            _props = new Hashtable(newProperties);
        }
    }
83767
protected void modified(ComponentContext context) {
        Dictionary<String, ?> newProperties = context.getProperties();
        modified(newProperties, true);
    }
1141466
private void handleConref() {
        // Get pure conref targets
        final Set<URI> pureConrefTargets = new HashSet<>(128);
        for (final URI target: conrefTargetSet) {
            if (!nonConrefCopytoTargetSet.contains(target)) {
                pureConrefTargets.add(target);
            }
        }
        conrefTargetSet = pureConrefTargets;

        // Remove pure conref targets from fullTopicSet
        fullTopicSet.removeAll(pureConrefTargets);
        // Treat pure conref targets same as resource-only
        resourceOnlySet.addAll(pureConrefTargets);
    }
1135755
function addMetaProperty (object, propName, value) {
  defineProperty(object, propName, {
    enumerable: false,
    value
  })
}
767843
protected void updateDirtyState() {
		boolean dirty = isDirty();
		if (oldDirty != dirty) {
			oldDirty = dirty;
			firePropertyChange(DIRTY_PROPERTY, !dirty, dirty);
		}
	}
424232
function defineProperty (key, handler, value) {
    Object.defineProperty(ctrl, key, {
      get: function () { return value; },
      set: function (newValue) {
        var oldValue = value;
        value        = newValue;
        handler && handler(newValue, oldValue);
      }
    });
  }
909526
private static void addRequestProperties(final Map<String, String> requestProperties, final HttpURLConnection connection) {
        if (requestProperties != null) {
            for (Entry<String, String> entry : requestProperties.entrySet()) {
                connection.addRequestProperty(entry.getKey(), entry.getValue());
            }
        }
    }