18042102834

Committed 26 Sep 2025 03:25PM UTC coverage: 44.791% (-0.1%) from 44.905%

Build # 18042102834

Build Type

push

github

Committed by

rubensworks

Commit Message

Merge remote-tracking branch 'origin/master-1.20-lts' into master-1.21-lts

Run Details

2572 of 8540 branches covered (30.12%)

Branch coverage included in aggregate %.

11761 of 23460 relevant lines covered (50.13%)

2.38 hits per line

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

27.59

/src/main/java/org/cyclops/integrateddynamics/infobook/OnTheDynamicsOfIntegrationBook.java

package org.cyclops.integrateddynamics.infobook;

import com.google.common.base.Function;
import com.google.common.collect.Lists;
import net.minecraft.resources.ResourceLocation;
import org.cyclops.cyclopscore.infobook.IInfoBook;
import org.cyclops.cyclopscore.infobook.InfoBook;
import org.cyclops.cyclopscore.infobook.InfoBookParser;
import org.cyclops.cyclopscore.infobook.pageelement.SectionAppendix;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.Reference;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
import org.cyclops.integrateddynamics.api.part.IPartType;
import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
import org.cyclops.integrateddynamics.core.part.PartTypes;
import org.cyclops.integrateddynamics.infobook.pageelement.*;
import org.cyclops.integrateddynamics.part.aspect.Aspects;
import org.w3c.dom.Element;

import javax.annotation.Nullable;
import java.util.List;

/**
 * Infobook class for the On the Dynamics of Integration.
 * @author rubensworks
 */
public class OnTheDynamicsOfIntegrationBook extends InfoBook {

    private static OnTheDynamicsOfIntegrationBook _instance = null;

    static {
        InfoBookParser.registerAppendixRecipeFactories(RegistryEntries.RECIPETYPE_SQUEEZER.get(), SqueezerRecipeAppendix::new);
        InfoBookParser.registerAppendixRecipeFactories(RegistryEntries.RECIPETYPE_MECHANICAL_SQUEEZER.get(), MechanicalSqueezerRecipeAppendix::new);
        InfoBookParser.registerAppendixRecipeFactories(RegistryEntries.RECIPETYPE_DRYING_BASIN.get(), DryingBasinRecipeAppendix::new);
        InfoBookParser.registerAppendixRecipeFactories(RegistryEntries.RECIPETYPE_MECHANICAL_DRYING_BASIN.get(), MechanicalDryingBasinRecipeAppendix::new);

        InfoBookParser.registerAppendixFactory(Reference.MOD_ID + ":aspect", new InfoBookParser.IAppendixFactory() {
            @Override
            public SectionAppendix create(IInfoBook infoBook, Element node) throws InfoBookParser.InvalidAppendixException {
                String aspectName = node.getTextContent();
                IAspect aspect = Aspects.REGISTRY.getAspect(ResourceLocation.parse(aspectName));
                if (aspect == null) {
                    throw new InfoBookParser.InvalidAppendixException(String.format("Could not find an aspect by name %s.", aspectName));
                }
                return new AspectAppendix(infoBook, aspect);
            }
        });

        InfoBookParser.registerAppendixListFactory(Reference.MOD_ID + ":part_aspects", new InfoBookParser.IAppendixListFactory() {
            @Override
            public List<SectionAppendix> create(final IInfoBook infoBook, Element node) throws InfoBookParser.InvalidAppendixException {
                String partName = node.getTextContent();
                IPartType partType = PartTypes.REGISTRY.getPartType(ResourceLocation.parse(partName));
                if (partType == null) {
                    throw new InfoBookParser.InvalidAppendixException(String.format("Could not find a part type by name '%s'.", partName));
                }
                List<IAspect> aspects = Lists.newArrayList(Aspects.REGISTRY.getAspects(partType));
                return Lists.transform(aspects, new Function<IAspect, SectionAppendix>() {
                    @Nullable
                    @Override
                    public SectionAppendix apply(IAspect input) {
                        return new AspectAppendix(infoBook, input);
                    }
                });
            }
        });

        InfoBookParser.registerAppendixFactory(Reference.MOD_ID + ":operator", new InfoBookParser.IAppendixFactory() {
            @Override
            public SectionAppendix create(IInfoBook infoBook, Element node) throws InfoBookParser.InvalidAppendixException {
                String operatorName = node.getTextContent();
                IOperator operator = Operators.REGISTRY.getOperator(ResourceLocation.parse(operatorName));
                if (operator == null) {
                    throw new InfoBookParser.InvalidAppendixException(String.format("Could not find an operator by name %s.", operatorName));
                }
                return new OperatorAppendix(infoBook, operator);
            }
        });

        InfoBookParser.registerAppendixListFactory(Reference.MOD_ID + ":operators_output", new InfoBookParser.IAppendixListFactory() {
            @Override
            public List<SectionAppendix> create(final IInfoBook infoBook, Element node) throws InfoBookParser.InvalidAppendixException {
                String categoryName = node.getTextContent();
                List<IOperator> operators = Lists.newArrayList("*".equals(categoryName) ? Operators.REGISTRY.getOperators() : Operators.REGISTRY.getOperatorsInCategory(categoryName));
                if (operators.isEmpty()) {
                    operators = Lists.newArrayList();
                    for (IOperator operator : Operators.REGISTRY.getOperators()) {
                        if (operator.getUniqueName().toString().matches(categoryName)) {
                            operators.add(operator);
                        }
                    }
                }
                return Lists.transform(operators, new Function<IOperator, SectionAppendix>() {
                    @Nullable
                    @Override
                    public SectionAppendix apply(IOperator input) {
                        return new OperatorAppendix(infoBook, input);
                    }
                });
            }
        });
    }

