Add an Accept option to a request.

        :param value: the Accept value
976718
def accept(self, value):
        
        if value in list(defines.Content_types.values()):
            option = Option()
            option.number = defines.OptionRegistry.ACCEPT.number
            option.value = value
            self.add_option(option)
745216
def setValue(self, value):
        
        self.__value = projex.text.decoded(value) if isinstance(value, (str, unicode)) else value
449379
public void accept(Acceptable<ClassInfo> accept) {
        try {
            boolean re = accept.accept(classInfo);
            if (!this.accept && re)
                this.accept = true;
        } catch (Exception e) {
            logger.error("class accept error", e);
        }
    }
916550
@Override
  public boolean accept(V value) {

    Boolean result = acceptRecursive(value);
    if (result == null) {
      return this.defaultResult;
    } else {
      return result.booleanValue();
    }
  }
786232
def setOption(self, key, value):
    
    self.send_setOption(key, value)
    self.recv_setOption()
503643
public void addValue(int... value) {
        /* no-op if disabled */
        if (!enabled.get())
            return;

        for (int v : value) {
            try {
                getCurrentBucket().data.addValue(v);
            } catch (Exception e) {
                logger.error("Failed to add value: " + v, e);
            }
        }
    }
76234
def allow(cls, action, **kwargs):
        
        return cls.create(action, exclude=False, **kwargs)
296390
def browser_attach_timeout(self, value):
        
        if not isinstance(value, int):
            raise ValueError('Browser Attach Timeout must be an integer.')
        self._options[self.BROWSER_ATTACH_TIMEOUT] = value
183766
def push(self, value):
        

        stream = DataStream.FromEncoded(value.stream)

        if stream.stream_type == DataStream.OutputType:
            if len(self.streaming_data) == self.streaming_length:
                raise StorageFullError('Streaming buffer full')

            self.streaming_data.append(value)
        else:
            if len(self.storage_data) == self.storage_length:
                raise StorageFullError('Storage buffer full')

            self.storage_data.append(value)
857823
public static AcceptStatus fromValue(int value) {
        AcceptStatus status = VALUES.get(value);
        if (status == null) {
            status = new AcceptStatus(value);
            VALUES.put(value, status);
        }
        return status;
    }
211335
public Request option(String key, Object value) {
        this.options.put(key, value);
        return this;
    }
597557
def propose_value(self, value):
        '''
        
        '''
        if self.proposed_value is None:
            self.proposed_value = value

            if self.leader:
                self.current_accept_msg = Accept(self.network_uid, self.proposal_id, value)
                return self.current_accept_msg
438862
protected void addValidValue(String value)
	{
		if(value!=null && !value.isEmpty())
			validValues.add(value.toLowerCase());
	}
964997
def accept(self, match=None, match_dict=None, include_rejected=False, include_denied=False):
        '''
        
        '''
        if match is not None:
            matches = self.name_match(match)
        elif match_dict is not None and isinstance(match_dict, dict):
            matches = match_dict
        else:
            matches = {}
        keydirs = [self.PEND]
        if include_rejected:
            keydirs.append(self.REJ)
        if include_denied:
            keydirs.append(self.DEN)
        for keydir in keydirs:
            for key in matches.get(keydir, []):
                try:
                    shutil.move(
                            os.path.join(
                                self.opts['pki_dir'],
                                keydir,
                                key),
                            os.path.join(
                                self.opts['pki_dir'],
                                self.ACC,
                                key)
                            )
                    eload = {'result': True,
                             'act': 'accept',
                             'id': key}
                    self.event.fire_event(eload,
                                          salt.utils.event.tagify(prefix='key'))
                except (IOError, OSError):
                    pass
        return (
            self.name_match(match) if match is not None
            else self.dict_match(matches)
        )
1250340
public ListParameterization addParameter(OptionID optionid, Object value) {
    parameters.add(new ParameterPair(optionid, value));
    return this;
  }
211834
async def request(self, value: Any) -> Any:
        
        await self.send(value)
        return await self.recv()
233558
def put(self, value):
        
        io_loop = IOLoop.current()
        new_hole = Future()

        new_put = Future()
        new_put.set_result(new_hole)

        with self._lock:
            self._put, put = new_put, self._put

        answer = Future()

        def _on_put(future):
            if future.exception():  # pragma: no cover (never happens)
                return answer.set_exc_info(future.exc_info())

            old_hole = put.result()
            old_hole.set_result(Node(value, new_hole))
            answer.set_result(None)

        io_loop.add_future(put, _on_put)
        return answer