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