jps/jps-builders/src/org/jetbrains/jps/builders/java/dependencyView/RW.java

   1 // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
   2 package org.jetbrains.jps.builders.java.dependencyView;
   3
   4 import com.intellij.util.io.DataExternalizer;
   5 import com.intellij.util.io.DataInputOutputUtil;
   6 import com.intellij.util.io.IOUtil;
   7 import gnu.trove.TIntHashSet;
   8 import org.jetbrains.jps.builders.storage.BuildDataCorruptedException;
   9
  10 import java.io.*;
  11 import java.util.Collection;
  12
  13 /**
  14  * @author: db
  15  */
  16 public final class RW {
  17   private RW() {
  18
  19   }
  20
  21   protected static String readUTF(DataInput in) throws IOException {
  22     return IOUtil.readUTF(in);
  23   }
  24
  25   protected static void writeUTF(DataOutput out, String value) throws IOException {
  26     IOUtil.writeUTF(out, value);
  27   }
  28
  29   public interface Savable {
  30     void save(DataOutput out);
  31   }
  32
  33   public static <X extends Savable> void save(final X[] x, final DataOutput out) {
  34     try {
  35       DataInputOutputUtil.writeINT(out, x.length);
  36       for (Savable s : x) {
  37         s.save(out);
  38       }
  39     }
  40     catch (IOException e) {
  41       throw new BuildDataCorruptedException(e);
  42     }
  43   }
  44
  45   public static <X> void save(final TIntHashSet x, final DataOutput out) {
  46     try {
  47       DataInputOutputUtil.writeINT(out, x.size());
  48       x.forEach(value -> {
  49         try {
  50           DataInputOutputUtil.writeINT(out, value);
  51           return true;
  52         }
  53         catch (IOException e) {
  54           throw new BuildDataCorruptedException(e);
  55         }
  56       });
  57     }
  58     catch (IOException c) {
  59       throw new BuildDataCorruptedException(c);
  60     }
  61   }
  62
  63   public static <X> void save(final Collection<? extends X> x, final DataExternalizer<X> e, final DataOutput out) {
  64     try {
  65       DataInputOutputUtil.writeINT(out, x.size());
  66
  67       for (X y : x) {
  68         e.save(out, y);
  69       }
  70     }
  71     catch (IOException c) {
  72       throw new BuildDataCorruptedException(c);
  73     }
  74   }
  75
  76   public static <X extends Savable> void save(final Collection<X> x, final DataOutput out) {
  77     try {
  78       final int size = x.size();
  79
  80       DataInputOutputUtil.writeINT(out, size);
  81
  82       for (X s : x) {
  83         s.save(out);
  84       }
  85     }
  86     catch (IOException e) {
  87       throw new BuildDataCorruptedException(e);
  88     }
  89   }
  90
  91   public static <X> X[] read(final DataExternalizer<X> e, final DataInput in, final X[] result) {
  92     try {
  93       for (int i = 0; i < result.length; i++) {
  94         result[i] = e.read(in);
  95       }
  96
  97       return result;
  98     }
  99     catch (IOException x) {
 100       throw new BuildDataCorruptedException(x);
 101     }
 102   }
 103
 104   public static TIntHashSet read(final TIntHashSet acc, final DataInput in) {
 105     try {
 106       final int size = DataInputOutputUtil.readINT(in);
 107
 108       for (int i = 0; i<size; i++) {
 109         acc.add(DataInputOutputUtil.readINT(in));
 110       }
 111
 112       return acc;
 113     }
 114     catch (IOException x) {
 115       throw new BuildDataCorruptedException(x);
 116     }
 117   }
 118
 119   public static <X,C extends Collection<X>> C read(final DataExternalizer<X> e, final C acc, final DataInput in) {
 120     try {
 121       final int size = DataInputOutputUtil.readINT(in);
 122
 123       for (int i = 0; i<size; i++) {
 124         acc.add(e.read(in));
 125       }
 126
 127       return acc;
 128     }
 129     catch (IOException x) {
 130       throw new BuildDataCorruptedException(x);
 131     }
 132   }
 133
 134   public interface Writable {
 135     void write(BufferedWriter w);
 136   }
 137
 138   public interface ToWritable<T> {
 139     Writable convert(T x);
 140   }
 141
 142   public static void writeln(final BufferedWriter w, final String s) {
 143     try {
 144       if (s == null) {
 145         w.write("");
 146       }
 147       else {
 148         w.write(s);
 149       }
 150       w.newLine();
 151     }
 152     catch (IOException e) {
 153       throw new BuildDataCorruptedException(e);
 154     }
 155   }
 156
 157   public interface Reader<T> {
 158     T read(BufferedReader r);
 159   }
 160
 161   public static ToWritable<String> fromString = new ToWritable<String>() {
 162     @Override
 163     public Writable convert(final String s) {
 164       return new Writable() {
 165         @Override
 166         public void write(BufferedWriter w) {
 167           writeln(w, s);
 168         }
 169       };
 170     }
 171   };
 172
 173   public static String readString(final BufferedReader r) {
 174     try {
 175       return r.readLine();
 176     }
 177     catch (IOException e) {
 178       throw new BuildDataCorruptedException(e);
 179     }
 180   }
 181
 182   public static long readLong(final BufferedReader r) {
 183     final String s = readString(r);
 184
 185     try {
 186       return Long.parseLong(s);
 187     }
 188     catch (Exception n) {
 189       System.err.println("Parsing error: expected long, but found \"" + s + "\"");
 190       return 0;
 191     }
 192   }
 193 }