X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=core%2Fsrc%2Fnet%2Fsf%2Fopenrocket%2Ffile%2Fopenrocket%2Fimportt%2FOpenRocketLoader.java;h=d6c4e249347ded9bdac0d6a8c8a0f9361ff80b24;hb=77f2457dc781c8c517ddef157c18491ad770f6c6;hp=eee1dae68aadd6ae2daab91f0a45550134297cbb;hpb=a297db7cfb4074b8e60152cdfb9a8ceecd1e4c2b;p=debian%2Fopenrocket diff --git a/core/src/net/sf/openrocket/file/openrocket/importt/OpenRocketLoader.java b/core/src/net/sf/openrocket/file/openrocket/importt/OpenRocketLoader.java index eee1dae6..d6c4e249 100644 --- a/core/src/net/sf/openrocket/file/openrocket/importt/OpenRocketLoader.java +++ b/core/src/net/sf/openrocket/file/openrocket/importt/OpenRocketLoader.java @@ -28,6 +28,7 @@ import net.sf.openrocket.file.simplesax.SimpleSAX; import net.sf.openrocket.logging.LogHelper; import net.sf.openrocket.material.Material; import net.sf.openrocket.motor.Motor; +import net.sf.openrocket.preset.ComponentPreset; import net.sf.openrocket.rocketcomponent.BodyComponent; import net.sf.openrocket.rocketcomponent.BodyTube; import net.sf.openrocket.rocketcomponent.Bulkhead; @@ -66,6 +67,7 @@ import net.sf.openrocket.rocketcomponent.ThicknessRingComponent; import net.sf.openrocket.rocketcomponent.Transition; import net.sf.openrocket.rocketcomponent.TrapezoidFinSet; import net.sf.openrocket.rocketcomponent.TubeCoupler; +import net.sf.openrocket.simulation.customexpression.CustomExpression; import net.sf.openrocket.simulation.FlightData; import net.sf.openrocket.simulation.FlightDataBranch; import net.sf.openrocket.simulation.FlightDataType; @@ -97,30 +99,30 @@ import org.xml.sax.SAXException; */ public class OpenRocketLoader extends AbstractRocketLoader { private static final LogHelper log = Application.getLogger(); - - + + @Override public OpenRocketDocument loadFromStream(InputStream source, MotorFinder motorFinder) throws RocketLoadException, - IOException { + IOException { log.info("Loading .ork file"); DocumentLoadingContext context = new DocumentLoadingContext(); context.setMotorFinder(motorFinder); - + InputSource xmlSource = new InputSource(source); OpenRocketHandler handler = new OpenRocketHandler(context); - - + + try { SimpleSAX.readXML(xmlSource, handler, warnings); } catch (SAXException e) { log.warn("Malformed XML in input"); throw new RocketLoadException("Malformed XML in input.", e); } - - + + OpenRocketDocument doc = handler.getDocument(); doc.getDefaultConfiguration().setAllStages(); - + // Deduce suitable time skip double timeSkip = StorageOptions.SIMULATION_DATA_NONE; for (Simulation s : doc.getSimulations()) { @@ -137,7 +139,7 @@ public class OpenRocketLoader extends AbstractRocketLoader { List list = branch.get(FlightDataType.TYPE_TIME); if (list == null) continue; - + double previousTime = Double.NaN; for (double time : list) { if (time - previousTime < timeSkip) @@ -147,33 +149,33 @@ public class OpenRocketLoader extends AbstractRocketLoader { } // Round value timeSkip = Math.rint(timeSkip * 100) / 100; - + doc.getDefaultStorageOptions().setSimulationTimeSkip(timeSkip); doc.getDefaultStorageOptions().setCompressionEnabled(false); // Set by caller if compressed doc.getDefaultStorageOptions().setExplicitlySet(false); - + doc.clearUndo(); log.info("Loading done"); return doc; } - + } class DocumentConfig { - + /* Remember to update OpenRocketSaver as well! */ - public static final String[] SUPPORTED_VERSIONS = { "1.0", "1.1", "1.2", "1.3", "1.4" }; - + public static final String[] SUPPORTED_VERSIONS = { "1.0", "1.1", "1.2", "1.3", "1.4", "1.5" }; + /** * Divisor used in converting an integer version to the point-represented version. * The integer version divided by this value is the major version and the remainder is * the minor version. For example 101 corresponds to file version "1.1". */ public static final int FILE_VERSION_DIVISOR = 100; - - + + //////// Component constructors static final HashMap> constructors = new HashMap>(); static { @@ -186,29 +188,29 @@ class DocumentConfig { constructors.put("ellipticalfinset", EllipticalFinSet.class.getConstructor(new Class[0])); constructors.put("freeformfinset", FreeformFinSet.class.getConstructor(new Class[0])); constructors.put("launchlug", LaunchLug.class.getConstructor(new Class[0])); - + // Internal components constructors.put("engineblock", EngineBlock.class.getConstructor(new Class[0])); constructors.put("innertube", InnerTube.class.getConstructor(new Class[0])); constructors.put("tubecoupler", TubeCoupler.class.getConstructor(new Class[0])); constructors.put("bulkhead", Bulkhead.class.getConstructor(new Class[0])); constructors.put("centeringring", CenteringRing.class.getConstructor(new Class[0])); - + constructors.put("masscomponent", MassComponent.class.getConstructor(new Class[0])); constructors.put("shockcord", ShockCord.class.getConstructor(new Class[0])); constructors.put("parachute", Parachute.class.getConstructor(new Class[0])); constructors.put("streamer", Streamer.class.getConstructor(new Class[0])); - + // Other constructors.put("stage", Stage.class.getConstructor(new Class[0])); - + } catch (NoSuchMethodException e) { throw new BugException( "Error in constructing the 'constructors' HashMap."); } } - - + + //////// Parameter setters /* * The keys are of the form Class:param, where Class is the class name and param @@ -236,7 +238,9 @@ class DocumentConfig { Reflection.findMethod(RocketComponent.class, "setOverrideSubcomponents", boolean.class))); setters.put("RocketComponent:comment", new StringSetter( Reflection.findMethod(RocketComponent.class, "setComment", String.class))); - + setters.put("RocketComponent:preset", new ComponentPresetSetter( + Reflection.findMethod(RocketComponent.class, "loadPreset", ComponentPreset.class))); + // ExternalComponent setters.put("ExternalComponent:finish", new EnumSetter( Reflection.findMethod(ExternalComponent.class, "setFinish", Finish.class), @@ -244,23 +248,23 @@ class DocumentConfig { setters.put("ExternalComponent:material", new MaterialSetter( Reflection.findMethod(ExternalComponent.class, "setMaterial", Material.class), Material.Type.BULK)); - + // BodyComponent setters.put("BodyComponent:length", new DoubleSetter( Reflection.findMethod(BodyComponent.class, "setLength", double.class))); - + // SymmetricComponent setters.put("SymmetricComponent:thickness", new DoubleSetter( Reflection.findMethod(SymmetricComponent.class, "setThickness", double.class), "filled", Reflection.findMethod(SymmetricComponent.class, "setFilled", boolean.class))); - + // BodyTube setters.put("BodyTube:radius", new DoubleSetter( Reflection.findMethod(BodyTube.class, "setOuterRadius", double.class), "auto", Reflection.findMethod(BodyTube.class, "setOuterRadiusAutomatic", boolean.class))); - + // Transition setters.put("Transition:shape", new EnumSetter( Reflection.findMethod(Transition.class, "setType", Transition.Shape.class), @@ -269,7 +273,7 @@ class DocumentConfig { Reflection.findMethod(Transition.class, "setClipped", boolean.class))); setters.put("Transition:shapeparameter", new DoubleSetter( Reflection.findMethod(Transition.class, "setShapeParameter", double.class))); - + setters.put("Transition:foreradius", new DoubleSetter( Reflection.findMethod(Transition.class, "setForeRadius", double.class), "auto", @@ -278,7 +282,7 @@ class DocumentConfig { Reflection.findMethod(Transition.class, "setAftRadius", double.class), "auto", Reflection.findMethod(Transition.class, "setAftRadiusAutomatic", boolean.class))); - + setters.put("Transition:foreshoulderradius", new DoubleSetter( Reflection.findMethod(Transition.class, "setForeShoulderRadius", double.class))); setters.put("Transition:foreshoulderlength", new DoubleSetter( @@ -287,7 +291,7 @@ class DocumentConfig { Reflection.findMethod(Transition.class, "setForeShoulderThickness", double.class))); setters.put("Transition:foreshouldercapped", new BooleanSetter( Reflection.findMethod(Transition.class, "setForeShoulderCapped", boolean.class))); - + setters.put("Transition:aftshoulderradius", new DoubleSetter( Reflection.findMethod(Transition.class, "setAftShoulderRadius", double.class))); setters.put("Transition:aftshoulderlength", new DoubleSetter( @@ -296,14 +300,14 @@ class DocumentConfig { Reflection.findMethod(Transition.class, "setAftShoulderThickness", double.class))); setters.put("Transition:aftshouldercapped", new BooleanSetter( Reflection.findMethod(Transition.class, "setAftShoulderCapped", boolean.class))); - + // NoseCone - disable disallowed elements setters.put("NoseCone:foreradius", null); setters.put("NoseCone:foreshoulderradius", null); setters.put("NoseCone:foreshoulderlength", null); setters.put("NoseCone:foreshoulderthickness", null); setters.put("NoseCone:foreshouldercapped", null); - + // FinSet setters.put("FinSet:fincount", new IntSetter( Reflection.findMethod(FinSet.class, "setFinCount", int.class))); @@ -321,7 +325,7 @@ class DocumentConfig { setters.put("FinSet:tablength", new DoubleSetter( Reflection.findMethod(FinSet.class, "setTabLength", double.class))); setters.put("FinSet:tabposition", new FinTabPositionSetter()); - + // TrapezoidFinSet setters.put("TrapezoidFinSet:rootchord", new DoubleSetter( Reflection.findMethod(TrapezoidFinSet.class, "setRootChord", double.class))); @@ -331,15 +335,15 @@ class DocumentConfig { Reflection.findMethod(TrapezoidFinSet.class, "setSweep", double.class))); setters.put("TrapezoidFinSet:height", new DoubleSetter( Reflection.findMethod(TrapezoidFinSet.class, "setHeight", double.class))); - + // EllipticalFinSet setters.put("EllipticalFinSet:rootchord", new DoubleSetter( Reflection.findMethod(EllipticalFinSet.class, "setLength", double.class))); setters.put("EllipticalFinSet:height", new DoubleSetter( Reflection.findMethod(EllipticalFinSet.class, "setHeight", double.class))); - + // FreeformFinSet points handled as a special handler - + // LaunchLug setters.put("LaunchLug:radius", new DoubleSetter( Reflection.findMethod(LaunchLug.class, "setOuterRadius", double.class))); @@ -350,14 +354,14 @@ class DocumentConfig { setters.put("LaunchLug:radialdirection", new DoubleSetter( Reflection.findMethod(LaunchLug.class, "setRadialDirection", double.class), Math.PI / 180.0)); - + // InternalComponent - nothing - + // StructuralComponent setters.put("StructuralComponent:material", new MaterialSetter( Reflection.findMethod(StructuralComponent.class, "setMaterial", Material.class), Material.Type.BULK)); - + // RingComponent setters.put("RingComponent:length", new DoubleSetter( Reflection.findMethod(RingComponent.class, "setLength", double.class))); @@ -366,23 +370,23 @@ class DocumentConfig { setters.put("RingComponent:radialdirection", new DoubleSetter( Reflection.findMethod(RingComponent.class, "setRadialDirection", double.class), Math.PI / 180.0)); - + // ThicknessRingComponent - radius on separate components due to differing automatics setters.put("ThicknessRingComponent:thickness", new DoubleSetter( Reflection.findMethod(ThicknessRingComponent.class, "setThickness", double.class))); - + // EngineBlock setters.put("EngineBlock:outerradius", new DoubleSetter( Reflection.findMethod(EngineBlock.class, "setOuterRadius", double.class), "auto", Reflection.findMethod(EngineBlock.class, "setOuterRadiusAutomatic", boolean.class))); - + // TubeCoupler setters.put("TubeCoupler:outerradius", new DoubleSetter( Reflection.findMethod(TubeCoupler.class, "setOuterRadius", double.class), "auto", Reflection.findMethod(TubeCoupler.class, "setOuterRadiusAutomatic", boolean.class))); - + // InnerTube setters.put("InnerTube:outerradius", new DoubleSetter( Reflection.findMethod(InnerTube.class, "setOuterRadius", double.class))); @@ -392,9 +396,9 @@ class DocumentConfig { setters.put("InnerTube:clusterrotation", new DoubleSetter( Reflection.findMethod(InnerTube.class, "setClusterRotation", double.class), Math.PI / 180.0)); - + // RadiusRingComponent - + // Bulkhead setters.put("RadiusRingComponent:innerradius", new DoubleSetter( Reflection.findMethod(RadiusRingComponent.class, "setInnerRadius", double.class))); @@ -402,7 +406,7 @@ class DocumentConfig { Reflection.findMethod(Bulkhead.class, "setOuterRadius", double.class), "auto", Reflection.findMethod(Bulkhead.class, "setOuterRadiusAutomatic", boolean.class))); - + // CenteringRing setters.put("CenteringRing:innerradius", new DoubleSetter( Reflection.findMethod(CenteringRing.class, "setInnerRadius", double.class), @@ -412,8 +416,8 @@ class DocumentConfig { Reflection.findMethod(CenteringRing.class, "setOuterRadius", double.class), "auto", Reflection.findMethod(CenteringRing.class, "setOuterRadiusAutomatic", boolean.class))); - - + + // MassObject setters.put("MassObject:packedlength", new DoubleSetter( Reflection.findMethod(MassObject.class, "setLength", double.class))); @@ -424,18 +428,18 @@ class DocumentConfig { setters.put("MassObject:radialdirection", new DoubleSetter( Reflection.findMethod(MassObject.class, "setRadialDirection", double.class), Math.PI / 180.0)); - + // MassComponent setters.put("MassComponent:mass", new DoubleSetter( Reflection.findMethod(MassComponent.class, "setComponentMass", double.class))); - + // ShockCord setters.put("ShockCord:cordlength", new DoubleSetter( Reflection.findMethod(ShockCord.class, "setCordLength", double.class))); setters.put("ShockCord:material", new MaterialSetter( Reflection.findMethod(ShockCord.class, "setMaterial", Material.class), Material.Type.LINE)); - + // RecoveryDevice setters.put("RecoveryDevice:cd", new DoubleSetter( Reflection.findMethod(RecoveryDevice.class, "setCD", double.class), @@ -451,7 +455,7 @@ class DocumentConfig { setters.put("RecoveryDevice:material", new MaterialSetter( Reflection.findMethod(RecoveryDevice.class, "setMaterial", Material.class), Material.Type.SURFACE)); - + // Parachute setters.put("Parachute:diameter", new DoubleSetter( Reflection.findMethod(Parachute.class, "setDiameter", double.class))); @@ -462,13 +466,13 @@ class DocumentConfig { setters.put("Parachute:linematerial", new MaterialSetter( Reflection.findMethod(Parachute.class, "setLineMaterial", Material.class), Material.Type.LINE)); - + // Streamer setters.put("Streamer:striplength", new DoubleSetter( Reflection.findMethod(Streamer.class, "setStripLength", double.class))); setters.put("Streamer:stripwidth", new DoubleSetter( Reflection.findMethod(Streamer.class, "setStripWidth", double.class))); - + // Rocket // handled by separate handler setters.put("Rocket:referencetype", new EnumSetter( @@ -480,17 +484,17 @@ class DocumentConfig { Reflection.findMethod(Rocket.class, "setDesigner", String.class))); setters.put("Rocket:revision", new StringSetter( Reflection.findMethod(Rocket.class, "setRevision", String.class))); - + // Stage setters.put("Stage:separationevent", new EnumSetter( Reflection.findMethod(Stage.class, "setSeparationEvent", Stage.SeparationEvent.class), Stage.SeparationEvent.class)); setters.put("Stage:separationdelay", new DoubleSetter( Reflection.findMethod(Stage.class, "setSeparationDelay", double.class))); - + } - - + + /** * Search for a enum value that has the corresponding name as an XML value. The current * conversion from enum name to XML value is to lowercase the name and strip out all @@ -504,7 +508,7 @@ class DocumentConfig { */ public static > Enum findEnum(String name, Class> enumClass) { - + if (name == null) return null; name = name.trim(); @@ -515,8 +519,8 @@ class DocumentConfig { } return null; } - - + + /** * Convert a string to a double including formatting specifications of the OpenRocket * file format. This accepts all formatting that is valid for @@ -550,11 +554,11 @@ class DocumentConfig { class OpenRocketHandler extends AbstractElementHandler { private final DocumentLoadingContext context; private OpenRocketContentHandler handler = null; - + public OpenRocketHandler(DocumentLoadingContext context) { this.context = context; } - + /** * Return the OpenRocketDocument read from the file, or null if a document * has not been read yet. @@ -564,24 +568,24 @@ class OpenRocketHandler extends AbstractElementHandler { public OpenRocketDocument getDocument() { return handler.getDocument(); } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + // Check for unknown elements if (!element.equals("openrocket")) { warnings.add(Warning.fromString("Unknown element " + element + ", ignoring.")); return null; } - + // Check for first call if (handler != null) { warnings.add(Warning.fromString("Multiple document elements found, ignoring later " + "ones.")); return null; } - + // Check version number String version = null; String creator = attributes.remove("creator"); @@ -601,18 +605,18 @@ class OpenRocketHandler extends AbstractElementHandler { str += ", attempting to read file anyway."; warnings.add(str); } - + context.setFileVersion(parseVersion(docVersion)); - + handler = new OpenRocketContentHandler(context); return handler; } - - + + private int parseVersion(String docVersion) { if (docVersion == null) return 0; - + Matcher m = Pattern.compile("^([0-9]+)\\.([0-9]+)$").matcher(docVersion); if (m.matches()) { int major = Integer.parseInt(m.group(1)); @@ -622,7 +626,7 @@ class OpenRocketHandler extends AbstractElementHandler { return 0; } } - + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) throws SAXException { @@ -630,8 +634,8 @@ class OpenRocketHandler extends AbstractElementHandler { attributes.remove("creator"); super.closeElement(element, attributes, content, warnings); } - - + + } @@ -642,27 +646,27 @@ class OpenRocketContentHandler extends AbstractElementHandler { private final DocumentLoadingContext context; private final OpenRocketDocument doc; private final Rocket rocket; - + private boolean rocketDefined = false; private boolean simulationsDefined = false; - + private boolean datatypesDefined = false; + public OpenRocketContentHandler(DocumentLoadingContext context) { this.context = context; this.rocket = new Rocket(); this.doc = new OpenRocketDocument(rocket); } - - + public OpenRocketDocument getDocument() { if (!rocketDefined) return null; return doc; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + if (element.equals("rocket")) { if (rocketDefined) { warnings.add(Warning @@ -674,6 +678,15 @@ class OpenRocketContentHandler extends AbstractElementHandler { return new ComponentParameterHandler(rocket, context); } + if (element.equals("datatypes")){ + if (datatypesDefined) { + warnings.add(Warning.fromString("Multiple datatype blocks. Ignoring later ones.")); + return null; + } + datatypesDefined = true; + return new DatatypeHandler(this, context); + } + if (element.equals("simulations")) { if (simulationsDefined) { warnings.add(Warning @@ -684,15 +697,99 @@ class OpenRocketContentHandler extends AbstractElementHandler { simulationsDefined = true; return new SimulationsHandler(doc, context); } - + warnings.add(Warning.fromString("Unknown element " + element + ", ignoring.")); - + return null; } } +class DatatypeHandler extends AbstractElementHandler { + private final DocumentLoadingContext context; + private final OpenRocketContentHandler contentHandler; + private CustomExpressionHandler customExpressionHandler = null; + + public DatatypeHandler(OpenRocketContentHandler contentHandler, DocumentLoadingContext context) { + this.context = context; + this.contentHandler = contentHandler; + } + + @Override + public ElementHandler openElement(String element, + HashMap attributes, WarningSet warnings) + throws SAXException { + + if (element.equals("type") && attributes.get("source").equals("customexpression") ){ + customExpressionHandler = new CustomExpressionHandler(contentHandler, context); + return customExpressionHandler; + } + else { + warnings.add(Warning.fromString("Unknown datatype " + element + " defined, ignoring")); + } + + return this; + } + + @Override + public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) throws SAXException { + attributes.remove("source"); + super.closeElement(element, attributes, content, warnings); + + if (customExpressionHandler != null){ + contentHandler.getDocument().addCustomExpression(customExpressionHandler.currentExpression); + } + + } + +} + +class CustomExpressionHandler extends AbstractElementHandler{ + private final DocumentLoadingContext context; + private final OpenRocketContentHandler contentHandler; + public CustomExpression currentExpression; + + public CustomExpressionHandler(OpenRocketContentHandler contentHandler, DocumentLoadingContext context) { + this.context = context; + this.contentHandler = contentHandler; + currentExpression = new CustomExpression(contentHandler.getDocument()); + + } + + @Override + public ElementHandler openElement(String element, + HashMap attributes, WarningSet warnings) + throws SAXException { + + return this; + } + + @Override + public void closeElement(String element, HashMap attributes, + String content, WarningSet warnings) throws SAXException { + + if (element.equals("type")) { + contentHandler.getDocument().addCustomExpression(currentExpression); + } + + if (element.equals("name")) { + currentExpression.setName(content); + } + + if (element.equals("symbol")) { + currentExpression.setSymbol(content); + } + + if (element.equals("unit") && attributes.get("unittype").equals("auto")) { + currentExpression.setUnit(content); + } + + if (element.equals("expression")){ + currentExpression.setExpression(content); + } + } +} /** * A handler that creates components from the corresponding elements. The control of the @@ -701,16 +798,16 @@ class OpenRocketContentHandler extends AbstractElementHandler { class ComponentHandler extends AbstractElementHandler { private final DocumentLoadingContext context; private final RocketComponent parent; - + public ComponentHandler(RocketComponent parent, DocumentLoadingContext context) { this.parent = parent; this.context = context; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + // Attempt to construct new component Constructor constructor = DocumentConfig.constructors .get(element); @@ -718,7 +815,7 @@ class ComponentHandler extends AbstractElementHandler { warnings.add(Warning.fromString("Unknown element " + element + ", ignoring.")); return null; } - + RocketComponent c; try { c = constructor.newInstance(); @@ -729,9 +826,9 @@ class ComponentHandler extends AbstractElementHandler { } catch (InvocationTargetException e) { throw Reflection.handleWrappedException(e); } - + parent.addChild(c); - + return new ComponentParameterHandler(c, context); } } @@ -745,16 +842,16 @@ class ComponentHandler extends AbstractElementHandler { class ComponentParameterHandler extends AbstractElementHandler { private final DocumentLoadingContext context; private final RocketComponent component; - + public ComponentParameterHandler(RocketComponent c, DocumentLoadingContext context) { this.component = c; this.context = context; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + // Check for specific elements that contain other elements if (element.equals("subcomponents")) { return new ComponentHandler(component, context); @@ -780,22 +877,22 @@ class ComponentParameterHandler extends AbstractElementHandler { } return new MotorConfigurationHandler((Rocket) component, context); } - - + + return PlainTextHandler.INSTANCE; } - + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) { - + if (element.equals("subcomponents") || element.equals("motormount") || element.equals("finpoints") || element.equals("motorconfiguration")) { return; } - + // Search for the correct setter class - + Class c; for (c = component.getClass(); c != null; c = c.getSuperclass()) { String setterKey = c.getSimpleName() + ":" + element; @@ -828,23 +925,23 @@ class FinSetPointHandler extends AbstractElementHandler { private final DocumentLoadingContext context; private final FreeformFinSet finset; private final ArrayList coordinates = new ArrayList(); - + public FinSetPointHandler(FreeformFinSet finset, DocumentLoadingContext context) { this.finset = finset; this.context = context; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { return PlainTextHandler.INSTANCE; } - - + + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) throws SAXException { - + String strx = attributes.remove("x"); String stry = attributes.remove("y"); if (strx == null || stry == null) { @@ -859,10 +956,10 @@ class FinSetPointHandler extends AbstractElementHandler { warnings.add(Warning.fromString("Illegal fin points specification, ignoring.")); return; } - + super.closeElement(element, attributes, content, warnings); } - + @Override public void endHandler(String element, HashMap attributes, String content, WarningSet warnings) { @@ -879,51 +976,51 @@ class MotorMountHandler extends AbstractElementHandler { private final DocumentLoadingContext context; private final MotorMount mount; private MotorHandler motorHandler; - + public MotorMountHandler(MotorMount mount, DocumentLoadingContext context) { this.mount = mount; this.context = context; mount.setMotorMount(true); } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + if (element.equals("motor")) { motorHandler = new MotorHandler(context); return motorHandler; } - + if (element.equals("ignitionevent") || element.equals("ignitiondelay") || element.equals("overhang")) { return PlainTextHandler.INSTANCE; } - + warnings.add(Warning.fromString("Unknown element '" + element + "' encountered, ignoring.")); return null; } - - - + + + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) throws SAXException { - + if (element.equals("motor")) { String id = attributes.get("configid"); if (id == null || id.equals("")) { warnings.add(Warning.fromString("Illegal motor specification, ignoring.")); return; } - + Motor motor = motorHandler.getMotor(warnings); mount.setMotor(id, motor); mount.setMotorDelay(id, motorHandler.getDelay(warnings)); return; } - + if (element.equals("ignitionevent")) { MotorMount.IgnitionEvent event = null; for (MotorMount.IgnitionEvent e : MotorMount.IgnitionEvent.values()) { @@ -939,7 +1036,7 @@ class MotorMountHandler extends AbstractElementHandler { mount.setIgnitionEvent(event); return; } - + if (element.equals("ignitiondelay")) { double d; try { @@ -951,7 +1048,7 @@ class MotorMountHandler extends AbstractElementHandler { mount.setIgnitionDelay(d); return; } - + if (element.equals("overhang")) { double d; try { @@ -963,7 +1060,7 @@ class MotorMountHandler extends AbstractElementHandler { mount.setMotorOverhang(d); return; } - + super.closeElement(element, attributes, content, warnings); } } @@ -977,54 +1074,54 @@ class MotorConfigurationHandler extends AbstractElementHandler { private final Rocket rocket; private String name = null; private boolean inNameElement = false; - + public MotorConfigurationHandler(Rocket rocket, DocumentLoadingContext context) { this.rocket = rocket; this.context = context; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + if (inNameElement || !element.equals("name")) { warnings.add(Warning.FILE_INVALID_PARAMETER); return null; } inNameElement = true; - + return PlainTextHandler.INSTANCE; } - + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) { name = content; } - + @Override public void endHandler(String element, HashMap attributes, String content, WarningSet warnings) throws SAXException { - + String configid = attributes.remove("configid"); if (configid == null || configid.equals("")) { warnings.add(Warning.FILE_INVALID_PARAMETER); return; } - + if (!rocket.addMotorConfigurationID(configid)) { warnings.add("Duplicate motor configuration ID used."); return; } - + if (name != null && name.trim().length() > 0) { rocket.setMotorConfigurationName(configid, name); } - + if ("true".equals(attributes.remove("default"))) { rocket.getDefaultConfiguration().setMotorConfigurationID(configid); } - + super.closeElement(element, attributes, content, warnings); } } @@ -1033,7 +1130,7 @@ class MotorConfigurationHandler extends AbstractElementHandler { class MotorHandler extends AbstractElementHandler { /** File version where latest digest format was introduced */ private static final int MOTOR_DIGEST_VERSION = 104; - + private final DocumentLoadingContext context; private Motor.Type type = null; private String manufacturer = null; @@ -1042,26 +1139,26 @@ class MotorHandler extends AbstractElementHandler { private double diameter = Double.NaN; private double length = Double.NaN; private double delay = Double.NaN; - + public MotorHandler(DocumentLoadingContext context) { this.context = context; } - - + + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { return PlainTextHandler.INSTANCE; } - - + + /** * Return the motor to use, or null. */ public Motor getMotor(WarningSet warnings) { return context.getMotorFinder().findMotor(type, manufacturer, designation, diameter, length, digest, warnings); } - + /** * Return the delay to use for the motor. */ @@ -1072,16 +1169,16 @@ class MotorHandler extends AbstractElementHandler { } return delay; } - - + + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) throws SAXException { - + content = content.trim(); - + if (element.equals("type")) { - + // Motor type type = null; for (Motor.Type t : Motor.Type.values()) { @@ -1093,26 +1190,26 @@ class MotorHandler extends AbstractElementHandler { if (type == null) { warnings.add(Warning.fromString("Unknown motor type '" + content + "', ignoring.")); } - + } else if (element.equals("manufacturer")) { - + // Manufacturer manufacturer = content.trim(); - + } else if (element.equals("designation")) { - + // Designation designation = content.trim(); - + } else if (element.equals("digest")) { - + // Digest is used only for file versions saved using the same digest algorithm if (context.getFileVersion() >= MOTOR_DIGEST_VERSION) { digest = content.trim(); } - + } else if (element.equals("diameter")) { - + // Diameter diameter = Double.NaN; try { @@ -1123,22 +1220,22 @@ class MotorHandler extends AbstractElementHandler { if (Double.isNaN(diameter)) { warnings.add(Warning.fromString("Illegal motor diameter specified, ignoring.")); } - + } else if (element.equals("length")) { - + // Length length = Double.NaN; try { length = Double.parseDouble(content.trim()); } catch (NumberFormatException ignore) { } - + if (Double.isNaN(length)) { warnings.add(Warning.fromString("Illegal motor diameter specified, ignoring.")); } - + } else if (element.equals("delay")) { - + // Delay delay = Double.NaN; if (content.equals("none")) { @@ -1148,18 +1245,18 @@ class MotorHandler extends AbstractElementHandler { delay = Double.parseDouble(content.trim()); } catch (NumberFormatException ignore) { } - + if (Double.isNaN(delay)) { warnings.add(Warning.fromString("Illegal motor delay specified, ignoring.")); } - + } - + } else { super.closeElement(element, attributes, content, warnings); } } - + } @@ -1168,58 +1265,61 @@ class SimulationsHandler extends AbstractElementHandler { private final DocumentLoadingContext context; private final OpenRocketDocument doc; private SingleSimulationHandler handler; - + public SimulationsHandler(OpenRocketDocument doc, DocumentLoadingContext context) { this.doc = doc; this.context = context; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + if (!element.equals("simulation")) { warnings.add("Unknown element '" + element + "', ignoring."); return null; } - + handler = new SingleSimulationHandler(doc, context); return handler; } - + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) throws SAXException { attributes.remove("status"); super.closeElement(element, attributes, content, warnings); } - - + + } class SingleSimulationHandler extends AbstractElementHandler { + private final DocumentLoadingContext context; - + private final OpenRocketDocument doc; - + private String name; - + private SimulationConditionsHandler conditionHandler; private FlightDataHandler dataHandler; private final List listeners = new ArrayList(); - + public SingleSimulationHandler(OpenRocketDocument doc, DocumentLoadingContext context) { this.doc = doc; this.context = context; } - - + + public OpenRocketDocument getDocument(){ + return doc; + } @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + if (element.equals("name") || element.equals("simulator") || element.equals("calculator") || element.equals("listener")) { return PlainTextHandler.INSTANCE; @@ -1227,18 +1327,18 @@ class SingleSimulationHandler extends AbstractElementHandler { conditionHandler = new SimulationConditionsHandler(doc.getRocket(), context); return conditionHandler; } else if (element.equals("flightdata")) { - dataHandler = new FlightDataHandler(context); + dataHandler = new FlightDataHandler(this, context); return dataHandler; } else { warnings.add("Unknown element '" + element + "', ignoring."); return null; } } - + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) { - + if (element.equals("name")) { name = content; } else if (element.equals("simulator")) { @@ -1252,20 +1352,20 @@ class SingleSimulationHandler extends AbstractElementHandler { } else if (element.equals("listener") && content.trim().length() > 0) { listeners.add(content.trim()); } - + } - + @Override public void endHandler(String element, HashMap attributes, String content, WarningSet warnings) { - + String s = attributes.get("status"); Simulation.Status status = (Status) DocumentConfig.findEnum(s, Simulation.Status.class); if (status == null) { warnings.add("Simulation status unknown, assuming outdated."); status = Simulation.Status.OUTDATED; } - + SimulationOptions conditions; if (conditionHandler != null) { conditions = conditionHandler.getConditions(); @@ -1273,41 +1373,39 @@ class SingleSimulationHandler extends AbstractElementHandler { warnings.add("Simulation conditions not defined, using defaults."); conditions = new SimulationOptions(doc.getRocket()); } - + if (name == null) name = "Simulation"; - + FlightData data; if (dataHandler == null) data = null; else data = dataHandler.getFlightData(); - + Simulation simulation = new Simulation(doc.getRocket(), status, name, conditions, listeners, data); - + doc.addSimulation(simulation); } } - - - + class SimulationConditionsHandler extends AbstractElementHandler { private final DocumentLoadingContext context; private SimulationOptions conditions; private AtmosphereHandler atmosphereHandler; - + public SimulationConditionsHandler(Rocket rocket, DocumentLoadingContext context) { this.context = context; conditions = new SimulationOptions(rocket); // Set up default loading settings (which may differ from the new defaults) conditions.setGeodeticComputation(GeodeticComputationStrategy.FLAT); } - + public SimulationOptions getConditions() { return conditions; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { @@ -1317,18 +1415,18 @@ class SimulationConditionsHandler extends AbstractElementHandler { } return PlainTextHandler.INSTANCE; } - + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) { - + double d = Double.NaN; try { d = Double.parseDouble(content); } catch (NumberFormatException ignore) { } - - + + if (element.equals("configid")) { if (content.equals("")) { conditions.setMotorConfigurationID(null); @@ -1410,28 +1508,28 @@ class AtmosphereHandler extends AbstractElementHandler { private final String model; private double temperature = Double.NaN; private double pressure = Double.NaN; - + public AtmosphereHandler(String model, DocumentLoadingContext context) { this.model = model; this.context = context; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { return PlainTextHandler.INSTANCE; } - + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) throws SAXException { - + double d = Double.NaN; try { d = Double.parseDouble(content); } catch (NumberFormatException ignore) { } - + if (element.equals("basetemperature")) { if (Double.isNaN(d)) { warnings.add("Illegal base temperature specified, ignoring."); @@ -1446,8 +1544,8 @@ class AtmosphereHandler extends AbstractElementHandler { super.closeElement(element, attributes, content, warnings); } } - - + + public void storeSettings(SimulationOptions cond, WarningSet warnings) { if (!Double.isNaN(pressure)) { cond.setLaunchPressure(pressure); @@ -1455,7 +1553,7 @@ class AtmosphereHandler extends AbstractElementHandler { if (!Double.isNaN(temperature)) { cond.setLaunchTemperature(temperature); } - + if ("isa".equals(model)) { cond.setISAAtmosphere(true); } else if ("extendedisa".equals(model)) { @@ -1465,32 +1563,34 @@ class AtmosphereHandler extends AbstractElementHandler { warnings.add("Unknown atmospheric model, using ISA."); } } - + } class FlightDataHandler extends AbstractElementHandler { private final DocumentLoadingContext context; - + private FlightDataBranchHandler dataHandler; private WarningSet warningSet = new WarningSet(); private List branches = new ArrayList(); + private SingleSimulationHandler simHandler; private FlightData data; - - - public FlightDataHandler(DocumentLoadingContext context) { + + + public FlightDataHandler(SingleSimulationHandler simHandler, DocumentLoadingContext context) { this.context = context; + this.simHandler = simHandler; } - + public FlightData getFlightData() { return data; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + if (element.equals("warning")) { return PlainTextHandler.INSTANCE; } @@ -1499,20 +1599,21 @@ class FlightDataHandler extends AbstractElementHandler { warnings.add("Illegal flight data definition, ignoring."); return null; } - dataHandler = new FlightDataBranchHandler(attributes.get("name"), - attributes.get("types"), context); + dataHandler = new FlightDataBranchHandler( attributes.get("name"), + attributes.get("types"), + simHandler, context); return dataHandler; } - + warnings.add("Unknown element '" + element + "' encountered, ignoring."); return null; } - - + + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) { - + if (element.equals("databranch")) { FlightDataBranch branch = dataHandler.getBranch(); if (branch.getLength() > 0) { @@ -1522,12 +1623,12 @@ class FlightDataHandler extends AbstractElementHandler { warningSet.add(Warning.fromString(content)); } } - - + + @Override public void endHandler(String element, HashMap attributes, String content, WarningSet warnings) { - + if (branches.size() > 0) { data = new FlightData(branches.toArray(new FlightDataBranch[0])); } else { @@ -1540,7 +1641,7 @@ class FlightDataHandler extends AbstractElementHandler { double groundHitVelocity = Double.NaN; double launchRodVelocity = Double.NaN; double deploymentVelocity = Double.NaN; - + try { maxAltitude = DocumentConfig.stringToDouble(attributes.get("maxaltitude")); } catch (NumberFormatException ignore) { @@ -1578,16 +1679,16 @@ class FlightDataHandler extends AbstractElementHandler { deploymentVelocity = DocumentConfig.stringToDouble(attributes.get("deploymentvelocity")); } catch (NumberFormatException ignore) { } - + data = new FlightData(maxAltitude, maxVelocity, maxAcceleration, maxMach, timeToApogee, flightTime, groundHitVelocity, launchRodVelocity, deploymentVelocity); } - + data.getWarningSet().addAll(warningSet); data.immute(); } - - + + } @@ -1597,77 +1698,118 @@ class FlightDataBranchHandler extends AbstractElementHandler { private final FlightDataType[] types; private final FlightDataBranch branch; - public FlightDataBranchHandler(String name, String typeList, DocumentLoadingContext context) { + private static final LogHelper log = Application.getLogger(); + private final SingleSimulationHandler simHandler; + + public FlightDataBranchHandler(String name, String typeList, SingleSimulationHandler simHandler, DocumentLoadingContext context) { + this.simHandler = simHandler; this.context = context; String[] split = typeList.split(","); types = new FlightDataType[split.length]; for (int i = 0; i < split.length; i++) { - types[i] = FlightDataType.getType(split[i], UnitGroup.UNITS_NONE); + String typeName = split[i]; + FlightDataType matching = findFlightDataType(typeName); + types[i] = matching; + //types[i] = FlightDataType.getType(typeName, matching.getSymbol(), matching.getUnitGroup()); } - + // TODO: LOW: May throw an IllegalArgumentException branch = new FlightDataBranch(name, types); } + // Find the full flight data type given name only + // Note: this way of doing it requires that custom expressions always come before flight data in the file, + // not the nicest but this is always the case anyway. + private FlightDataType findFlightDataType(String name){ + + // Kevins version with lookup by key. Not using right now + /* + if ( key != null ) { + for (FlightDataType t : FlightDataType.ALL_TYPES){ + if (t.getKey().equals(key) ){ + return t; + } + } + } + */ + + // Look in built in types + for (FlightDataType t : FlightDataType.ALL_TYPES){ + if (t.getName().equals(name) ){ + return t; + } + } + + // Look in custom expressions + for (CustomExpression exp : simHandler.getDocument().getCustomExpressions()){ + if (exp.getName().equals(name) ){ + return exp.getType(); + } + } + + log.warn("Could not find the flight data type '"+name+"' used in the XML file. Substituted type with unknown symbol and units."); + return FlightDataType.getType(name, "Unknown", UnitGroup.UNITS_NONE); + } + public FlightDataBranch getBranch() { branch.immute(); return branch; } - + @Override public ElementHandler openElement(String element, HashMap attributes, WarningSet warnings) { - + if (element.equals("datapoint")) return PlainTextHandler.INSTANCE; if (element.equals("event")) return PlainTextHandler.INSTANCE; - + warnings.add("Unknown element '" + element + "' encountered, ignoring."); return null; } - - + + @Override public void closeElement(String element, HashMap attributes, String content, WarningSet warnings) { - + if (element.equals("event")) { double time; FlightEvent.Type type; - + try { time = DocumentConfig.stringToDouble(attributes.get("time")); } catch (NumberFormatException e) { warnings.add("Illegal event specification, ignoring."); return; } - + type = (Type) DocumentConfig.findEnum(attributes.get("type"), FlightEvent.Type.class); if (type == null) { warnings.add("Illegal event specification, ignoring."); return; } - + branch.addEvent(new FlightEvent(type, time)); return; } - + if (!element.equals("datapoint")) { warnings.add("Unknown element '" + element + "' encountered, ignoring."); return; } - + // element == "datapoint" - - + + // Check line format String[] split = content.split(","); if (split.length != types.length) { warnings.add("Data point did not contain correct amount of values, ignoring point."); return; } - + // Parse the doubles double[] values = new double[split.length]; for (int i = 0; i < values.length; i++) { @@ -1678,7 +1820,7 @@ class FlightDataBranchHandler extends AbstractElementHandler { return; } } - + // Add point to branch branch.addPoint(); for (int i = 0; i < types.length; i++) { @@ -1712,11 +1854,11 @@ interface Setter { //// StringSetter - sets the value to the contained String class StringSetter implements Setter { private final Reflection.Method setMethod; - + public StringSetter(Reflection.Method set) { setMethod = set; } - + @Override public void set(RocketComponent c, String s, HashMap attributes, WarningSet warnings) { @@ -1727,11 +1869,11 @@ class StringSetter implements Setter { //// IntSetter - set an integer value class IntSetter implements Setter { private final Reflection.Method setMethod; - + public IntSetter(Reflection.Method set) { setMethod = set; } - + @Override public void set(RocketComponent c, String s, HashMap attributes, WarningSet warnings) { @@ -1748,15 +1890,15 @@ class IntSetter implements Setter { //// BooleanSetter - set a boolean value class BooleanSetter implements Setter { private final Reflection.Method setMethod; - + public BooleanSetter(Reflection.Method set) { setMethod = set; } - + @Override public void set(RocketComponent c, String s, HashMap attributes, WarningSet warnings) { - + s = s.trim(); if (s.equalsIgnoreCase("true")) { setMethod.invoke(c, true); @@ -1777,7 +1919,7 @@ class DoubleSetter implements Setter { private final String specialString; private final Reflection.Method specialMethod; private final double multiplier; - + /** * Set only the double value. * @param set set method for the double value. @@ -1788,7 +1930,7 @@ class DoubleSetter implements Setter { this.specialMethod = null; this.multiplier = 1.0; } - + /** * Multiply with the given multiplier and set the double value. * @param set set method for the double value. @@ -1800,7 +1942,7 @@ class DoubleSetter implements Setter { this.specialMethod = null; this.multiplier = mul; } - + /** * Set the double value, or if the value equals the special string, use the * special setter and set it to true. @@ -1816,20 +1958,20 @@ class DoubleSetter implements Setter { this.specialMethod = specialMethod; this.multiplier = 1.0; } - - + + @Override public void set(RocketComponent c, String s, HashMap attributes, WarningSet warnings) { - + s = s.trim(); - + // Check for special case if (specialMethod != null && s.equalsIgnoreCase(specialString)) { specialMethod.invoke(c, true); return; } - + // Normal case try { double d = Double.parseDouble(s); @@ -1844,16 +1986,16 @@ class DoubleSetter implements Setter { class OverrideSetter implements Setter { private final Reflection.Method setMethod; private final Reflection.Method enabledMethod; - + public OverrideSetter(Reflection.Method set, Reflection.Method enabledMethod) { this.setMethod = set; this.enabledMethod = enabledMethod; } - + @Override public void set(RocketComponent c, String s, HashMap attributes, WarningSet warnings) { - + try { double d = Double.parseDouble(s); setMethod.invoke(c, d); @@ -1868,22 +2010,22 @@ class OverrideSetter implements Setter { class EnumSetter> implements Setter { private final Reflection.Method setter; private final Class enumClass; - + public EnumSetter(Reflection.Method set, Class enumClass) { this.setter = set; this.enumClass = enumClass; } - + @Override public void set(RocketComponent c, String name, HashMap attributes, WarningSet warnings) { - + Enum setEnum = DocumentConfig.findEnum(name, enumClass); if (setEnum == null) { warnings.add(Warning.FILE_INVALID_PARAMETER); return; } - + setter.invoke(c, setEnum); } } @@ -1892,24 +2034,24 @@ class EnumSetter> implements Setter { //// ColorSetter - sets a Color value class ColorSetter implements Setter { private final Reflection.Method setMethod; - + public ColorSetter(Reflection.Method set) { setMethod = set; } - + @Override public void set(RocketComponent c, String s, HashMap attributes, WarningSet warnings) { - + String red = attributes.get("red"); String green = attributes.get("green"); String blue = attributes.get("blue"); - + if (red == null || green == null || blue == null) { warnings.add(Warning.FILE_INVALID_PARAMETER); return; } - + int r, g, b; try { r = Integer.parseInt(red); @@ -1919,100 +2061,167 @@ class ColorSetter implements Setter { warnings.add(Warning.FILE_INVALID_PARAMETER); return; } - + if (r < 0 || g < 0 || b < 0 || r > 255 || g > 255 || b > 255) { warnings.add(Warning.FILE_INVALID_PARAMETER); return; } - + Color color = new Color(r, g, b); setMethod.invoke(c, color); - + if (!s.trim().equals("")) { warnings.add(Warning.FILE_INVALID_PARAMETER); } } } +////ComponentPresetSetter - sets a ComponentPreset value +class ComponentPresetSetter implements Setter { +private final Reflection.Method setMethod; +public ComponentPresetSetter(Reflection.Method set) { + this.setMethod = set; +} -class MaterialSetter implements Setter { - private final Reflection.Method setMethod; - private final Material.Type type; - - public MaterialSetter(Reflection.Method set, Material.Type type) { - this.setMethod = set; - this.type = type; +@Override +public void set(RocketComponent c, String name, HashMap attributes, + WarningSet warnings) { + // FIXME - probably need more data in the warning messages - like what component preset... + String manufacturerName = attributes.get("manufacturer"); + if ( manufacturerName == null ) { + warnings.add(Warning.fromString("Invalid ComponentPreset, no manufacturer specified. Ignored")); + return; } - - @Override - public void set(RocketComponent c, String name, HashMap attributes, - WarningSet warnings) { - - Material mat; - - // Check name != "" - name = name.trim(); - if (name.equals("")) { - warnings.add(Warning.fromString("Illegal material specification, ignoring.")); - return; - } - - // Parse density - double density; - String str; - str = attributes.remove("density"); - if (str == null) { - warnings.add(Warning.fromString("Illegal material specification, ignoring.")); - return; - } - try { - density = Double.parseDouble(str); - } catch (NumberFormatException e) { - warnings.add(Warning.fromString("Illegal material specification, ignoring.")); - return; + + String productNo = attributes.get("partno"); + if ( productNo == null ) { + warnings.add(Warning.fromString("Invalid ComponentPreset, no partno specified. Ignored")); + return; + } + + String digest = attributes.get("digest"); + if ( digest == null ) { + warnings.add(Warning.fromString("Invalid ComponentPreset, no digest specified.")); + } + + String type = attributes.get("type"); + if ( type == null ) { + warnings.add(Warning.fromString("Invalid ComponentPreset, no type specified.")); + } + + List presets = Application.getComponentPresetDao().find( manufacturerName, productNo ); + + ComponentPreset matchingPreset = null; + + for( ComponentPreset preset: presets ) { + if ( digest != null && preset.getDigest().equals(digest) ) { + // Found one with matching digest. Take it. + matchingPreset = preset; + break; } - - // Parse thickness - // double thickness = 0; - // str = attributes.remove("thickness"); - // try { - // if (str != null) - // thickness = Double.parseDouble(str); - // } catch (NumberFormatException e){ - // warnings.add(Warning.fromString("Illegal material specification, ignoring.")); - // return; - // } - - // Check type if specified - str = attributes.remove("type"); - if (str != null && !type.name().toLowerCase(Locale.ENGLISH).equals(str)) { - warnings.add(Warning.fromString("Illegal material type specified, ignoring.")); - return; + if ( type != null && preset.getType().name().equals(type) && matchingPreset != null) { + // Found the first one with matching type. + matchingPreset = preset; } - - mat = Databases.findMaterial(type, name, density, false); - - setMethod.invoke(c, mat); } + + // Was any found? + if ( matchingPreset == null ) { + warnings.add(Warning.fromString("No matching ComponentPreset found " + manufacturerName + " " + productNo)); + return; + } + + if ( digest != null && !matchingPreset.getDigest().equals(digest) ) { + warnings.add(Warning.fromString("ComponentPreset has wrong digest")); + } + + setMethod.invoke(c, matchingPreset); +} } +////MaterialSetter - sets a Material value +class MaterialSetter implements Setter { +private final Reflection.Method setMethod; +private final Material.Type type; + +public MaterialSetter(Reflection.Method set, Material.Type type) { + this.setMethod = set; + this.type = type; +} + +@Override +public void set(RocketComponent c, String name, HashMap attributes, + WarningSet warnings) { + + Material mat; + + // Check name != "" + name = name.trim(); + if (name.equals("")) { + warnings.add(Warning.fromString("Illegal material specification, ignoring.")); + return; + } + + // Parse density + double density; + String str; + str = attributes.remove("density"); + if (str == null) { + warnings.add(Warning.fromString("Illegal material specification, ignoring.")); + return; + } + try { + density = Double.parseDouble(str); + } catch (NumberFormatException e) { + warnings.add(Warning.fromString("Illegal material specification, ignoring.")); + return; + } + + // Parse thickness + // double thickness = 0; + // str = attributes.remove("thickness"); + // try { + // if (str != null) + // thickness = Double.parseDouble(str); + // } catch (NumberFormatException e){ + // warnings.add(Warning.fromString("Illegal material specification, ignoring.")); + // return; + // } + + // Check type if specified + str = attributes.remove("type"); + if (str != null && !type.name().toLowerCase(Locale.ENGLISH).equals(str)) { + warnings.add(Warning.fromString("Illegal material type specified, ignoring.")); + return; + } + + String key = attributes.remove("key"); + + mat = Databases.findMaterial(type, key, name, density); + + setMethod.invoke(c, mat); +} +} + + + class PositionSetter implements Setter { - + @Override public void set(RocketComponent c, String value, HashMap attributes, WarningSet warnings) { - + RocketComponent.Position type = (Position) DocumentConfig.findEnum(attributes.get("type"), RocketComponent.Position.class); if (type == null) { warnings.add(Warning.FILE_INVALID_PARAMETER); return; } - + double pos; try { pos = Double.parseDouble(value); @@ -2020,7 +2229,7 @@ class PositionSetter implements Setter { warnings.add(Warning.FILE_INVALID_PARAMETER); return; } - + if (c instanceof FinSet) { ((FinSet) c).setRelativePosition(type); c.setPositionValue(pos); @@ -2033,34 +2242,34 @@ class PositionSetter implements Setter { } else { warnings.add(Warning.FILE_INVALID_PARAMETER); } - + } } class FinTabPositionSetter extends DoubleSetter { - + public FinTabPositionSetter() { super(Reflection.findMethod(FinSet.class, "setTabShift", double.class)); } - + @Override public void set(RocketComponent c, String s, HashMap attributes, WarningSet warnings) { - + if (!(c instanceof FinSet)) { throw new IllegalStateException("FinTabPositionSetter called for component " + c); } - + String relative = attributes.get("relativeto"); FinSet.TabRelativePosition position = (TabRelativePosition) DocumentConfig.findEnum(relative, FinSet.TabRelativePosition.class); - + if (position != null) { - + ((FinSet) c).setTabRelativePosition(position); - + } else { if (relative == null) { warnings.add("Required attribute 'relativeto' not found for fin tab position."); @@ -2068,25 +2277,25 @@ class FinTabPositionSetter extends DoubleSetter { warnings.add("Illegal attribute value '" + relative + "' encountered."); } } - + super.set(c, s, attributes, warnings); } - - + + } class ClusterConfigurationSetter implements Setter { - + @Override public void set(RocketComponent component, String value, HashMap attributes, WarningSet warnings) { - + if (!(component instanceof Clusterable)) { warnings.add("Illegal component defined as cluster."); return; } - + ClusterConfiguration config = null; for (ClusterConfiguration c : ClusterConfiguration.CONFIGURATIONS) { if (c.getXMLName().equals(value)) { @@ -2094,12 +2303,12 @@ class ClusterConfigurationSetter implements Setter { break; } } - + if (config == null) { warnings.add("Illegal cluster configuration specified."); return; } - + ((Clusterable) component).setClusterConfiguration(config); } }