20210191346

Committed 14 Dec 2025 03:32PM UTC coverage: 19.514% (-33.5%) from 53.061%

Build # 20210191346

Build Type

push

github

Committed by

rubensworks

Commit Message

Remove deprecations

Run Details

663 of 8728 branches covered (7.6%)

Branch coverage included in aggregate %.

6786 of 29445 relevant lines covered (23.05%)

1.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

15.69

/src/main/java/org/cyclops/integrateddynamics/core/persist/world/NetworkWorldStorage.java

package org.cyclops.integrateddynamics.core.persist.world;

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.mojang.serialization.Codec;
import com.mojang.serialization.codecs.RecordCodecBuilder;
import net.minecraft.world.level.saveddata.SavedDataType;
import org.cyclops.cyclopscore.init.ModBaseNeoForge;
import org.cyclops.cyclopscore.persist.world.WorldStorage;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.core.TickHandler;
import org.cyclops.integrateddynamics.core.network.Network;
import org.cyclops.integrateddynamics.core.network.NetworkParams;

import java.util.Collections;
import java.util.List;
import java.util.Set;

/**
 * World NBT storage for all active networks.
 * @author rubensworks
 */
public class NetworkWorldStorage extends WorldStorage<NetworkWorldStorage> {

    private final List<NetworkParams> networkParams;
    private Set<Network> networks = Sets.newHashSet();

    public NetworkWorldStorage(List<NetworkParams> networkParams) {
        this.networkParams = Lists.newArrayList(networkParams);
    }

    /**
     * Add a network that needs persistence.
     * @param network The network.
     */
    public synchronized void addNewNetwork(Network network) {
        networks.add(network);
        setDirty();
    }

    /**
     * Remove a network that was invalidated and does not need persistence anymore.
     * This is allowed to be called if the network was already removed.
     * @param network The network.
     */
    public synchronized void removeInvalidatedNetwork(Network network) {
        networks.remove(network);
        setDirty();
    }

    /**
     * @return A thread-safe copy of the current network set.
     */
    public synchronized Set<INetwork> getNetworks() {
        return Collections.unmodifiableSet(Sets.newHashSet(networks));
    }

    @Override
    public void afterLoad() {
        // Load from params
        for (NetworkParams networkParam : networkParams) {
            Network network = new Network();
            network.fromParams(networkParam);
            networks.add(network);
        }

        TickHandler.getInstance().ticked = false;
        for(INetwork network : networks) {
            network.afterServerLoad();
        }
    }

    @Override
    public void beforeSave() {
        for(Network network : networks) {
            network.beforeServerStop();
        }

        // Save to params
        for(Network network : networks) {
            // Save to params
            this.networkParams.add(network.toParams());
        }

        // Consider always dirty
        setDirty();
    }

    public static class Access extends WorldStorage.Access<NetworkWorldStorage> {

        private static NetworkWorldStorage.Access INSTANCE = null;

        public static NetworkWorldStorage.Access getInstance(ModBaseNeoForge<?> mod) {
            if(INSTANCE == null) {
                INSTANCE = new NetworkWorldStorage.Access(mod);
            }
            return INSTANCE;
        }

        public Access(ModBaseNeoForge<?> mod) {
            super(new SavedDataType<>(
                    mod.getModId() + "_networks",
                    (ctx) -> new NetworkWorldStorage(Lists.newArrayList()),
                    ctx -> RecordCodecBuilder.create(instance -> instance.group(
                            RecordCodecBuilder.point(ctx.levelOrThrow()),
                            Codec.list(NetworkParams.CODEC).fieldOf("networks").forGetter(data -> data.networkParams)
                    ).apply(instance, (level, networkParams) -> new NetworkWorldStorage(networkParams)))
            ), mod);
        }
    }

}