    private OnTheDynamicsOfIntegrationBook() {
        super(IntegratedDynamics._instance, 2, Reference.BOOK_URL);
    }

    public static synchronized OnTheDynamicsOfIntegrationBook getInstance() {
        if(_instance == null) {
            _instance = new OnTheDynamicsOfIntegrationBook();
        }
        return _instance;
    }
}

1	package org.cyclops.integrateddynamics.infobook;
2
3	import com.google.common.base.Function;
4	import com.google.common.collect.Lists;
5	import net.minecraft.resources.ResourceLocation;
6	import org.cyclops.cyclopscore.infobook.IInfoBook;
7	import org.cyclops.cyclopscore.infobook.InfoBook;
8	import org.cyclops.cyclopscore.infobook.InfoBookParser;
9	import org.cyclops.cyclopscore.infobook.pageelement.SectionAppendix;
10	import org.cyclops.integrateddynamics.IntegratedDynamics;
11	import org.cyclops.integrateddynamics.Reference;
12	import org.cyclops.integrateddynamics.RegistryEntries;
13	import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
14	import org.cyclops.integrateddynamics.api.part.IPartType;
15	import org.cyclops.integrateddynamics.api.part.aspect.IAspect;
16	import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
17	import org.cyclops.integrateddynamics.core.part.PartTypes;
18	import org.cyclops.integrateddynamics.infobook.pageelement.*;
19	import org.cyclops.integrateddynamics.part.aspect.Aspects;
20	import org.w3c.dom.Element;
21
22	import javax.annotation.Nullable;
23	import java.util.List;
24
25	/**
26	* Infobook class for the On the Dynamics of Integration.
27	* @author rubensworks
28	*/
29	public class OnTheDynamicsOfIntegrationBook extends InfoBook {
30
31	private static OnTheDynamicsOfIntegrationBook _instance = null;	2✔
32
33	static {
34	InfoBookParser.registerAppendixRecipeFactories(RegistryEntries.RECIPETYPE_SQUEEZER.get(), SqueezerRecipeAppendix::new);	5✔
35	InfoBookParser.registerAppendixRecipeFactories(RegistryEntries.RECIPETYPE_MECHANICAL_SQUEEZER.get(), MechanicalSqueezerRecipeAppendix::new);	5✔
36	InfoBookParser.registerAppendixRecipeFactories(RegistryEntries.RECIPETYPE_DRYING_BASIN.get(), DryingBasinRecipeAppendix::new);	5✔
37	InfoBookParser.registerAppendixRecipeFactories(RegistryEntries.RECIPETYPE_MECHANICAL_DRYING_BASIN.get(), MechanicalDryingBasinRecipeAppendix::new);	5✔
38
39	InfoBookParser.registerAppendixFactory(Reference.MOD_ID + ":aspect", new InfoBookParser.IAppendixFactory() {	8✔
40	@Override
41	public SectionAppendix create(IInfoBook infoBook, Element node) throws InfoBookParser.InvalidAppendixException {
42	String aspectName = node.getTextContent();	×
43	IAspect aspect = Aspects.REGISTRY.getAspect(ResourceLocation.parse(aspectName));	×
44	if (aspect == null) {	×
45	throw new InfoBookParser.InvalidAppendixException(String.format("Could not find an aspect by name %s.", aspectName));	×
46	}
47	return new AspectAppendix(infoBook, aspect);	×
48	}
49	});
50
51	InfoBookParser.registerAppendixListFactory(Reference.MOD_ID + ":part_aspects", new InfoBookParser.IAppendixListFactory() {	8✔
52	@Override
53	public List<SectionAppendix> create(final IInfoBook infoBook, Element node) throws InfoBookParser.InvalidAppendixException {
54	String partName = node.getTextContent();	×
55	IPartType partType = PartTypes.REGISTRY.getPartType(ResourceLocation.parse(partName));	×
56	if (partType == null) {	×
57	throw new InfoBookParser.InvalidAppendixException(String.format("Could not find a part type by name '%s'.", partName));	×
58	}
59	List<IAspect> aspects = Lists.newArrayList(Aspects.REGISTRY.getAspects(partType));	×
60	return Lists.transform(aspects, new Function<IAspect, SectionAppendix>() {	×
61	@Nullable
62	@Override
63	public SectionAppendix apply(IAspect input) {
64	return new AspectAppendix(infoBook, input);	×
65	}
66	});
67	}
68	});
69
70	InfoBookParser.registerAppendixFactory(Reference.MOD_ID + ":operator", new InfoBookParser.IAppendixFactory() {	8✔
71	@Override
72	public SectionAppendix create(IInfoBook infoBook, Element node) throws InfoBookParser.InvalidAppendixException {
73	String operatorName = node.getTextContent();	×
74	IOperator operator = Operators.REGISTRY.getOperator(ResourceLocation.parse(operatorName));	×
75	if (operator == null) {	×
76	throw new InfoBookParser.InvalidAppendixException(String.format("Could not find an operator by name %s.", operatorName));	×
77	}
78	return new OperatorAppendix(infoBook, operator);	×
79	}
80	});
81
82	InfoBookParser.registerAppendixListFactory(Reference.MOD_ID + ":operators_output", new InfoBookParser.IAppendixListFactory() {	8✔
83	@Override
84	public List<SectionAppendix> create(final IInfoBook infoBook, Element node) throws InfoBookParser.InvalidAppendixException {
85	String categoryName = node.getTextContent();	×
86	List<IOperator> operators = Lists.newArrayList("*".equals(categoryName) ? Operators.REGISTRY.getOperators() : Operators.REGISTRY.getOperatorsInCategory(categoryName));	×
87	if (operators.isEmpty()) {	×
88	operators = Lists.newArrayList();	×
89	for (IOperator operator : Operators.REGISTRY.getOperators()) {	×
90	if (operator.getUniqueName().toString().matches(categoryName)) {	×
91	operators.add(operator);	×
92	}
93	}	×
94	}
95	return Lists.transform(operators, new Function<IOperator, SectionAppendix>() {	×
96	@Nullable
97	@Override
98	public SectionAppendix apply(IOperator input) {
99	return new OperatorAppendix(infoBook, input);	×
100	}
101	});
102	}
103	});
104	}	1✔
105
106	private OnTheDynamicsOfIntegrationBook() {
107	super(IntegratedDynamics._instance, 2, Reference.BOOK_URL);	5✔
108	}	1✔
109
110	public static synchronized OnTheDynamicsOfIntegrationBook getInstance() {
111	if(_instance == null) {	2!
112	_instance = new OnTheDynamicsOfIntegrationBook();	4✔
113	}
114	return _instance;	2✔
115	}
116	}

CyclopsMC / IntegratedDynamics / 18042102834

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