b39bc23ec4245a2cb3cb07e3e1d9be36d58a903e
[debian/openrocket] / core / src / net / sf / openrocket / preset / xml / BaseComponentDTO.java
1
2 package net.sf.openrocket.preset.xml;
3
4 import net.sf.openrocket.database.Databases;
5 import net.sf.openrocket.material.Material;
6 import net.sf.openrocket.motor.Manufacturer;
7 import net.sf.openrocket.preset.ComponentPreset;
8 import net.sf.openrocket.preset.InvalidComponentPresetException;
9 import net.sf.openrocket.preset.TypedPropertyMap;
10 import net.sf.openrocket.unit.UnitGroup;
11
12 import javax.imageio.ImageIO;
13 import javax.xml.bind.DatatypeConverter;
14 import javax.xml.bind.annotation.XmlAccessType;
15 import javax.xml.bind.annotation.XmlAccessorType;
16 import javax.xml.bind.annotation.XmlAttribute;
17 import javax.xml.bind.annotation.XmlElement;
18 import javax.xml.bind.annotation.XmlInlineBinaryData;
19 import javax.xml.bind.annotation.XmlValue;
20 import javax.xml.bind.annotation.adapters.XmlAdapter;
21 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
22 import java.awt.image.BufferedImage;
23 import java.io.ByteArrayInputStream;
24 import java.io.ByteArrayOutputStream;
25 import java.io.IOException;
26 import java.util.List;
27
28 /**
29  * Base class for the external representation of all component presets.
30  */
31 @XmlAccessorType(XmlAccessType.FIELD)
32 public abstract class BaseComponentDTO {
33
34         @XmlElement(name = "Manufacturer")
35         private String manufacturer;
36         @XmlElement(name = "PartNumber")
37         private String partNo;
38         @XmlElement(name = "Description")
39         private String description;
40         @XmlElement(name = "Material")
41         private AnnotatedMaterialDTO material;
42         @XmlElement(name = "Mass")
43         private AnnotatedMassDTO mass;
44         @XmlElement(name="Filled")
45         private Boolean filled;
46     @XmlInlineBinaryData
47     @XmlJavaTypeAdapter(Base64Adapter.class)
48     @XmlElement(name = "Thumbnail")
49     private byte[] image;
50
51         /**
52          * Default constructor.
53          */
54         protected BaseComponentDTO() {
55         }
56
57         /**
58          * Constructor.
59          *
60          * @param preset  the preset to use to pull data values out of
61          *
62          * @throws net.sf.openrocket.util.BugException thrown if the expected body tube keys are not in the preset
63          */
64         protected BaseComponentDTO(final ComponentPreset preset) {
65                 setManufacturer(preset.getManufacturer().getSimpleName());
66                 setPartNo(preset.getPartNo());
67                 if ( preset.has(ComponentPreset.DESCRIPTION )) {
68                         setDescription(preset.get(ComponentPreset.DESCRIPTION));
69                 }
70                 if ( preset.has(ComponentPreset.MATERIAL)) {
71                         setMaterial(new AnnotatedMaterialDTO(preset.get(ComponentPreset.MATERIAL)));
72                 }
73                 if (preset.has(ComponentPreset.MASS)) {
74                         setMass(preset.get(ComponentPreset.MASS));
75                 }
76                 if ( preset.has(ComponentPreset.FILLED) ) {
77                         setFilled( preset.get(ComponentPreset.FILLED));
78                 }
79         if (preset.has(ComponentPreset.IMAGE) ) {
80             setImageData(preset.get(ComponentPreset.IMAGE));
81         }
82         }
83
84         public String getManufacturer() {
85                 return manufacturer;
86         }
87
88         public void setManufacturer(final String theManufacturer) {
89                 manufacturer = theManufacturer;
90         }
91
92         public String getPartNo() {
93                 return partNo;
94         }
95
96         public void setPartNo(final String thePartNo) {
97                 partNo = thePartNo;
98         }
99
100         public String getDescription() {
101                 return description;
102         }
103
104         public void setDescription(final String theDescription) {
105                 description = theDescription;
106         }
107
108         public AnnotatedMaterialDTO getMaterial() {
109                 return material;
110         }
111
112         public void setMaterial(final AnnotatedMaterialDTO theMaterial) {
113                 material = theMaterial;
114         }
115
116         public double getMass() {
117                 return mass.getValue();
118         }
119
120         public void setMass(final AnnotatedMassDTO theMass) {
121                 mass = theMass;
122         }
123
124         public void setMass(final double theMass) {
125                 mass = new AnnotatedMassDTO(theMass);
126         }
127
128         public Boolean getFilled() {
129                 return filled;
130         }
131
132         public void setFilled(Boolean filled) {
133                 this.filled = filled;
134         }
135
136     public byte[] getImageData() {
137         return image;
138     }
139
140     public void setImageData(final byte[] theImage) {
141         image = theImage;
142     }
143
144     public BufferedImage getImage() throws IOException {
145         if (image != null) {
146             return ImageIO.read(new ByteArrayInputStream(image));
147         }
148         return null;
149     }
150
151     public void setImage(BufferedImage theImage) throws IOException {
152         if (theImage != null) {
153             final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
154             ImageIO.write(theImage, "png", byteArrayOutputStream);
155             image = byteArrayOutputStream.toByteArray();
156         }
157     }
158
159     public abstract ComponentPreset asComponentPreset(List<MaterialDTO> materials) throws InvalidComponentPresetException;
160
161         void addProps(TypedPropertyMap props, List<MaterialDTO> materialList) {
162                 props.put(ComponentPreset.MANUFACTURER, Manufacturer.getManufacturer(manufacturer));
163                 props.put(ComponentPreset.PARTNO, partNo);
164                 if ( description != null ) {
165                         props.put(ComponentPreset.DESCRIPTION, description);
166                 }
167                 Material m = find(materialList, material);
168                 if ( m != null ) {
169                         props.put(ComponentPreset.MATERIAL, find(materialList, material));
170                 }
171                 if ( mass != null ) {
172                         props.put(ComponentPreset.MASS, getMass());
173                 }
174                 if ( filled != null ) {
175                         props.put(ComponentPreset.FILLED, getFilled());
176                 }
177         if (image != null) {
178             props.put(ComponentPreset.IMAGE, image);
179         }
180         }
181
182         protected Material find(List<MaterialDTO> materialList, AnnotatedMaterialDTO dto) {
183                 if ( dto == null ) {
184                         return null;
185                 }
186                 for (int i = 0; i < materialList.size(); i++) {
187                         MaterialDTO materialDTO =  materialList.get(i);
188                         if (materialDTO.getType().name().equals(dto.type) && materialDTO.getName().equals(dto.material)) {
189                                 return materialDTO.asMaterial();
190                         }
191                 }
192
193                 // Don't have one, first check OR's database
194         Material m = Databases.findMaterial(dto.getORMaterialType(), dto.material);
195         if ( m != null ) {
196                 return m;
197         }
198
199         return Material.newUserMaterial(dto.getORMaterialType(), dto.material, 0.0);
200
201         }
202
203         static class AnnotatedMaterialDTO {
204                 @XmlAttribute(name = "Type")
205                 private String type;
206                 @XmlValue
207                 private String material;
208
209                 AnnotatedMaterialDTO() {}
210
211                 AnnotatedMaterialDTO(Material theMaterial) {
212                         type = theMaterial.getType().name();
213                         material = theMaterial.getName();
214                 }
215                 
216                 public Material.Type getORMaterialType() {
217                         if ( "BULK".equals(type) ) {
218                                 return Material.Type.BULK;
219                         } else if ( "SURFACE".equals(type) ) {
220                                 return Material.Type.SURFACE;
221                         } else if ( "LINE".equals(type) ) {
222                                 return Material.Type.LINE;
223                         }
224                         throw new IllegalArgumentException( "Inavlid material type " + type +" specified for Component" );
225                 }
226         }
227
228         static class AnnotatedLengthDTO {
229                 @XmlAttribute(name="Unit", required=false)
230                 private String unitName = "m";
231                 @XmlValue
232                 private double length;
233
234                 AnnotatedLengthDTO() {}
235
236                 AnnotatedLengthDTO( double length ) {
237                         this.length = length;
238                 }
239
240                 public double getValue() {
241                         return UnitGroup.UNITS_LENGTH.getUnit(unitName).fromUnit(length);
242                 }
243         }
244
245         static class AnnotatedMassDTO {
246                 @XmlAttribute(name="Unit", required=false)
247                 private String unitName = "kg";
248                 @XmlValue
249                 private double mass;
250
251                 AnnotatedMassDTO() {}
252
253                 AnnotatedMassDTO( double mass ) {
254                         this.mass = mass;
255                 }
256
257                 public double getValue() {
258                         return UnitGroup.UNITS_MASS.getUnit(unitName).fromUnit(mass);
259                 }
260         }
261
262     static class Base64Adapter extends XmlAdapter<String, byte[]> {
263         @Override
264         public byte[] unmarshal(String s) {
265             if (s == null) {
266                 return null;
267             }
268             return DatatypeConverter.parseBase64Binary(s);
269         }
270
271         @Override
272         public String marshal(byte[] bytes) {
273             if (bytes == null) {
274                 return null;
275             }
276             return DatatypeConverter.printBase64Binary(bytes);
277         }
278     }
279 }