1	package org.cyclops.integrateddynamics.core.persist.world;
2
3	import com.google.common.collect.Lists;
4	import com.google.common.collect.Sets;
5	import com.mojang.serialization.Codec;
6	import com.mojang.serialization.codecs.RecordCodecBuilder;
7	import net.minecraft.world.level.saveddata.SavedDataType;
8	import org.cyclops.cyclopscore.init.ModBaseNeoForge;
9	import org.cyclops.cyclopscore.persist.world.WorldStorage;
10	import org.cyclops.integrateddynamics.api.network.INetwork;
11	import org.cyclops.integrateddynamics.core.TickHandler;
12	import org.cyclops.integrateddynamics.core.network.Network;
13	import org.cyclops.integrateddynamics.core.network.NetworkParams;
14
15	import java.util.Collections;
16	import java.util.List;
17	import java.util.Set;
18
19	/**
20	* World NBT storage for all active networks.
21	* @author rubensworks
22	*/
23	public class NetworkWorldStorage extends WorldStorage<NetworkWorldStorage> {
24
25	private final List<NetworkParams> networkParams;
26	private Set<Network> networks = Sets.newHashSet();	×
27
28	public NetworkWorldStorage(List<NetworkParams> networkParams) {	×
29	this.networkParams = Lists.newArrayList(networkParams);	×
30	}	×
31
32	/**
33	* Add a network that needs persistence.
34	* @param network The network.
35	*/
36	public synchronized void addNewNetwork(Network network) {
37	networks.add(network);	×
38	setDirty();	×
39	}	×
40
41	/**
42	* Remove a network that was invalidated and does not need persistence anymore.
43	* This is allowed to be called if the network was already removed.
44	* @param network The network.
45	*/
46	public synchronized void removeInvalidatedNetwork(Network network) {
47	networks.remove(network);	×
48	setDirty();	×
49	}	×
50
51	/**
52	* @return A thread-safe copy of the current network set.
53	*/
54	public synchronized Set<INetwork> getNetworks() {
55	return Collections.unmodifiableSet(Sets.newHashSet(networks));	×
56	}
57
58	@Override
59	public void afterLoad() {
60	// Load from params
61	for (NetworkParams networkParam : networkParams) {	×
62	Network network = new Network();	×
63	network.fromParams(networkParam);	×
64	networks.add(network);	×
65	}	×
66
67	TickHandler.getInstance().ticked = false;	×
68	for(INetwork network : networks) {	×
69	network.afterServerLoad();	×
70	}	×
71	}	×
72
73	@Override
74	public void beforeSave() {
75	for(Network network : networks) {	×
76	network.beforeServerStop();	×
77	}	×
78
79	// Save to params
80	for(Network network : networks) {	×
81	// Save to params
82	this.networkParams.add(network.toParams());	×
83	}	×
84
85	// Consider always dirty
86	setDirty();	×
87	}	×
88
89	public static class Access extends WorldStorage.Access<NetworkWorldStorage> {
90
91	private static NetworkWorldStorage.Access INSTANCE = null;	3✔
92
93	public static NetworkWorldStorage.Access getInstance(ModBaseNeoForge<?> mod) {
94	if(INSTANCE == null) {	2!
95	INSTANCE = new NetworkWorldStorage.Access(mod);	5✔
96	}
97	return INSTANCE;	2✔
98	}
99
100	public Access(ModBaseNeoForge<?> mod) {
101	super(new SavedDataType<>(	5✔
102	mod.getModId() + "_networks",	6✔
103	(ctx) -> new NetworkWorldStorage(Lists.newArrayList()),	×
104	ctx -> RecordCodecBuilder.create(instance -> instance.group(	×
105	RecordCodecBuilder.point(ctx.levelOrThrow()),	×
106	Codec.list(NetworkParams.CODEC).fieldOf("networks").forGetter(data -> data.networkParams)	×
107	).apply(instance, (level, networkParams) -> new NetworkWorldStorage(networkParams)))	×
108	), mod);
109	}	1✔
110	}
111
112	}

CyclopsMC / IntegratedDynamics / 20210191346

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous