Sets the exportFormat value for this ReportDownloadOptions.

@param exportFormat   * The {@link ExportFormat} used to generate the report.
Default value is {@link ExportFormat#CSV_DUMP}.
423961
public void setExportFormat(com.google.api.ads.admanager.axis.v201902.ExportFormat exportFormat) {
        this.exportFormat = exportFormat;
    }
1034454
public void setExportOnlyColumns(final String[] exportOnlyColumns) {
        if (exportOnlyColumns != null) {
            this.exportOnlyColumns = exportOnlyColumns.clone();
        } else {
            this.exportOnlyColumns = null;
        }
    }
483220
@Override
    public List<ExportFormat> exportFormats(IssueServiceConfiguration issueServiceConfiguration) {
        return issueExportServiceFactory.getIssueExportServices().stream()
                .map(IssueExportService::getExportFormat)
                .collect(Collectors.toList());
    }
1077138
public void setExportsInfo(java.util.Collection<ExportInfo> exportsInfo) {
        if (exportsInfo == null) {
            this.exportsInfo = null;
            return;
        }

        this.exportsInfo = new java.util.ArrayList<ExportInfo>(exportsInfo);
    }
1355670
public void setPathFormat(String pathFormat)
    throws ConfigException
  {
    _pathFormat = pathFormat;

    if (pathFormat.endsWith(".zip")) {
      throw new ConfigException(L.l(".zip extension to path-format is not supported."));
    }
  }
250929
public void setDisplayFormatters(Object displayFormatters) {

        if (displayFormatters instanceof List) {
            for (Object formatterItem : ((List<?>)displayFormatters)) {
                if (formatterItem instanceof CmsJspContentAccessValueWrapper) {
                    addFormatter((CmsJspContentAccessValueWrapper)formatterItem);
                }
            }
        } else if (displayFormatters instanceof CmsJspContentAccessValueWrapper) {
            addFormatter((CmsJspContentAccessValueWrapper)displayFormatters);
        } else if (displayFormatters instanceof String) {
            String[] temp = ((String)displayFormatters).split(CmsXmlDisplayFormatterValue.SEPARATOR);
            if (temp.length == 2) {
                addDisplayFormatter(temp[0], temp[1]);
            }
        }
    }
1239823
public void setExportPath(String exportPath) {

        if (exportPath.equals(OpenCms.getSystemInfo().getWebApplicationRfsPath())) {
            // not allowed because a full static export would delete the opencms directory
            throw new CmsIllegalArgumentException(Messages.get().container(Messages.ERR_INVALID_EXPORT_PATH_1, m_name));
        }
        m_exportPath = exportPath;
    }
1096096
public void setExportHeader(String exportHeader) {

        if (CmsStringUtil.splitAsArray(exportHeader, ':').length == 2) {
            if (CmsLog.INIT.isInfoEnabled()) {
                CmsLog.INIT.info(Messages.get().getBundle().key(Messages.INIT_EXPORT_HEADERS_1, exportHeader));
            }
            m_exportHeaders.add(exportHeader);
        } else {
            if (CmsLog.INIT.isWarnEnabled()) {
                CmsLog.INIT.warn(Messages.get().getBundle().key(Messages.INIT_INVALID_HEADER_1, exportHeader));
            }
        }
    }
568179
public void setCreativeFormat(com.google.api.ads.admanager.axis.v201902.RichMediaStudioCreativeFormat creativeFormat) {
        this.creativeFormat = creativeFormat;
    }
1028350
public function setOutputFormat($outputFormat)
    {
        $allowedFormats = array(
            'xml/rdf',
            'text/simple',
            'text/microformats',
            'application/json',
            'text/n3'
        );

        if (!in_array(strtolower($outputFormat), $allowedFormats)) {
            throw new \InvalidArgumentException(
                "Illegal output format, allowed output formats are " . implode(', ', $allowedFormats)
            );
        }
        $this->outputFormat = $outputFormat;

        return $this;
    }
19708
public function setOutputFormat($outputFormat)
    {
        if (! $this->isValidOutputFormat($outputFormat)) {
            throw new InvalidFormat("Format {$outputFormat} is not supported");
        }

        $this->outputFormat = $outputFormat;

        return $this;
    }
343605
function setFormat(format) {
            if (format === null || format === undefined) {
                throw new Error("Format is not defined " + this.clazz.$name);
            }

            if (this.format !== format) {
                this.format = format;
                this.$getSuper("setValue").call(this, this.$format(this.date));
            }

            return this;
        }
1148072
public static FormatterBuilder createFormatterBuilder(Properties formatterProperties) throws Exception {

        FormatterBuilder builder;
        AbstractFormatterFactory factory;

        if (formatterProperties.size() > 0) {
            String formatterClass = formatterProperties.getProperty("formatter");
            String format = formatterProperties.getProperty("format", "csv");
            Class<?> classz = Class.forName(formatterClass);
            Class<?>[] ctorParmTypes = new Class[]{ String.class, Properties.class };
            Constructor<?> ctor = classz.getDeclaredConstructor(ctorParmTypes);
            Object[] ctorParms = new Object[]{ format, formatterProperties };

            factory = new AbstractFormatterFactory() {
                @Override
                public Formatter create(String formatName, Properties props) {
                    try {
                        return (Formatter) ctor.newInstance(ctorParms);
                    }
                    catch (Exception e) {
                        VoltDB.crashLocalVoltDB("Failed to create formatter " + formatName);
                        return null;
                    }

                }
            };
            builder = new FormatterBuilder(format, formatterProperties);
        } else {
            factory = new VoltCSVFormatterFactory();
            Properties props = new Properties();
            factory.create("csv", props);
            builder = new FormatterBuilder("csv", props);
        }

        builder.setFormatterFactory(factory);
        return builder;
    }
515644
private void configureInputFormat(CsvInputFormat<?> format) {
		format.setCharset(this.charset);
		format.setDelimiter(this.lineDelimiter);
		format.setFieldDelimiter(this.fieldDelimiter);
		format.setCommentPrefix(this.commentPrefix);
		format.setSkipFirstLineAsHeader(skipFirstLineAsHeader);
		format.setLenient(ignoreInvalidLines);
		if (this.parseQuotedStrings) {
			format.enableQuotedStringParsing(this.quoteCharacter);
		}
	}
271427
public void setArchiveFormat(String format)
  {
    if (format.endsWith(".gz")) {
      _archiveFormat = format.substring(0, format.length() - ".gz".length());
      _archiveSuffix = ".gz";
    }
    else if (format.endsWith(".zip")) {
      _archiveFormat = format.substring(0, format.length() - ".zip".length());
      _archiveSuffix = ".zip";
    }
    else {
      _archiveFormat = format;
      _archiveSuffix = "";
    }
  }
859615
@OptionDesc(longName = "output", shortName = "o",
			description = "write output to FILE instead of stdout",
			argumentName = "FILE", argumentType = ArgumentType.STRING)
	public void setOutputFile(String outputFile) {
		this.outputFile = outputFile;
	}
801634
@FFDCIgnore(value = { Exception.class })
    public void setSimpleDateFormat(String formatString) {
        if (formatString == null) {
            if (tc.isDebugEnabled()) {
                Tr.debug(tc, "Null format string provided; date format will not be changed");
            }
            return;
        }
        try {
            simpleDateFormat = new SimpleDateFormat(formatString);
        } catch (Exception e) {
            if (tc.isDebugEnabled()) {
                Tr.debug(tc, "Exception caught setting date format: " + e.getMessage());
                Tr.debug(tc, "Date format will not be changed");
            }
        }
    }