add a result to the internal result list

        arguments:
            same arguments as for Result()
768174
def add_result(self, code, message=None):
        
        self._results.append(Result(code, message))
554769
def _merge_result(self, command, res, **kwargs):
        
        if command in self.result_callbacks:
            return self.result_callbacks[command](res, **kwargs)

        # Default way to handle result
        return first_key(res)
1182483
def exec_result(obj, local, stream):
    """"""
    local['_'] = obj
    if obj is not None:
        print(repr(obj), file=stream)
1373864
def add_result_hook(self, hook: Type["QueryResultHook"]) -> Type["QueryResultHook"]:
        
        hook.next_hook = self._query_result_hook
        self._query_result_hook = hook
        return hook
730894
private static void appendResult(int result, Appendable dest,
            int cpLength, int options, Edits edits) throws IOException {
        // Decode the result.
        if (result < 0) {
            // (not) original code point
            if (edits != null) {
                edits.addUnchanged(cpLength);
                if ((options & OMIT_UNCHANGED_TEXT) != 0) {
                    return;
                }
            }
            appendCodePoint(dest, ~result);
        } else if (result <= UCaseProps.MAX_STRING_LENGTH) {
            // The mapping has already been appended to result.
            if (edits != null) {
                edits.addReplace(cpLength, result);
            }
        } else {
            // Append the single-code point mapping.
            int length = appendCodePoint(dest, result);
            if (edits != null) {
                edits.addReplace(cpLength, length);
            }
        }
    }
123727
def result(self, result):
        
        if result and len(result[2]) > 0:
            self.errs.extend([((result[0], result[1]), err) for err in result[2]])
443581
def append_logs_to_result_object(result_obj, result):
    
    logs = result.has_logs()
    result_obj["exec"]["logs"] = []
    if logs and result.logfiles:
        for log in logs:
            typ = None
            parts = log.split(os.sep)
            if "bench" in parts[len(parts) - 1]:
                typ = "framework"
            # elif "Dut" in parts[len(parts)-1]:
            #    typ = "dut"

            if typ is not None:
                name = parts[len(parts) - 1]
                try:
                    with open(log, "r") as file_name:
                        data = file_name.read()
                    dic = {"data": data, "name": name, "from": typ}
                    result_obj["exec"]["logs"].append(dic)
                except OSError:
                    pass
            else:
                continue
182201
def add_output_arg(self, out):
        
        self.add_arg(out._dax_repr())
        self._add_output(out)
949797
def _add_result(self, dict_entry, entry, dt, start_time):
    
    time_entry = {}
    time_entry['dt'] = dt
    time_entry['start_time'] = start_time
    dict_entry[entry] = time_entry
654716
def _generate_result(self, callname, result):
        """"""
        # Retrieve path from API class
        schema = self.api.result_schema()
        schema.context['callname'] = callname
        self.callback(schema.load(result), self.context)
578398
def putResult(self, result):
        """"""
        self._lock_prev_output.acquire()
        for tube in self._tubes_result_output:
            tube.put((result, 0))
        self._lock_next_output.release()
673560
def move_to_result(self, lst_idx):
        """"""
        self.in_result_idx.add(lst_idx)

        if lst_idx in self.not_in_result_root_match_idx:
            self.not_in_result_root_match_idx.remove(lst_idx)
1013994
def add_result(result)
      raise "invalid result" unless result.class == ICU::Result
      raise "player number (#{@num}) is not matched to result player number (#{result.inspect})" unless @num == result.player
      already = @results.find_all { |r| r.round == result.round }
      return if already.size == 1 && already[0].eql?(result)
      raise "player #{@num} already has a result in round #{result.round} (#{already[0].inspect}) which does not match the one being added (#{result.inspect})" unless already.size == 0
      if @results.size == 0 || @results.last.round <= result.round
        @results << result
      else
        i = (0..@results.size-1).find { |n| @results[n].round > result.round }
        @results.insert(i, result)
      end
    end
110753
def add_result(self, values):
        
        idx = [values['host']]
        for gid in self.key_gids[1:]:
            idx.append(values[gid])
        idx = tuple(idx)

        try:
            self.results[idx] += 1
        except KeyError:
            self.results[idx] = 1
        self._last_idx = idx
1374379
def append_result(self, results, num_matches):
        """"""
        filename, lineno, colno, match_end, line = results

        if filename not in self.files:
            file_item = FileMatchItem(self, filename, self.sorting,
                                      self.text_color)
            file_item.setExpanded(True)
            self.files[filename] = file_item
            self.num_files += 1

        search_text = self.search_text
        title = "'%s' - " % search_text
        nb_files = self.num_files
        if nb_files == 0:
            text = _('String not found')
        else:
            text_matches = _('matches in')
            text_files = _('file')
            if nb_files > 1:
                text_files += 's'
            text = "%d %s %d %s" % (num_matches, text_matches,
                                    nb_files, text_files)
        self.set_title(title + text)

        file_item = self.files[filename]
        line = self.truncate_result(line, colno, match_end)
        item = LineMatchItem(file_item, lineno, colno, line, self.text_color)
        self.data[id(item)] = (filename, lineno, colno)
1332737
def merge_result(res):
    
    if not isinstance(res, dict):
        raise ValueError('Value should be of dict type')

    result = set([])

    for _, v in res.items():
        for value in v:
            result.add(value)

    return list(result)
478727
def add(self, *number):
        """"""
        return self._format_result(sum(
            # positional arguments are always strings
            [int(n) for n in number]))