001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.camel.builder; 018 019 import java.util.Map; 020 import java.util.zip.Deflater; 021 022 import org.w3c.dom.Node; 023 024 import org.apache.camel.model.DataFormatDefinition; 025 import org.apache.camel.model.ProcessorDefinition; 026 import org.apache.camel.model.dataformat.AvroDataFormat; 027 import org.apache.camel.model.dataformat.Base64DataFormat; 028 import org.apache.camel.model.dataformat.BeanioDataFormat; 029 import org.apache.camel.model.dataformat.BindyDataFormat; 030 import org.apache.camel.model.dataformat.BindyType; 031 import org.apache.camel.model.dataformat.CastorDataFormat; 032 import org.apache.camel.model.dataformat.CsvDataFormat; 033 import org.apache.camel.model.dataformat.CustomDataFormat; 034 import org.apache.camel.model.dataformat.GzipDataFormat; 035 import org.apache.camel.model.dataformat.HL7DataFormat; 036 import org.apache.camel.model.dataformat.JaxbDataFormat; 037 import org.apache.camel.model.dataformat.JibxDataFormat; 038 import org.apache.camel.model.dataformat.JsonDataFormat; 039 import org.apache.camel.model.dataformat.JsonLibrary; 040 import org.apache.camel.model.dataformat.PGPDataFormat; 041 import org.apache.camel.model.dataformat.ProtobufDataFormat; 042 import org.apache.camel.model.dataformat.RssDataFormat; 043 import org.apache.camel.model.dataformat.SerializationDataFormat; 044 import org.apache.camel.model.dataformat.SoapJaxbDataFormat; 045 import org.apache.camel.model.dataformat.StringDataFormat; 046 import org.apache.camel.model.dataformat.SyslogDataFormat; 047 import org.apache.camel.model.dataformat.TidyMarkupDataFormat; 048 import org.apache.camel.model.dataformat.XMLBeansDataFormat; 049 import org.apache.camel.model.dataformat.XMLSecurityDataFormat; 050 import org.apache.camel.model.dataformat.XStreamDataFormat; 051 import org.apache.camel.model.dataformat.XmlJsonDataFormat; 052 import org.apache.camel.model.dataformat.ZipDataFormat; 053 import org.apache.camel.model.dataformat.ZipFileDataFormat; 054 import org.apache.camel.util.jsse.KeyStoreParameters; 055 056 /** 057 * An expression for constructing the different possible {@link org.apache.camel.spi.DataFormat} 058 * options. 059 * 060 * @version 061 */ 062 public class DataFormatClause<T extends ProcessorDefinition<?>> { 063 private final T processorType; 064 private final Operation operation; 065 066 /** 067 * {@link org.apache.camel.spi.DataFormat} operations. 068 */ 069 public enum Operation { 070 Marshal, Unmarshal 071 } 072 073 public DataFormatClause(T processorType, Operation operation) { 074 this.processorType = processorType; 075 this.operation = operation; 076 } 077 078 /** 079 * Uses the Avro data format 080 */ 081 public T avro() { 082 return dataFormat(new AvroDataFormat()); 083 } 084 085 public T avro(Object schema) { 086 AvroDataFormat dataFormat = new AvroDataFormat(); 087 dataFormat.setSchema(schema); 088 return dataFormat(dataFormat); 089 } 090 091 public T avro(String instanceClassName) { 092 return dataFormat(new AvroDataFormat(instanceClassName)); 093 } 094 095 /** 096 * Uses the base64 data format 097 */ 098 public T base64() { 099 Base64DataFormat dataFormat = new Base64DataFormat(); 100 return dataFormat(dataFormat); 101 } 102 103 /** 104 * Uses the base64 data format 105 */ 106 public T base64(int lineLength, String lineSeparator, boolean urlSafe) { 107 Base64DataFormat dataFormat = new Base64DataFormat(); 108 dataFormat.setLineLength(lineLength); 109 dataFormat.setLineSeparator(lineSeparator); 110 dataFormat.setUrlSafe(urlSafe); 111 return dataFormat(dataFormat); 112 } 113 114 /** 115 * Uses the beanio data format 116 */ 117 public T beanio(String mapping, String streamName) { 118 BeanioDataFormat dataFormat = new BeanioDataFormat(); 119 dataFormat.setMapping(mapping); 120 dataFormat.setStreamName(streamName); 121 return dataFormat(dataFormat); 122 } 123 124 /** 125 * Uses the beanio data format 126 */ 127 public T beanio(String mapping, String streamName, String encoding) { 128 BeanioDataFormat dataFormat = new BeanioDataFormat(); 129 dataFormat.setMapping(mapping); 130 dataFormat.setStreamName(streamName); 131 dataFormat.setEncoding(encoding); 132 return dataFormat(dataFormat); 133 } 134 135 /** 136 * Uses the beanio data format 137 */ 138 public T beanio(String mapping, String streamName, String encoding, 139 boolean ignoreUnidentifiedRecords, boolean ignoreUnexpectedRecords, boolean ignoreInvalidRecords) { 140 BeanioDataFormat dataFormat = new BeanioDataFormat(); 141 dataFormat.setMapping(mapping); 142 dataFormat.setStreamName(streamName); 143 dataFormat.setEncoding(encoding); 144 dataFormat.setIgnoreInvalidRecords(ignoreInvalidRecords); 145 dataFormat.setIgnoreUnexpectedRecords(ignoreUnexpectedRecords); 146 dataFormat.setIgnoreInvalidRecords(ignoreInvalidRecords); 147 return dataFormat(dataFormat); 148 } 149 150 /** 151 * Uses the Bindy data format 152 * 153 * @param type the type of bindy data format to use 154 * @param packages packages to scan for Bindy annotated POJO classes 155 */ 156 public T bindy(BindyType type, String... packages) { 157 BindyDataFormat bindy = new BindyDataFormat(); 158 bindy.setType(type); 159 bindy.setPackages(packages); 160 return dataFormat(bindy); 161 } 162 163 /** 164 * Uses the Bindy data format 165 * 166 * @param type the type of bindy data format to use 167 * @param classType the POJO class type 168 */ 169 public T bindy(BindyType type, Class<?> classType) { 170 BindyDataFormat bindy = new BindyDataFormat(); 171 bindy.setType(type); 172 bindy.setClassType(classType); 173 return dataFormat(bindy); 174 } 175 176 /** 177 * Uses the CSV data format 178 */ 179 public T csv() { 180 return dataFormat(new CsvDataFormat()); 181 } 182 183 /** 184 * Uses the CSV data format for a huge file. 185 * Sequential access through an iterator. 186 */ 187 public T csvLazyLoad() { 188 return dataFormat(new CsvDataFormat(true)); 189 } 190 191 /** 192 * Uses the custom data format 193 */ 194 public T custom(String ref) { 195 return dataFormat(new CustomDataFormat(ref)); 196 } 197 198 /** 199 * Uses the Castor data format 200 */ 201 public T castor() { 202 return dataFormat(new CastorDataFormat()); 203 } 204 205 /** 206 * Uses the Castor data format 207 * 208 * @param mappingFile name of mapping file to locate in classpath 209 */ 210 public T castor(String mappingFile) { 211 CastorDataFormat castor = new CastorDataFormat(); 212 castor.setMappingFile(mappingFile); 213 return dataFormat(castor); 214 } 215 216 /** 217 * Uses the Castor data format 218 * 219 * @param mappingFile name of mapping file to locate in classpath 220 * @param validation whether validation is enabled or not 221 */ 222 public T castor(String mappingFile, boolean validation) { 223 CastorDataFormat castor = new CastorDataFormat(); 224 castor.setMappingFile(mappingFile); 225 castor.setValidation(validation); 226 return dataFormat(castor); 227 } 228 229 /** 230 * Uses the GZIP deflater data format 231 */ 232 public T gzip() { 233 GzipDataFormat gzdf = new GzipDataFormat(); 234 return dataFormat(gzdf); 235 } 236 237 /** 238 * Uses the HL7 data format 239 */ 240 public T hl7() { 241 return dataFormat(new HL7DataFormat()); 242 } 243 244 /** 245 * Uses the HL7 data format 246 */ 247 public T hl7(boolean validate) { 248 HL7DataFormat hl7 = new HL7DataFormat(); 249 hl7.setValidate(validate); 250 return dataFormat(hl7); 251 } 252 253 /** 254 * Uses the HL7 data format 255 */ 256 public T hl7(Object parser) { 257 HL7DataFormat hl7 = new HL7DataFormat(); 258 hl7.setParser(parser); 259 return dataFormat(hl7); 260 } 261 262 /** 263 * Uses the PGP data format 264 */ 265 public T pgp(String keyFileName, String keyUserid) { 266 PGPDataFormat pgp = new PGPDataFormat(); 267 pgp.setKeyFileName(keyFileName); 268 pgp.setKeyUserid(keyUserid); 269 return dataFormat(pgp); 270 } 271 272 /** 273 * Uses the PGP data format 274 */ 275 public T pgp(String keyFileName, String keyUserid, String password) { 276 PGPDataFormat pgp = new PGPDataFormat(); 277 pgp.setKeyFileName(keyFileName); 278 pgp.setKeyUserid(keyUserid); 279 pgp.setPassword(password); 280 return dataFormat(pgp); 281 } 282 283 /** 284 * Uses the PGP data format 285 */ 286 public T pgp(String keyFileName, String keyUserid, String password, boolean armored, boolean integrity) { 287 PGPDataFormat pgp = new PGPDataFormat(); 288 pgp.setKeyFileName(keyFileName); 289 pgp.setKeyUserid(keyUserid); 290 pgp.setPassword(password); 291 pgp.setArmored(armored); 292 pgp.setIntegrity(integrity); 293 return dataFormat(pgp); 294 } 295 296 /** 297 * Uses the JAXB data format 298 */ 299 public T jaxb() { 300 return dataFormat(new JaxbDataFormat()); 301 } 302 303 /** 304 * Uses the JAXB data format with context path 305 */ 306 public T jaxb(String contextPath) { 307 JaxbDataFormat dataFormat = new JaxbDataFormat(); 308 dataFormat.setContextPath(contextPath); 309 return dataFormat(dataFormat); 310 } 311 312 /** 313 * Uses the JAXB data format turning pretty printing on or off 314 */ 315 public T jaxb(boolean prettyPrint) { 316 return dataFormat(new JaxbDataFormat(prettyPrint)); 317 } 318 319 /** 320 * Uses the JiBX data format. 321 */ 322 public T jibx() { 323 return dataFormat(new JibxDataFormat()); 324 } 325 326 /** 327 * Uses the JiBX data format with unmarshall class. 328 */ 329 public T jibx(Class<?> unmarshallClass) { 330 return dataFormat(new JibxDataFormat(unmarshallClass)); 331 } 332 333 /** 334 * Uses the JSON data format using the XStream json library 335 */ 336 public T json() { 337 return dataFormat(new JsonDataFormat()); 338 } 339 340 /** 341 * Uses the JSON data format 342 * 343 * @param library the json library to use 344 */ 345 public T json(JsonLibrary library) { 346 return dataFormat(new JsonDataFormat(library)); 347 } 348 349 /** 350 * Uses the JSON data format 351 * 352 * @param type the json type to use 353 * @param unmarshalType unmarshal type for json jackson type 354 */ 355 public T json(JsonLibrary type, Class<?> unmarshalType) { 356 JsonDataFormat json = new JsonDataFormat(type); 357 json.setUnmarshalType(unmarshalType); 358 return dataFormat(json); 359 } 360 361 /** 362 * Uses the JSON data format 363 * 364 * @param type the json type to use 365 * @param unmarshalType unmarshal type for json jackson type 366 * @param jsonView the view type for json jackson type 367 */ 368 public T json(Class<?> unmarshalType, Class<?> jsonView) { 369 JsonDataFormat json = new JsonDataFormat(JsonLibrary.Jackson); 370 json.setUnmarshalType(unmarshalType); 371 json.setJsonView(jsonView); 372 return dataFormat(json); 373 } 374 375 /** 376 * Uses the protobuf data format 377 */ 378 public T protobuf() { 379 return dataFormat(new ProtobufDataFormat()); 380 } 381 382 public T protobuf(Object defaultInstance) { 383 ProtobufDataFormat dataFormat = new ProtobufDataFormat(); 384 dataFormat.setDefaultInstance(defaultInstance); 385 return dataFormat(dataFormat); 386 } 387 388 public T protobuf(String instanceClassName) { 389 return dataFormat(new ProtobufDataFormat(instanceClassName)); 390 } 391 392 /** 393 * Uses the RSS data format 394 */ 395 public T rss() { 396 return dataFormat(new RssDataFormat()); 397 } 398 399 /** 400 * Uses the Java Serialization data format 401 */ 402 public T serialization() { 403 return dataFormat(new SerializationDataFormat()); 404 } 405 406 /** 407 * Uses the Soap 1.1 JAXB data format 408 */ 409 public T soapjaxb() { 410 return dataFormat(new SoapJaxbDataFormat()); 411 } 412 413 /** 414 * Uses the Soap 1.1 JAXB data format 415 */ 416 public T soapjaxb(String contextPath) { 417 return dataFormat(new SoapJaxbDataFormat(contextPath)); 418 } 419 420 /** 421 * Uses the Soap 1.1 JAXB data format 422 */ 423 public T soapjaxb(String contextPath, String elementNameStrategyRef) { 424 return dataFormat(new SoapJaxbDataFormat(contextPath, elementNameStrategyRef)); 425 } 426 427 /** 428 * Uses the Soap 1.1 JAXB data format 429 */ 430 public T soapjaxb(String contextPath, Object elementNameStrategy) { 431 return dataFormat(new SoapJaxbDataFormat(contextPath, elementNameStrategy)); 432 } 433 434 /** 435 * Uses the Soap 1.2 JAXB data format 436 */ 437 public T soapjaxb12() { 438 SoapJaxbDataFormat soap = new SoapJaxbDataFormat(); 439 soap.setVersion("1.2"); 440 return dataFormat(soap); 441 } 442 443 /** 444 * Uses the Soap 1.2 JAXB data format 445 */ 446 public T soapjaxb12(String contextPath) { 447 SoapJaxbDataFormat soap = new SoapJaxbDataFormat(contextPath); 448 soap.setVersion("1.2"); 449 return dataFormat(soap); 450 } 451 452 /** 453 * Uses the Soap 1.2 JAXB data format 454 */ 455 public T soapjaxb12(String contextPath, String elementNameStrategyRef) { 456 SoapJaxbDataFormat soap = new SoapJaxbDataFormat(contextPath, elementNameStrategyRef); 457 soap.setVersion("1.2"); 458 return dataFormat(soap); 459 } 460 461 /** 462 * Uses the Soap JAXB data format 463 */ 464 public T soapjaxb12(String contextPath, Object elementNameStrategy) { 465 SoapJaxbDataFormat soap = new SoapJaxbDataFormat(contextPath, elementNameStrategy); 466 soap.setVersion("1.2"); 467 return dataFormat(soap); 468 } 469 470 /** 471 * Uses the String data format 472 */ 473 public T string() { 474 return string(null); 475 } 476 477 /** 478 * Uses the String data format supporting encoding using given charset 479 */ 480 public T string(String charset) { 481 StringDataFormat sdf = new StringDataFormat(); 482 sdf.setCharset(charset); 483 return dataFormat(sdf); 484 } 485 486 /** 487 * Uses the Syslog data format 488 */ 489 public T syslog() { 490 return dataFormat(new SyslogDataFormat()); 491 } 492 493 /** 494 * Return WellFormed HTML (an XML Document) either 495 * {@link java.lang.String} or {@link org.w3c.dom.Node} 496 */ 497 public T tidyMarkup(Class<?> dataObjectType) { 498 return dataFormat(new TidyMarkupDataFormat(dataObjectType)); 499 } 500 501 /** 502 * Return TidyMarkup in the default format 503 * as {@link org.w3c.dom.Node} 504 */ 505 public T tidyMarkup() { 506 return dataFormat(new TidyMarkupDataFormat(Node.class)); 507 } 508 509 /** 510 * Uses the XStream data format 511 */ 512 public T xstream() { 513 return dataFormat(new XStreamDataFormat()); 514 } 515 516 /** 517 * Uses the xstream by setting the encoding 518 */ 519 public T xstream(String encoding) { 520 return dataFormat(new XStreamDataFormat(encoding)); 521 } 522 523 /** 524 * Uses the XML Security data format 525 */ 526 public T secureXML() { 527 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(); 528 return dataFormat(xsdf); 529 } 530 531 /** 532 * Uses the XML Security data format 533 */ 534 public T secureXML(String secureTag, boolean secureTagContents) { 535 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, secureTagContents); 536 return dataFormat(xsdf); 537 } 538 539 /** 540 * Uses the XML Security data format 541 */ 542 public T secureXML(String secureTag, Map<String, String> namespaces, boolean secureTagContents) { 543 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, namespaces, secureTagContents); 544 return dataFormat(xsdf); 545 } 546 547 /** 548 * Uses the XML Security data format 549 */ 550 public T secureXML(String secureTag, boolean secureTagContents, String passPhrase) { 551 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, secureTagContents, passPhrase); 552 return dataFormat(xsdf); 553 } 554 555 /** 556 * Uses the XML Security data format 557 */ 558 public T secureXML(String secureTag, Map<String, String> namespaces, boolean secureTagContents, String passPhrase) { 559 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, namespaces, secureTagContents, passPhrase); 560 return dataFormat(xsdf); 561 } 562 563 /** 564 * Uses the XML Security data format 565 */ 566 public T secureXML(String secureTag, boolean secureTagContents, String passPhrase, String xmlCipherAlgorithm) { 567 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, secureTagContents, passPhrase, xmlCipherAlgorithm); 568 return dataFormat(xsdf); 569 } 570 571 572 /** 573 * Uses the XML Security data format 574 */ 575 public T secureXML(String secureTag, Map<String, String> namespaces, boolean secureTagContents, String passPhrase, String xmlCipherAlgorithm) { 576 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, namespaces, secureTagContents, passPhrase, xmlCipherAlgorithm); 577 return dataFormat(xsdf); 578 } 579 580 /** 581 * @deprecated Use {@link #secureXML(String, Map, boolean, String, String, String, String) instead. 582 * Uses the XML Security data format 583 */ 584 @Deprecated 585 public T secureXML(String secureTag, boolean secureTagContents, String recipientKeyAlias, String xmlCipherAlgorithm, 586 String keyCipherAlgorithm) { 587 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, keyCipherAlgorithm); 588 return dataFormat(xsdf); 589 } 590 591 /** 592 * Uses the XML Security data format 593 */ 594 public T secureXML(String secureTag, boolean secureTagContents, String recipientKeyAlias, String xmlCipherAlgorithm, 595 String keyCipherAlgorithm, String keyOrTrustStoreParametersId) { 596 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, 597 keyCipherAlgorithm, keyOrTrustStoreParametersId); 598 return dataFormat(xsdf); 599 } 600 601 /** 602 * Uses the XML Security data format 603 */ 604 public T secureXML(String secureTag, boolean secureTagContents, String recipientKeyAlias, String xmlCipherAlgorithm, 605 String keyCipherAlgorithm, String keyOrTrustStoreParametersId, String keyPassword) { 606 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, 607 keyCipherAlgorithm, keyOrTrustStoreParametersId, keyPassword); 608 return dataFormat(xsdf); 609 } 610 611 /** 612 * Uses the XML Security data format 613 */ 614 public T secureXML(String secureTag, boolean secureTagContents, String recipientKeyAlias, String xmlCipherAlgorithm, 615 String keyCipherAlgorithm, KeyStoreParameters keyOrTrustStoreParameters) { 616 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, 617 keyCipherAlgorithm, keyOrTrustStoreParameters); 618 return dataFormat(xsdf); 619 } 620 621 /** 622 * Uses the XML Security data format 623 */ 624 public T secureXML(String secureTag, boolean secureTagContents, String recipientKeyAlias, String xmlCipherAlgorithm, 625 String keyCipherAlgorithm, KeyStoreParameters keyOrTrustStoreParameters, String keyPassword) { 626 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, 627 keyCipherAlgorithm, keyOrTrustStoreParameters, keyPassword); 628 return dataFormat(xsdf); 629 } 630 631 /** 632 * Uses the XML Security data format 633 */ 634 public T secureXML(String secureTag, Map<String, String> namespaces, boolean secureTagContents, String recipientKeyAlias, 635 String xmlCipherAlgorithm, String keyCipherAlgorithm, String keyOrTrustStoreParametersId) { 636 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, namespaces, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, 637 keyCipherAlgorithm, keyOrTrustStoreParametersId); 638 return dataFormat(xsdf); 639 } 640 641 /** 642 * Uses the XML Security data format 643 */ 644 public T secureXML(String secureTag, Map<String, String> namespaces, boolean secureTagContents, String recipientKeyAlias, 645 String xmlCipherAlgorithm, String keyCipherAlgorithm, String keyOrTrustStoreParametersId, String keyPassword) { 646 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, namespaces, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, 647 keyCipherAlgorithm, keyOrTrustStoreParametersId, keyPassword); 648 return dataFormat(xsdf); 649 } 650 651 /** 652 * Uses the XML Security data format 653 */ 654 public T secureXML(String secureTag, Map<String, String> namespaces, boolean secureTagContents, String recipientKeyAlias, 655 String xmlCipherAlgorithm, String keyCipherAlgorithm, KeyStoreParameters keyOrTrustStoreParameters) { 656 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, namespaces, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, 657 keyCipherAlgorithm, keyOrTrustStoreParameters); 658 return dataFormat(xsdf); 659 } 660 661 /** 662 * Uses the XML Security data format 663 */ 664 public T secureXML(String secureTag, Map<String, String> namespaces, boolean secureTagContents, String recipientKeyAlias, 665 String xmlCipherAlgorithm, String keyCipherAlgorithm, KeyStoreParameters keyOrTrustStoreParameters, String keyPassword) { 666 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, namespaces, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, 667 keyCipherAlgorithm, keyOrTrustStoreParameters, keyPassword); 668 return dataFormat(xsdf); 669 } 670 671 /** 672 * Uses the XML Security data format 673 */ 674 public T secureXML(String secureTag, Map<String, String> namespaces, boolean secureTagContents, String recipientKeyAlias, 675 String xmlCipherAlgorithm, String keyCipherAlgorithm, KeyStoreParameters keyOrTrustStoreParameters, String keyPassword, 676 String digestAlgorithm) { 677 XMLSecurityDataFormat xsdf = new XMLSecurityDataFormat(secureTag, namespaces, secureTagContents, recipientKeyAlias, xmlCipherAlgorithm, 678 keyCipherAlgorithm, keyOrTrustStoreParameters, keyPassword, digestAlgorithm); 679 return dataFormat(xsdf); 680 } 681 682 /** 683 * Uses the xmlBeans data format 684 */ 685 public T xmlBeans() { 686 return dataFormat(new XMLBeansDataFormat()); 687 } 688 689 /** 690 * Uses the xmljson dataformat, based on json-lib 691 */ 692 public T xmljson() { 693 return dataFormat(new XmlJsonDataFormat()); 694 } 695 696 /** 697 * Uses the xmljson dataformat, based on json-lib, initializing custom options with a Map 698 */ 699 public T xmljson(Map<String, String> options) { 700 return dataFormat(new XmlJsonDataFormat(options)); 701 } 702 703 /** 704 * Uses the ZIP deflater data format 705 */ 706 public T zip() { 707 ZipDataFormat zdf = new ZipDataFormat(Deflater.DEFAULT_COMPRESSION); 708 return dataFormat(zdf); 709 } 710 711 /** 712 * Uses the ZIP deflater data format 713 */ 714 public T zip(int compressionLevel) { 715 ZipDataFormat zdf = new ZipDataFormat(compressionLevel); 716 return dataFormat(zdf); 717 } 718 719 /** 720 * Uses the ZIP file data format 721 */ 722 public T zipFile() { 723 ZipFileDataFormat zfdf = new ZipFileDataFormat(); 724 return dataFormat(zfdf); 725 } 726 727 @SuppressWarnings("unchecked") 728 private T dataFormat(DataFormatDefinition dataFormatType) { 729 switch (operation) { 730 case Unmarshal: 731 return (T) processorType.unmarshal(dataFormatType); 732 case Marshal: 733 return (T) processorType.marshal(dataFormatType); 734 default: 735 throw new IllegalArgumentException("Unknown DataFormat operation: " + operation); 736 } 737 } 738 }