001/*
002 * Copyright (c) 2022-2024 See AUTHORS file.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 *   http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 *
016 */
017
018package com.github.tommyettinger.kryo.cringe;
019
020import com.esotericsoftware.kryo.Kryo;
021import com.esotericsoftware.kryo.Serializer;
022import com.esotericsoftware.kryo.io.Input;
023import com.esotericsoftware.kryo.io.Output;
024import com.github.tommyettinger.cringe.PointSequence.*;
025
026/**
027 * Outer class containing nothing of its own except for many inner Kryo Serializer classes.
028 */
029public final class PointSequenceSerializers {
030
031    private PointSequenceSerializers() {
032    }
033
034    /**
035     * Kryo {@link Serializer} for cringe {@link Halton2}s.
036     */
037    public static class Halton2Serializer extends Serializer<Halton2> {
038
039        public Halton2Serializer() {
040            setImmutable(false);
041            setAcceptsNull(false);
042        }
043
044        @Override
045        public void write(final Kryo kryo, final Output output, final Halton2 data) {
046            output.writeInt(data.baseX, true);
047            output.writeInt(data.baseY, true);
048            output.writeInt(data.index, false);
049        }
050
051        @Override
052        public Halton2 read(final Kryo kryo, final Input input, final Class<? extends Halton2> dataClass) {
053            return new Halton2(input.readInt(true), input.readInt(true), input.readInt(false));
054        }
055
056        @Override
057        public Halton2 copy(Kryo kryo, Halton2 original) {
058            return original.copy();
059        }
060    }
061
062    /**
063     * Kryo {@link Serializer} for cringe {@link Halton3}s.
064     */
065    public static class Halton3Serializer extends Serializer<Halton3> {
066
067        public Halton3Serializer() {
068            setImmutable(false);
069            setAcceptsNull(false);
070        }
071
072        @Override
073        public void write(final Kryo kryo, final Output output, final Halton3 data) {
074            output.writeInt(data.baseX, true);
075            output.writeInt(data.baseY, true);
076            output.writeInt(data.baseZ, true);
077            output.writeInt(data.index, false);
078        }
079
080        @Override
081        public Halton3 read(final Kryo kryo, final Input input, final Class<? extends Halton3> dataClass) {
082            return new Halton3(input.readInt(true), input.readInt(true), input.readInt(true), input.readInt(false));
083        }
084
085        @Override
086        public Halton3 copy(Kryo kryo, Halton3 original) {
087            return original.copy();
088        }
089    }
090    
091    /**
092     * Kryo {@link Serializer} for cringe {@link Halton4}s.
093     */
094    public static class Halton4Serializer extends Serializer<Halton4> {
095
096        public Halton4Serializer() {
097            setImmutable(false);
098            setAcceptsNull(false);
099        }
100
101        @Override
102        public void write(final Kryo kryo, final Output output, final Halton4 data) {
103            output.writeInt(data.baseX, true);
104            output.writeInt(data.baseY, true);
105            output.writeInt(data.baseZ, true);
106            output.writeInt(data.baseW, true);
107            output.writeInt(data.index, false);
108        }
109
110        @Override
111        public Halton4 read(final Kryo kryo, final Input input, final Class<? extends Halton4> dataClass) {
112            return new Halton4(input.readInt(true), input.readInt(true), input.readInt(true),
113                    input.readInt(true), input.readInt(false));
114        }
115
116        @Override
117        public Halton4 copy(Kryo kryo, Halton4 original) {
118            return original.copy();
119        }
120    }
121    
122    /**
123     * Kryo {@link Serializer} for cringe {@link Halton5}s.
124     */
125    public static class Halton5Serializer extends Serializer<Halton5> {
126
127        public Halton5Serializer() {
128            setImmutable(false);
129            setAcceptsNull(false);
130        }
131
132        @Override
133        public void write(final Kryo kryo, final Output output, final Halton5 data) {
134            output.writeInt(data.baseX, true);
135            output.writeInt(data.baseY, true);
136            output.writeInt(data.baseZ, true);
137            output.writeInt(data.baseW, true);
138            output.writeInt(data.baseU, true);
139            output.writeInt(data.index, false);
140        }
141
142        @Override
143        public Halton5 read(final Kryo kryo, final Input input, final Class<? extends Halton5> dataClass) {
144            return new Halton5(input.readInt(true), input.readInt(true), input.readInt(true),
145                    input.readInt(true), input.readInt(true), input.readInt(false));
146        }
147
148        @Override
149        public Halton5 copy(Kryo kryo, Halton5 original) {
150            return original.copy();
151        }
152    }
153    
154    /**
155     * Kryo {@link Serializer} for cringe {@link Halton6}s.
156     */
157    public static class Halton6Serializer extends Serializer<Halton6> {
158
159        public Halton6Serializer() {
160            setImmutable(false);
161            setAcceptsNull(false);
162        }
163
164        @Override
165        public void write(final Kryo kryo, final Output output, final Halton6 data) {
166            output.writeInt(data.baseX, true);
167            output.writeInt(data.baseY, true);
168            output.writeInt(data.baseZ, true);
169            output.writeInt(data.baseW, true);
170            output.writeInt(data.baseU, true);
171            output.writeInt(data.baseV, true);
172            output.writeInt(data.index, false);
173        }
174
175        @Override
176        public Halton6 read(final Kryo kryo, final Input input, final Class<? extends Halton6> dataClass) {
177            return new Halton6(input.readInt(true), input.readInt(true), input.readInt(true),
178                    input.readInt(true), input.readInt(true), input.readInt(true), input.readInt(false));
179        }
180
181        @Override
182        public Halton6 copy(Kryo kryo, Halton6 original) {
183            return original.copy();
184        }
185    }
186    
187    /**
188     * Kryo {@link Serializer} for cringe {@link R2}s.
189     */
190    public static class R2Serializer extends Serializer<R2> {
191
192        public R2Serializer() {
193            setImmutable(false);
194            setAcceptsNull(false);
195        }
196
197        @Override
198        public void write(final Kryo kryo, final Output output, final R2 data) {
199            output.writeFloat(data.x);
200            output.writeFloat(data.y);
201        }
202
203        @Override
204        public R2 read(final Kryo kryo, final Input input, final Class<? extends R2> dataClass) {
205            return new R2(input.readFloat(), input.readFloat());
206        }
207
208        @Override
209        public R2 copy(Kryo kryo, R2 original) {
210            return original.copy();
211        }
212    }
213
214    /**
215     * Kryo {@link Serializer} for cringe {@link R3}s.
216     */
217    public static class R3Serializer extends Serializer<R3> {
218
219        public R3Serializer() {
220            setImmutable(false);
221            setAcceptsNull(false);
222        }
223
224        @Override
225        public void write(final Kryo kryo, final Output output, final R3 data) {
226            output.writeFloat(data.x);
227            output.writeFloat(data.y);
228            output.writeFloat(data.z);
229        }
230
231        @Override
232        public R3 read(final Kryo kryo, final Input input, final Class<? extends R3> dataClass) {
233            return new R3(input.readFloat(), input.readFloat(), input.readFloat());
234        }
235
236        @Override
237        public R3 copy(Kryo kryo, R3 original) {
238            return original.copy();
239        }
240    }
241
242    /**
243     * Kryo {@link Serializer} for cringe {@link R4}s.
244     */
245    public static class R4Serializer extends Serializer<R4> {
246
247        public R4Serializer() {
248            setImmutable(false);
249            setAcceptsNull(false);
250        }
251
252        @Override
253        public void write(final Kryo kryo, final Output output, final R4 data) {
254            output.writeFloat(data.x);
255            output.writeFloat(data.y);
256            output.writeFloat(data.z);
257            output.writeFloat(data.w);
258        }
259
260        @Override
261        public R4 read(final Kryo kryo, final Input input, final Class<? extends R4> dataClass) {
262            return new R4(input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat());
263        }
264
265        @Override
266        public R4 copy(Kryo kryo, R4 original) {
267            return original.copy();
268        }
269    }
270
271    /**
272     * Kryo {@link Serializer} for cringe {@link R5}s.
273     */
274    public static class R5Serializer extends Serializer<R5> {
275
276        public R5Serializer() {
277            setImmutable(false);
278            setAcceptsNull(false);
279        }
280
281        @Override
282        public void write(final Kryo kryo, final Output output, final R5 data) {
283            output.writeFloat(data.x);
284            output.writeFloat(data.y);
285            output.writeFloat(data.z);
286            output.writeFloat(data.w);
287            output.writeFloat(data.u);
288        }
289
290        @Override
291        public R5 read(final Kryo kryo, final Input input, final Class<? extends R5> dataClass) {
292            return new R5(input.readFloat(), input.readFloat(), input.readFloat(),
293                    input.readFloat(), input.readFloat());
294        }
295
296        @Override
297        public R5 copy(Kryo kryo, R5 original) {
298            return original.copy();
299        }
300    }
301
302    /**
303     * Kryo {@link Serializer} for cringe {@link R6}s.
304     */
305    public static class R6Serializer extends Serializer<R6> {
306
307        public R6Serializer() {
308            setImmutable(false);
309            setAcceptsNull(false);
310        }
311
312        @Override
313        public void write(final Kryo kryo, final Output output, final R6 data) {
314            output.writeFloat(data.x);
315            output.writeFloat(data.y);
316            output.writeFloat(data.z);
317            output.writeFloat(data.w);
318            output.writeFloat(data.u);
319            output.writeFloat(data.v);
320        }
321
322        @Override
323        public R6 read(final Kryo kryo, final Input input, final Class<? extends R6> dataClass) {
324            return new R6(input.readFloat(), input.readFloat(), input.readFloat(),
325                    input.readFloat(), input.readFloat(), input.readFloat());
326        }
327
328        @Override
329        public R6 copy(Kryo kryo, R6 original) {
330            return original.copy();
331        }
332    }
333}