Add an output parameter description to the call info.
766409
def addOutParameter(self, name, type, namespace=None, element_type=0):
        """"""
        parameter = ParameterInfo(name, type, namespace, element_type)
        self.outparams.append(parameter)
        return parameter
526919
def append_stat_var(self, name, get_func):
        
        self._stats_getters.append(get_func)
        self._stats_logline += '%s: {}. ' % name
        self._stats_logline_totals += 'Total %s: {}. ' % name
948074
public void printCommandInfo(CommandInfo info) {
        final PrintContext context = new PrintContext();

        // Print command name : description
        final CliCommand command = info.getCommand();
        printIdentifiable(context, command);

        // Print bound params.
        final BoundParams boundParams = info.getBoundParams();
        printBoundParams(context, command, boundParams);
    }
966232
def _put_output(self, output: Optional[str]) -> None:
        """"""
        if output is None:
            self._argv.extend(["-f", "null", "-"])
            return

        output_cmd = shlex.split(str(output))
        if len(output_cmd) > 1:
            self._argv.extend(output_cmd)
        else:
            self._argv.append(output)
670284
def add_info(self, key, val, ignore_errors=False):
    """"""
    self.add_infos((key, val), ignore_errors=ignore_errors)
893186
def set_transform_interface_params(spec, input_features, output_features, are_optional = False):
    
    input_features = _fm.process_or_validate_features(input_features)
    output_features = _fm.process_or_validate_features(output_features)

    # Add input and output features
    for (fname, ftype) in input_features:
        input_ = spec.description.input.add()
        input_.name = fname
        datatypes._set_datatype(input_.type, ftype)
        if are_optional:
            input_.type.isOptional = are_optional

    for (fname, ftype) in output_features:
        output_ = spec.description.output.add()
        output_.name = fname
        datatypes._set_datatype(output_.type, ftype)

    return spec
1259128
public void infof(Throwable t, String format, Object... params) {
        doLogf(Level.INFO, FQCN, format, params, t);
    }
1026055
private void addMethodInfo(MethodDoc method, Content dl) {
        ClassDoc[] intfacs = method.containingClass().interfaces();
        MethodDoc overriddenMethod = method.overriddenMethod();
        // Check whether there is any implementation or overridden info to be
        // printed. If no overridden or implementation info needs to be
        // printed, do not print this section.
        if ((intfacs.length > 0 &&
                new ImplementedMethods(method, this.configuration).build().length > 0) ||
                overriddenMethod != null) {
            MethodWriterImpl.addImplementsInfo(this, method, dl);
            if (overriddenMethod != null) {
                MethodWriterImpl.addOverridden(this,
                        method.overriddenType(), overriddenMethod, dl);
            }
        }
    }
162698
function () {
        var prefix = 'INFO';
        this.output(prefix, prefix.green, Array.prototype.slice.call(arguments));
    }
876757
def setOutputObject(self, newOutput=output.CalcpkgOutput(True, True)):
		""""""
		self.output = newOutput
272129
def present_params(paramlist, spacing = 0, maxchars=90, linecont=", &"):
    """"""
    #The +2 is spacing is for the tab indent at the start of the line.
    #The +3 is for indent and the extra parenthesis at the start of the call.
    line = []
    length = 0
    result = []

    for param in paramlist:
        extra = len(list(param))
        if length + extra + 2 + spacing > maxchars:
            result.append(", ".join(line) + linecont)
            line = [ param ]
            length = extra + 2
        else:
            line.append(param)
            length += extra + 2

    #Add on the remaining bits of the line
    result.append(", ".join(line))

    return "\n{}".format(" ".join([ "" for i in range(spacing + 3)])).join(result)
442667
def add_parameter(self, param_name, description=None, default=0, unit=None):
        

        if description is None:
            description = "Parameter called {}".format(param_name)

        if unit is None:
            unit = "-"
        
        name_check = lambda x: x['name'] == param_name
        name_check_list = list(filter(name_check, self.ext_params))
        if len(name_check_list) == 0:
            self.ext_params.append({'name': param_name, 'description': description, 'default': default, 'unit': unit})
        else:
            print('{} already exists - choose a different name'.format(param_name))
1115736
def add_description(method):
    """"""

    @wraps(method)
    def wrapped(self, node, *args):
        return join([node.description, method(self, node, *args)], "\n")

    return wrapped
48148
def cli_info(data, title='Info'):
    '''
    
    '''

    wrapper = textwrap.TextWrapper()
    wrapper.initial_indent = ' ' * 4
    wrapper.subsequent_indent = wrapper.initial_indent

    return '{title}:\n\n{text}'.format(title=title, text=wrapper.fill(data))
832547
def output_contact_info(gandi, data, output_keys, justify=10):
    """"""
    for key in output_keys:
        if data[key]:
            output_line(gandi, key, data[key]['handle'], justify)
1244698
def write_output(self):
        """"""
        for data in self.output_data.values():
            self.create_output(data.get('key'), data.get('value'), data.get('type'))
1312149
def add_parameter(self, parameter):
        """"""
        if parameter.name.lower() not in self.paramorder:
            self.paramorder.append(parameter.name.lower())
        self._parameters[parameter.name.lower()] = parameter