Update a space
@param  {String|Integer} spaceIdentifier A Robin space identifier
@param  {Object}         data            A data object
@return {Function}                       A promise
18760
function (spaceIdentifier, data) {
    var path;
    if (data) {
      path = this.constructPath(constants.SPACES, spaceIdentifier);
      return this.Core.PATCH(path, data);
    } else {
      return this.rejectRequest('Bad Request: Space data is required');
    }
  }
42839
protected void removeLocalSpaceDefinition(SpaceID id, boolean isLocalDestruction) {
		final Space space;
		synchronized (getSpaceRepositoryMutex()) {
			space = this.spaces.remove(id);
			if (space != null) {
				this.spacesBySpec.remove(id.getSpaceSpecification(), id);
			}
		}
		if (space != null) {
			fireSpaceRemoved(space, isLocalDestruction);
		}
	}
1125719
function setDataRegistry(data) {
  assertType(data, 'object', false, 'Invalid data specified');
  if (!window.__private__) window.__private__ = {};
  window.__private__.dataRegistry = data;
}
1186806
function update (data) {
    this.bind()
    this.length = data.length
    this.byteLength = this.length * data.BYTES_PER_ELEMENT
    this.gl.bufferData(this.type, data, this.usage)
  }
1136947
function (identifier) {
            var self = this;

            return self.needByIdentifier(identifier)
                .then(function (record) {
                    return self.destroy(
                       record.id
                    ).then(function (records) {
                        return records[0];
                    });
                });
        }
419720
function runPluginWithIdentifier (pluginName, identifier, options = {}) {
  const pluginFolderPath = options.dir || pluginFolder();

  // Append `.sketchplugin` if not passed in with the plugin name
  if (!pluginName.endsWith('.sketchplugin')) {
    pluginName += '.sketchplugin';
  }
  const pluginPath = `${pluginFolderPath}/${pluginName}`;

  // Check if the plugin actually exists before running anything!
  const exists = fs.existsSync(pluginPath);
  invariant(
    exists,
    `Plugin '${pluginPath}' not found! Cannot run plugin command!`
  );

  let args = '';

  if (options.context) {
    args += `--context='${JSON.stringify(options.context)}' `;
  }

  sketchtoolExec(`run ${escape(pluginPath)} ${identifier} ${args}`);
}
825738
private boolean spaceExists(final StorageProvider store,
                                final String spaceId)
        throws TaskExecutionFailedException {
        try {
            return new Retrier().execute(new Retriable() {
                @Override
                public Boolean retry() throws Exception {
                    // The actual method being executed
                    store.getSpaceProperties(spaceId);
                    return true;
                }
            });
        } catch (NotFoundException nfe) {
            return false;
        } catch (Exception e) {
            String msg = "Error attempting to check if space exists: " +
                         e.getMessage();
            throw new DuplicationTaskExecutionFailedException(
                buildFailureMessage(msg), e);
        }
    }
413209
function (channelIdentifier, data) {
      var path;
      if (channelIdentifier) {
        path = this.constructPath(constants.CHANNELS, channelIdentifier, constants.TRIGGERS);
        return this.Core.POST(path, data);
      } else {
        return this.rejectRequest('Bad Request: A channel identifier and a data object are required.');
      }
    }
161312
func (s *SpacesService) Update(spaceID uint, space *Space) (*http.Response, error) {
	u := fmt.Sprintf("spaces/%d", spaceID)
	req, err := s.client.NewRequest("PUT", u, space)
	if err != nil {
		return nil, err
	}

	return s.client.Do(req, nil)
}
869002
public function updateWallet($identifier, $data) {
        $response = $this->blocktrailClient->post("wallet/{$identifier}", null, $data, RestClient::AUTH_HTTP_SIG);
        return self::jsonDecode($response->body(), true);
    }
906268
protected void removeDefaultSpaceDefinition(SpaceID spaceID) {
		AgentContext context = null;
		synchronized (mutex()) {
			context = this.contexts.remove(spaceID.getContextID());
		}
		if (context != null) {
			fireContextDestroyed(context);
		}
	}
1186265
function verifyNamespace(namespace) {
	if (namespace && typeof namespace !== 'string') {
		const msg = util.format('Namespace must be a non-empty string: %j', namespace);
		logger.error('verifyNamespace:', msg);
		throw new Error(msg);
	}
}
567735
public void updateSpaceACLs(String spaceID,
                                Map<String, AclType> spaceACLs,
                                String storeID) throws ResourceException {
        try {
            StorageProvider storage = storageProviderFactory.getStorageProvider(
                storeID);
            if (null != spaceACLs) {
                storage.setSpaceACLs(spaceID, spaceACLs);
            }

        } catch (NotFoundException e) {
            throw new ResourceNotFoundException("update space ACLs for", spaceID, e);
        } catch (Exception e) {
            storageProviderFactory.expireStorageProvider(storeID);
            throw new ResourceException("update space ACLs for", spaceID, e);
        }
    }
1261822
public void updateFrameData(String id, byte[] data)
	{
		if (frames.containsKey(id))
		{
			((ID3v2Frame) frames.get(id)).setFrameData(data);
		}
		else
		{
			ID3v2Frame frame = new ID3v2Frame(id, data);
			frames.put(id, frame);
		}

		updateSize();
	}
140883
function identifier (options) {
  var result = ddata._identifier(options)
  return result ? options.fn(result) : 'ERROR, Cannot find identifier.'
}
1004358
synchronized void verifiedByClient(int namespaceId, Block block) {
    DataBlockScanner nsScanner = getNSScanner(namespaceId);
    if (nsScanner != null) {
      nsScanner.updateScanStatusUpdateOnly(block,
          DataBlockScanner.ScanType.REMOTE_READ, true);
    } else {
      LOG.warn("No namespace scanner found for namespaceId: " + nsScanner);
    }
  }
111264
func (s *Service) SpaceUpdate(ctx context.Context, spaceIdentity string, o SpaceUpdateOpts) (*Space, error) {
	var space Space
	return &space, s.Patch(ctx, &space, fmt.Sprintf("/spaces/%v", spaceIdentity), o)
}