620faa79aa08a88da3236f3ad560496e2b98a840
[idea/community.git] / jps / jps-builders / src / org / jetbrains / jps / builders / java / dependencyView / RW.java
1 // Copyright 2000-2018 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 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 }