juplo.de Git - simple-mapper/blob - src/main/java/de/juplo/jackson/SimpleMapperService.java

   1 package de.juplo.jackson;
   2
   3
   4 import com.fasterxml.jackson.core.JsonFactory;
   5 import java.io.File;
   6 import java.io.IOException;
   7 import java.io.InputStream;
   8 import java.io.Reader;
   9 import java.net.URL;
  10 import java.util.Iterator;
  11 import java.util.List;
  12 import java.util.Map;
  13 import java.util.Spliterator;
  14 import java.util.stream.Stream;
  15 import org.springframework.beans.factory.InitializingBean;
  16 import org.springframework.beans.factory.annotation.Autowired;
  17 import org.springframework.stereotype.Component;
  18 import org.springframework.util.Assert;
  19
  20
  21
  22 /**
  23  *
  24  * @author kai
  25  */
  26 @Component
  27 public class SimpleMapperService
  28     extends
  29       SimpleMapper
  30     implements
  31       InitializingBean
  32 {
  33   @Autowired(required = false)
  34   private JsonFactory factory;
  35
  36
  37   public SimpleMapperService() {}
  38
  39   public SimpleMapperService(JsonFactory factory)
  40   {
  41     this.factory = factory;
  42   }
  43
  44
  45   @Override
  46   public void afterPropertiesSet() throws Exception
  47   {
  48     Assert.notNull(factory, "The attribute factory must be set!");
  49   }
  50
  51   public JsonFactory getFactory()
  52   {
  53     return factory;
  54   }
  55
  56
  57   public Spliterator<Object> getArraySpliterator(File file)
  58       throws
  59         IOException
  60   {
  61     return getArraySpliterator(factory.createParser(file));
  62   }
  63
  64   public Spliterator<Object> getArraySpliterator(InputStream is)
  65       throws
  66         IOException
  67   {
  68     return getArraySpliterator(factory.createParser(is));
  69   }
  70
  71   public Spliterator<Object> getArraySpliterator(Reader r)
  72       throws
  73         IOException
  74   {
  75     return getArraySpliterator(factory.createParser(r));
  76   }
  77
  78   public Spliterator<Object> getArraySpliterator(String content)
  79       throws
  80         IOException
  81   {
  82     return getArraySpliterator(factory.createParser(content));
  83   }
  84
  85   public Spliterator<Object> getArraySpliterator(URL url)
  86       throws
  87         IOException
  88   {
  89     return getArraySpliterator(factory.createParser(url));
  90   }
  91
  92   public Spliterator<Object> getArraySpliterator(byte[] data)
  93       throws
  94         IOException
  95   {
  96     return getArraySpliterator(factory.createParser(data));
  97   }
  98
  99   public Spliterator<Object> getArraySpliterator(char[] content)
 100       throws
 101         IOException
 102   {
 103     return getArraySpliterator(factory.createParser(content));
 104   }
 105
 106   public Spliterator<Object> getArraySpliterator(byte[] data, int offset, int len)
 107       throws
 108         IOException
 109   {
 110     return getArraySpliterator(factory.createParser(data, offset, len));
 111   }
 112
 113   public Spliterator<Object> getArraySpliterator(char[] data, int offset, int len)
 114       throws
 115         IOException
 116   {
 117     return getArraySpliterator(factory.createParser(data, offset, len));
 118   }
 119
 120   public Stream<Object> getArrayStream(File file)
 121       throws
 122         IOException
 123   {
 124     return getArrayStream(factory.createParser(file));
 125   }
 126
 127   public Stream<Object> getArrayStream(InputStream is)
 128       throws
 129         IOException
 130   {
 131     return getArrayStream(factory.createParser(is));
 132   }
 133
 134   public Stream<Object> getArrayStream(Reader r)
 135       throws
 136         IOException
 137   {
 138     return getArrayStream(factory.createParser(r));
 139   }
 140
 141   public Stream<Object> getArrayStream(String content)
 142       throws
 143         IOException
 144   {
 145     return getArrayStream(factory.createParser(content));
 146   }
 147
 148   public Stream<Object> getArrayStream(URL url)
 149       throws
 150         IOException
 151   {
 152     return getArrayStream(factory.createParser(url));
 153   }
 154
 155   public Stream<Object> getArrayStream(byte[] data)
 156       throws
 157         IOException
 158   {
 159     return getArrayStream(factory.createParser(data));
 160   }
 161
 162   public Stream<Object> getArrayStream(char[] content)
 163       throws
 164         IOException
 165   {
 166     return getArrayStream(factory.createParser(content));
 167   }
 168
 169   public Stream<Object> getArrayStream(byte[] data, int offset, int len)
 170       throws
 171         IOException
 172   {
 173     return getArrayStream(factory.createParser(data, offset, len));
 174   }
 175
 176   public Stream<Object> getArrayStream(char[] data, int offset, int len)
 177       throws
 178         IOException
 179   {
 180     return getArrayStream(factory.createParser(data, offset, len));
 181   }
 182
 183   public Iterator<Object> getArrayIterator(File file)
 184       throws
 185         IOException
 186   {
 187     return getArrayIterator(factory.createParser(file));
 188   }
 189
 190   public Iterator<Object> getArrayIterator(InputStream is)
 191       throws
 192         IOException
 193   {
 194     return getArrayIterator(factory.createParser(is));
 195   }
 196
 197   public Iterator<Object> getArrayIterator(Reader r)
 198       throws
 199         IOException
 200   {
 201     return getArrayIterator(factory.createParser(r));
 202   }
 203
 204   public Iterator<Object> getArrayIterator(String content)
 205       throws
 206         IOException
 207   {
 208     return getArrayIterator(factory.createParser(content));
 209   }
 210
 211   public Iterator<Object> getArrayIterator(URL url)
 212       throws
 213         IOException
 214   {
 215     return getArrayIterator(factory.createParser(url));
 216   }
 217
 218   public Iterator<Object> getArrayIterator(byte[] data)
 219       throws
 220         IOException
 221   {
 222     return getArrayIterator(factory.createParser(data));
 223   }
 224
 225   public Iterator<Object> getArrayIterator(char[] content)
 226       throws
 227         IOException
 228   {
 229     return getArrayIterator(factory.createParser(content));
 230   }
 231
 232   public Iterator<Object> getArrayIterator(byte[] data, int offset, int len)
 233       throws
 234         IOException
 235   {
 236     return getArrayIterator(factory.createParser(data, offset, len));
 237   }
 238
 239   public Iterator<Object> getArrayIterator(char[] data, int offset, int len)
 240       throws
 241         IOException
 242   {
 243     return getArrayIterator(factory.createParser(data, offset, len));
 244   }
 245
 246
 247   public Spliterator<Map.Entry<String, Object>> getObjectSpliterator(File file)
 248       throws
 249         IOException
 250   {
 251     return getObjectSpliterator(factory.createParser(file));
 252   }
 253
 254   public Spliterator<Map.Entry<String, Object>> getObjectSpliterator(InputStream is)
 255       throws
 256         IOException
 257   {
 258     return getObjectSpliterator(factory.createParser(is));
 259   }
 260
 261   public Spliterator<Map.Entry<String, Object>> getObjectSpliterator(Reader r)
 262       throws
 263         IOException
 264   {
 265     return getObjectSpliterator(factory.createParser(r));
 266   }
 267
 268   public Spliterator<Map.Entry<String, Object>> getObjectSpliterator(String content)
 269       throws
 270         IOException
 271   {
 272     return getObjectSpliterator(factory.createParser(content));
 273   }
 274
 275   public Spliterator<Map.Entry<String, Object>> getObjectSpliterator(URL url)
 276       throws
 277         IOException
 278   {
 279     return getObjectSpliterator(factory.createParser(url));
 280   }
 281
 282   public Spliterator<Map.Entry<String, Object>> getObjectSpliterator(byte[] data)
 283       throws
 284         IOException
 285   {
 286     return getObjectSpliterator(factory.createParser(data));
 287   }
 288
 289   public Spliterator<Map.Entry<String, Object>> getObjectSpliterator(char[] content)
 290       throws
 291         IOException
 292   {
 293     return getObjectSpliterator(factory.createParser(content));
 294   }
 295
 296   public Spliterator<Map.Entry<String, Object>> getObjectSpliterator(byte[] data, int offset, int len)
 297       throws
 298         IOException
 299   {
 300     return getObjectSpliterator(factory.createParser(data, offset, len));
 301   }
 302
 303   public Spliterator<Map.Entry<String, Object>> getObjectSpliterator(char[] data, int offset, int len)
 304       throws
 305         IOException
 306   {
 307     return getObjectSpliterator(factory.createParser(data, offset, len));
 308   }
 309
 310   public Stream<Map.Entry<String, Object>> getObjectStream(File file)
 311       throws
 312         IOException
 313   {
 314     return getObjectStream(factory.createParser(file));
 315   }
 316
 317   public Stream<Map.Entry<String, Object>> getObjectStream(InputStream is)
 318       throws
 319         IOException
 320   {
 321     return getObjectStream(factory.createParser(is));
 322   }
 323
 324   public Stream<Map.Entry<String, Object>> getObjectStream(Reader r)
 325       throws
 326         IOException
 327   {
 328     return getObjectStream(factory.createParser(r));
 329   }
 330
 331   public Stream<Map.Entry<String, Object>> getObjectStream(String content)
 332       throws
 333         IOException
 334   {
 335     return getObjectStream(factory.createParser(content));
 336   }
 337
 338   public Stream<Map.Entry<String, Object>> getObjectStream(URL url)
 339       throws
 340         IOException
 341   {
 342     return getObjectStream(factory.createParser(url));
 343   }
 344
 345   public Stream<Map.Entry<String, Object>> getObjectStream(byte[] data)
 346       throws
 347         IOException
 348   {
 349     return getObjectStream(factory.createParser(data));
 350   }
 351
 352   public Stream<Map.Entry<String, Object>> getObjectStream(char[] content)
 353       throws
 354         IOException
 355   {
 356     return getObjectStream(factory.createParser(content));
 357   }
 358
 359   public Stream<Map.Entry<String, Object>> getObjectStream(byte[] data, int offset, int len)
 360       throws
 361         IOException
 362   {
 363     return getObjectStream(factory.createParser(data, offset, len));
 364   }
 365
 366   public Stream<Map.Entry<String, Object>> getObjectStream(char[] data, int offset, int len)
 367       throws
 368         IOException
 369   {
 370     return getObjectStream(factory.createParser(data, offset, len));
 371   }
 372
 373   public Iterator<Map.Entry<String, Object>> getObjectIterator(File file)
 374       throws
 375         IOException
 376   {
 377     return getObjectIterator(factory.createParser(file));
 378   }
 379
 380   public Iterator<Map.Entry<String, Object>> getObjectIterator(InputStream is)
 381       throws
 382         IOException
 383   {
 384     return getObjectIterator(factory.createParser(is));
 385   }
 386
 387   public Iterator<Map.Entry<String, Object>> getObjectIterator(Reader r)
 388       throws
 389         IOException
 390   {
 391     return getObjectIterator(factory.createParser(r));
 392   }
 393
 394   public Iterator<Map.Entry<String, Object>> getObjectIterator(String content)
 395       throws
 396         IOException
 397   {
 398     return getObjectIterator(factory.createParser(content));
 399   }
 400
 401   public Iterator<Map.Entry<String, Object>> getObjectIterator(URL url)
 402       throws
 403         IOException
 404   {
 405     return getObjectIterator(factory.createParser(url));
 406   }
 407
 408   public Iterator<Map.Entry<String, Object>> getObjectIterator(byte[] data)
 409       throws
 410         IOException
 411   {
 412     return getObjectIterator(factory.createParser(data));
 413   }
 414
 415   public Iterator<Map.Entry<String, Object>> getObjectIterator(char[] content)
 416       throws
 417         IOException
 418   {
 419     return getObjectIterator(factory.createParser(content));
 420   }
 421
 422   public Iterator<Map.Entry<String, Object>> getObjectIterator(byte[] data, int offset, int len)
 423       throws
 424         IOException
 425   {
 426     return getObjectIterator(factory.createParser(data, offset, len));
 427   }
 428
 429   public Iterator<Map.Entry<String, Object>> getObjectIterator(char[] data, int offset, int len)
 430       throws
 431         IOException
 432   {
 433     return getObjectIterator(factory.createParser(data, offset, len));
 434   }
 435
 436
 437   public List<Object> convertArray(File file) throws Exception
 438   {
 439     return convertArray(factory.createParser(file));
 440   }
 441
 442   public List<Object> convertArray(InputStream is) throws Exception
 443   {
 444     return convertArray(factory.createParser(is));
 445   }
 446
 447   public List<Object> convertArray(Reader r) throws Exception
 448   {
 449     return convertArray(factory.createParser(r));
 450   }
 451
 452   public List<Object> convertArray(String content) throws Exception
 453   {
 454     return convertArray(factory.createParser(content));
 455   }
 456
 457   public List<Object> convertArray(URL url) throws Exception
 458   {
 459     return convertArray(factory.createParser(url));
 460   }
 461
 462   public List<Object> convertArray(byte[] data) throws Exception
 463   {
 464     return convertArray(factory.createParser(data));
 465   }
 466
 467   public List<Object> convertArray(char[] content) throws Exception
 468   {
 469     return convertArray(factory.createParser(content));
 470   }
 471
 472   public List<Object> convertArray(byte[] data, int offset, int len)
 473       throws
 474         Exception
 475   {
 476     return convertArray(factory.createParser(data, offset, len));
 477   }
 478
 479   public List<Object> convertArray(char[] content, int offset, int len)
 480       throws
 481         Exception
 482   {
 483     return convertArray(factory.createParser(content, offset, len));
 484   }
 485
 486   public Map<String, Object> convertObject(File file) throws Exception
 487   {
 488     return convertObject(factory.createParser(file));
 489   }
 490
 491   public Map<String, Object> convertObject(InputStream is) throws Exception
 492   {
 493     return convertObject(factory.createParser(is));
 494   }
 495
 496   public Map<String, Object> convertObject(Reader r) throws Exception
 497   {
 498     return convertObject(factory.createParser(r));
 499   }
 500
 501   public Map<String, Object> convertObject(String content) throws Exception
 502   {
 503     return convertObject(factory.createParser(content));
 504   }
 505
 506   public Map<String, Object> convertObject(URL url) throws Exception
 507   {
 508     return convertObject(factory.createParser(url));
 509   }
 510
 511   public Map<String, Object> convertObject(byte[] data) throws Exception
 512   {
 513     return convertObject(factory.createParser(data));
 514   }
 515
 516   public Map<String, Object> convertObject(char[] content) throws Exception
 517   {
 518     return convertObject(factory.createParser(content));
 519   }
 520
 521   public Map<String, Object> convertObject(byte[] data, int offset, int len)
 522       throws
 523         Exception
 524   {
 525     return convertObject(factory.createParser(data, offset, len));
 526   }
 527
 528   public Map<String, Object> convertObject(char[] content, int offset, int len)
 529       throws
 530         Exception
 531   {
 532     return convertObject(factory.createParser(content, offset, len));
 533   }
 534
 535   public Object convert(File file) throws Exception
 536   {
 537     return convert(factory.createParser(file));
 538   }
 539
 540   public Object convert(InputStream is) throws Exception
 541   {
 542     return convert(factory.createParser(is));
 543   }
 544
 545   public Object convert(Reader r) throws Exception
 546   {
 547     return convert(factory.createParser(r));
 548   }
 549
 550   public Object convert(String content) throws Exception
 551   {
 552     return convert(factory.createParser(content));
 553   }
 554
 555   public Object convert(URL url) throws Exception
 556   {
 557     return convert(factory.createParser(url));
 558   }
 559
 560   public Object convert(byte[] data) throws Exception
 561   {
 562     return convert(factory.createParser(data));
 563   }
 564
 565   public Object convert(char[] content) throws Exception
 566   {
 567     return convert(factory.createParser(content));
 568   }
 569
 570   public Object convert(byte[] data, int offset, int len)
 571       throws
 572         Exception
 573   {
 574     return convert(factory.createParser(data, offset, len));
 575   }
 576
 577   public Object convert(char[] content, int offset, int len)
 578       throws
 579         Exception
 580   {
 581     return convert(factory.createParser(content, offset, len));
 582   }
 583 }