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