18384427956

Committed 09 Oct 2025 05:46PM UTC coverage: 53.031% (-0.04%) from 53.071%

Build # 18384427956

Build Type

push

github

Committed by

rubensworks

Commit Message

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

Run Details

2863 of 8762 branches covered (32.68%)

Branch coverage included in aggregate %.

17326 of 29308 relevant lines covered (59.12%)

3.07 hits per line

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

23.53

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

package org.cyclops.integrateddynamics.infobook;

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 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));
                List<SectionAppendix> appendices = Lists.newArrayList();
                for (IAspect aspect : aspects) {
                    appendices.add(new AspectAppendix(infoBook, aspect));
                }
                return appendices;
            }
        });

        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);
                        }
                    }
                }
                List<SectionAppendix> appendices = Lists.newArrayList();
                for (IOperator operator : operators) {
                    appendices.add(new OperatorAppendix(infoBook, operator));
                }
                return appendices;
            }
        });
    }

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

CyclopsMC / IntegratedDynamics / 18384427956

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