git.gag.com Git - debian/openrocket/blob - src/net/sf/openrocket/gui/print/visitor/StageVisitorStrategy.java

   1 /*
   2  * StageVisitor.java
   3  */
   4 package net.sf.openrocket.gui.print.visitor;
   5
   6 import java.util.ArrayList;
   7 import java.util.List;
   8
   9 import net.sf.openrocket.rocketcomponent.BodyComponent;
  10 import net.sf.openrocket.rocketcomponent.BodyTube;
  11 import net.sf.openrocket.rocketcomponent.ComponentVisitor;
  12 import net.sf.openrocket.rocketcomponent.ComponentVisitorStrategy;
  13 import net.sf.openrocket.rocketcomponent.EllipticalFinSet;
  14 import net.sf.openrocket.rocketcomponent.ExternalComponent;
  15 import net.sf.openrocket.rocketcomponent.FreeformFinSet;
  16 import net.sf.openrocket.rocketcomponent.InnerTube;
  17 import net.sf.openrocket.rocketcomponent.LaunchLug;
  18 import net.sf.openrocket.rocketcomponent.MassObject;
  19 import net.sf.openrocket.rocketcomponent.NoseCone;
  20 import net.sf.openrocket.rocketcomponent.RadiusRingComponent;
  21 import net.sf.openrocket.rocketcomponent.RingComponent;
  22 import net.sf.openrocket.rocketcomponent.Rocket;
  23 import net.sf.openrocket.rocketcomponent.RocketComponent;
  24 import net.sf.openrocket.rocketcomponent.Stage;
  25 import net.sf.openrocket.rocketcomponent.Transition;
  26 import net.sf.openrocket.rocketcomponent.TrapezoidFinSet;
  27
  28 /**
  29  * This visitor strategy accumulates Stage references in a Rocket hierarchy.
  30  */
  31 public class StageVisitorStrategy implements ComponentVisitorStrategy {
  32
  33         /**
  34          * The collection of stages, accumulated during a visitation.
  35          */
  36         private List<Double> stageComponents = new ArrayList<Double>();
  37
  38         private Double mass = 0d;
  39
  40         /**
  41          * The owning visitor.
  42          */
  43         protected ComponentVisitor parent;
  44
  45         /**
  46          * Constructor.
  47          */
  48         public StageVisitorStrategy() {
  49         }
  50
  51         /**
  52          * Override the method that determines if the visiting should be going deep.
  53          *
  54          * @param stageNumber a stage number
  55          *
  56          * @return true, always
  57          */
  58         public boolean shouldVisitStage(int stageNumber) {
  59                 return true;
  60         }
  61
  62         /**
  63          * {@inheritDoc}
  64          */
  65         @Override
  66         public void setParent(final ComponentVisitor theParent) {
  67                 parent = theParent;
  68         }
  69
  70         /**
  71          * {@inheritDoc}
  72          */
  73         @Override
  74         public void visit(final Rocket visitable) {
  75                 goDeep(visitable);
  76         }
  77
  78         /**
  79          * {@inheritDoc}
  80          */
  81         @Override
  82         public void visit(final Stage visitable) {
  83
  84                 if (mass > 0d) {
  85                         stageComponents.add(mass);
  86                 }
  87                 mass = 0d;
  88                 List<RocketComponent> rc = visitable.getChildren();
  89                 goDeep(rc);
  90         }
  91
  92         /**
  93          * {@inheritDoc}
  94          */
  95         @Override
  96         public void visit(final RocketComponent visitable) {
  97                 mass += visitable.getMass();
  98                 goDeep(visitable);
  99         }
 100
 101         /**
 102          * Recurse through the given rocket component.
 103          *
 104          * @param root the root component; all children will be visited recursively
 105          */
 106         protected void goDeep(final RocketComponent root) {
 107                 List<RocketComponent> rc = root.getChildren();
 108                 goDeep(rc);
 109         }
 110
 111
 112         /**
 113          * Recurse through the given rocket component.
 114          *
 115          * @param theRc an array of rocket components; all children will be visited recursively
 116          */
 117         protected void goDeep(final List<RocketComponent> theRc) {
 118                 for (RocketComponent rocketComponent : theRc) {
 119                         rocketComponent.accept(parent);
 120                 }
 121         }
 122
 123
 124         /**
 125          * {@inheritDoc}
 126          */
 127         @Override
 128         public void visit(final ExternalComponent visitable) {
 129                 mass += visitable.getMass();
 130                 goDeep(visitable);
 131         }
 132
 133         /**
 134          * {@inheritDoc}
 135          */
 136         @Override
 137         public void visit(final BodyComponent visitable) {
 138                 mass += visitable.getMass();
 139                 goDeep(visitable);
 140         }
 141
 142         /**
 143          * {@inheritDoc}
 144          */
 145         @Override
 146         public void visit(final RingComponent visitable) {
 147                 mass += visitable.getMass();
 148                 goDeep(visitable);
 149         }
 150
 151         /**
 152          * {@inheritDoc}
 153          */
 154         @Override
 155         public void visit(final InnerTube visitable) {
 156                 mass += visitable.getMass();
 157                 goDeep(visitable);
 158         }
 159
 160         /**
 161          * {@inheritDoc}
 162          */
 163         @Override
 164         public void visit(final LaunchLug visitable) {
 165                 mass += visitable.getMass();
 166                 goDeep(visitable);
 167         }
 168
 169         /**
 170          * {@inheritDoc}
 171          */
 172         @Override
 173         public void visit(final Transition visitable) {
 174                 mass += visitable.getMass();
 175                 goDeep(visitable);
 176         }
 177
 178         /**
 179          * {@inheritDoc}
 180          */
 181         @Override
 182         public void visit(final RadiusRingComponent visitable) {
 183                 mass += visitable.getMass();
 184                 goDeep(visitable);
 185         }
 186
 187         /**
 188          * {@inheritDoc}
 189          */
 190         @Override
 191         public void visit(final MassObject visitable) {
 192                 mass += visitable.getMass();
 193                 goDeep(visitable);
 194         }
 195
 196         /**
 197          * {@inheritDoc}
 198          */
 199         @Override
 200         public void visit(final NoseCone visitable) {
 201                 mass += visitable.getMass();
 202                 goDeep(visitable);
 203         }
 204
 205         /**
 206          * {@inheritDoc}
 207          */
 208         @Override
 209         public void visit(final BodyTube visitable) {
 210                 mass += visitable.getMass();
 211                 goDeep(visitable);
 212         }
 213
 214         /**
 215          * {@inheritDoc}
 216          */
 217         @Override
 218         public void visit(final TrapezoidFinSet visitable) {
 219                 mass += visitable.getMass();
 220                 goDeep(visitable);
 221         }
 222
 223         /**
 224          * {@inheritDoc}
 225          */
 226         @Override
 227         public void visit(final EllipticalFinSet visitable) {
 228                 mass += visitable.getMass();
 229                 goDeep(visitable);
 230         }
 231
 232         /**
 233          * {@inheritDoc}
 234          */
 235         @Override
 236         public void visit(final FreeformFinSet visitable) {
 237                 mass += visitable.getMass();
 238                 goDeep(visitable);
 239         }
 240
 241         /**
 242          * Get the list of stages, sort from Stage 1 .. Stage N.
 243          *
 244          * @return a sorted list of stages
 245          */
 246         public List<Double> getStages() {
 247                 return stageComponents;
 248         }
 249
 250         /**
 251          * Close by setting the last stage.
 252          */
 253         @Override
 254         public void close() {
 255                 if (mass > 0d) {
 256                         stageComponents.add(mass);
 257                 }
 258         }
 259
 260 }