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