| 1 | /* =========================================================== | |
| 2 | * JFreeChart : a free chart library for the Java(tm) platform | |
| 3 | * =========================================================== | |
| 4 | * | |
| 5 | * (C) Copyright 2000-2009, by Object Refinery Limited and Contributors. | |
| 6 | * | |
| 7 | * Project Info: http://www.jfree.org/jfreechart/index.html | |
| 8 | * | |
| 9 | * This library is free software; you can redistribute it and/or modify it | |
| 10 | * under the terms of the GNU Lesser General Public License as published by | |
| 11 | * the Free Software Foundation; either version 2.1 of the License, or | |
| 12 | * (at your option) any later version. | |
| 13 | * | |
| 14 | * This library is distributed in the hope that it will be useful, but | |
| 15 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
| 16 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public | |
| 17 | * License for more details. | |
| 18 | * | |
| 19 | * You should have received a copy of the GNU Lesser General Public | |
| 20 | * License along with this library; if not, write to the Free Software | |
| 21 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, | |
| 22 | * USA. | |
| 23 | * | |
| 24 | * [Java is a trademark or registered trademark of Sun Microsystems, Inc. | |
| 25 | * in the United States and other countries.] | |
| 26 | * | |
| 27 | * --------------------------- | |
| 28 | * ClusteredXYBarRenderer.java | |
| 29 | * --------------------------- | |
| 30 | * (C) Copyright 2003-2009, by Paolo Cova and Contributors. | |
| 31 | * | |
| 32 | * Original Author: Paolo Cova; | |
| 33 | * Contributor(s): David Gilbert (for Object Refinery Limited); | |
| 34 | * Christian W. Zuckschwerdt; | |
| 35 | * Matthias Rose; | |
| 36 | * | |
| 37 | * Changes | |
| 38 | * ------- | |
| 39 | * 24-Jan-2003 : Version 1, contributed by Paolo Cova (DG); | |
| 40 | * 25-Mar-2003 : Implemented Serializable (DG); | |
| 41 | * 01-May-2003 : Modified drawItem() method signature (DG); | |
| 42 | * 30-Jul-2003 : Modified entity constructor (CZ); | |
| 43 | * 20-Aug-2003 : Implemented Cloneable and PublicCloneable (DG); | |
| 44 | * 16-Sep-2003 : Changed ChartRenderingInfo --> PlotRenderingInfo (DG); | |
| 45 | * 07-Oct-2003 : Added renderer state (DG); | |
| 46 | * 03-Nov-2003 : In draw method added state parameter and y==null value | |
| 47 | * handling (MR); | |
| 48 | * 25-Feb-2004 : Replaced CrosshairInfo with CrosshairState (DG); | |
| 49 | * 15-Jul-2004 : Switched getX() with getXValue() and getY() with | |
| 50 | * getYValue() (DG); | |
| 51 | * 01-Oct-2004 : Fixed bug where 'drawBarOutline' flag is ignored (DG); | |
| 52 | * 16-May-2005 : Fixed to used outline stroke for bar outlines. Removed some | |
| 53 | * redundant code with the result that the renderer now respects | |
| 54 | * the 'base' setting from the super-class. Added an equals() | |
| 55 | * method (DG); | |
| 56 | * 19-May-2005 : Added minimal item label implementation - needs improving (DG); | |
| 57 | * ------------- JFREECHART 1.0.x --------------------------------------------- | |
| 58 | * 11-Dec-2006 : Added support for GradientPaint (DG); | |
| 59 | * 12-Jun-2007 : Added override to findDomainBounds() to handle cluster offset, | |
| 60 | * fixed rendering to handle inverted axes, and simplified | |
| 61 | * entity generation code (DG); | |
| 62 | * 20-Jun-2007 : Removed JCommon dependencies (DG); | |
| 63 | * 24-Jun-2008 : Added new barPainter mechanism (DG); | |
| 64 | * | |
| 65 | */ | |
| 66 | ||
| 67 | package org.jfree.chart.renderer.xy; | |
| 68 | ||
| 69 | import java.awt.Graphics2D; | |
| 70 | import java.awt.geom.Rectangle2D; | |
| 71 | import java.io.Serializable; | |
| 72 | ||
| 73 | import org.jfree.chart.axis.ValueAxis; | |
| 74 | import org.jfree.chart.entity.EntityCollection; | |
| 75 | import org.jfree.chart.labels.XYItemLabelGenerator; | |
| 76 | import org.jfree.chart.plot.CrosshairState; | |
| 77 | import org.jfree.chart.plot.PlotOrientation; | |
| 78 | import org.jfree.chart.plot.PlotRenderingInfo; | |
| 79 | import org.jfree.chart.plot.XYPlot; | |
| 80 | import org.jfree.chart.util.PublicCloneable; | |
| 81 | import org.jfree.chart.util.RectangleEdge; | |
| 82 | import org.jfree.data.Range; | |
| 83 | import org.jfree.data.xy.IntervalXYDataset; | |
| 84 | import org.jfree.data.xy.XYDataset; | |
| 85 | ||
| 86 | /** | |
| 87 | * An extension of {@link XYBarRenderer} that displays bars for different | |
| 88 | * series values at the same x next to each other. The assumption here is | |
| 89 | * that for each x (time or else) there is a y value for each series. If | |
| 90 | * this is not the case, there will be spaces between bars for a given x. | |
| 91 | * The example shown here is generated by the | |
| 92 | * ClusteredXYBarRendererDemo1.java program included in the | |
| 93 | * JFreeChart demo collection: | |
| 94 | *

 | |
| 95 | *  | |
| 97 | *
 | |
| 98 | * This renderer does not include code to calculate the crosshair point for the | |
| 99 | * plot. | |
| 100 | */ | |
| 101 | public class ClusteredXYBarRenderer extends XYBarRenderer | |
| 102 | implements Cloneable, PublicCloneable, Serializable { | |
| 103 | ||
| 104 | /** For serialization. */ | |
| 105 | private static final long serialVersionUID =<PHONE_NUMBER>177133147L; | |
| 106 | ||
| 107 | /** Determines whether bar center should be interval start. */ | |
| 108 | private boolean centerBarAtStartValue; | |
| 109 | ||
| 110 | /** | |
| 111 | * Default constructor. Bar margin is set to 0.0. | |
| 112 | */ | |
| 113 | public ClusteredXYBarRenderer() { | |
| 114 | this(0.0, false); | |
| 115 | } | |
| 116 | ||
| 117 | /** | |
| 118 | * Constructs a new XY clustered bar renderer. | |
| 119 | * | |
| 120 | * @param margin the percentage amount to trim from the width of each bar. | |
| 121 | * @param centerBarAtStartValue if true, bars will be centered on the | |
| 122 | * start of the time period. | |
| 123 | */ | |
| 124 | public ClusteredXYBarRenderer(double margin, | |
| 125 | boolean centerBarAtStartValue) { | |
| 126 | super(margin); | |
| 127 | this.centerBarAtStartValue = centerBarAtStartValue; | |
| 128 | } | |
| 129 | ||
| 130 | /** | |
| 131 | * Returns the number of passes through the dataset that this renderer | |
| 132 | * requires. In this case, two passes are required, the first for drawing | |
| 133 | * the shadows (if visible), and the second for drawing the bars. | |
| 134 | * | |
| 135 | * @return 2. | |
| 136 | */ | |
| 137 | public int getPassCount() { | |
| 138 |
1
1. getPassCount : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return 2; |
| 139 | } | |
| 140 | ||
| 141 | /** | |
| 142 | * Returns the x-value bounds for the specified dataset. | |
| 143 | * | |
| 144 | * @param dataset the dataset (null permitted). | |
| 145 | * | |
| 146 | * @return The bounds (possibly null). | |
| 147 | */ | |
| 148 | public Range findDomainBounds(XYDataset dataset) { | |
| 149 |
1
1. findDomainBounds : negated conditional → KILLED |
if (dataset == null) { |
| 150 |
1
1. findDomainBounds : mutated return of Object value for org/jfree/chart/renderer/xy/ClusteredXYBarRenderer::findDomainBounds to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return null; |
| 151 | } | |
| 152 | // need to handle cluster centering as a special case | |
| 153 |
1
1. findDomainBounds : negated conditional → KILLED |
if (this.centerBarAtStartValue) { |
| 154 |
1
1. findDomainBounds : mutated return of Object value for org/jfree/chart/renderer/xy/ClusteredXYBarRenderer::findDomainBounds to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return findDomainBoundsWithOffset((IntervalXYDataset) dataset); |
| 155 | } | |
| 156 | else { | |
| 157 |
1
1. findDomainBounds : mutated return of Object value for org/jfree/chart/renderer/xy/ClusteredXYBarRenderer::findDomainBounds to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return super.findDomainBounds(dataset); |
| 158 | } | |
| 159 | } | |
| 160 | ||
| 161 | /** | |
| 162 | * Iterates over the items in an {@link IntervalXYDataset} to find | |
| 163 | * the range of x-values including the interval OFFSET so that it centers | |
| 164 | * the interval around the start value. | |
| 165 | * | |
| 166 | * @param dataset the dataset (null not permitted). | |
| 167 | * | |
| 168 | * @return The range (possibly null). | |
| 169 | */ | |
| 170 | protected Range findDomainBoundsWithOffset(IntervalXYDataset dataset) { | |
| 171 |
1
1. findDomainBoundsWithOffset : negated conditional → KILLED |
if (dataset == null) { |
| 172 | throw new IllegalArgumentException("Null 'dataset' argument."); | |
| 173 | } | |
| 174 | double minimum = Double.POSITIVE_INFINITY; | |
| 175 | double maximum = Double.NEGATIVE_INFINITY; | |
| 176 | int seriesCount = dataset.getSeriesCount(); | |
| 177 | double lvalue; | |
| 178 | double uvalue; | |
| 179 |
3
1. findDomainBoundsWithOffset : changed conditional boundary → KILLED 2. findDomainBoundsWithOffset : Changed increment from 1 to -1 → KILLED 3. findDomainBoundsWithOffset : negated conditional → KILLED |
for (int series = 0; series < seriesCount; series++) { |
| 180 | int itemCount = dataset.getItemCount(series); | |
| 181 |
3
1. findDomainBoundsWithOffset : changed conditional boundary → KILLED 2. findDomainBoundsWithOffset : Changed increment from 1 to -1 → KILLED 3. findDomainBoundsWithOffset : negated conditional → KILLED |
for (int item = 0; item < itemCount; item++) { |
| 182 | lvalue = dataset.getStartXValue(series, item); | |
| 183 | uvalue = dataset.getEndXValue(series, item); | |
| 184 |
2
1. findDomainBoundsWithOffset : Replaced double subtraction with addition → KILLED 2. findDomainBoundsWithOffset : Replaced double division with multiplication → KILLED |
double offset = (uvalue - lvalue) / 2.0; |
| 185 |
1
1. findDomainBoundsWithOffset : Replaced double subtraction with addition → KILLED |
lvalue = lvalue - offset; |
| 186 |
1
1. findDomainBoundsWithOffset : Replaced double subtraction with addition → KILLED |
uvalue = uvalue - offset; |
| 187 | minimum = Math.min(minimum, lvalue); | |
| 188 | maximum = Math.max(maximum, uvalue); | |
| 189 | } | |
| 190 | } | |
| 191 | ||
| 192 |
2
1. findDomainBoundsWithOffset : changed conditional boundary → SURVIVED 2. findDomainBoundsWithOffset : negated conditional → KILLED |
if (minimum > maximum) { |
| 193 |
1
1. findDomainBoundsWithOffset : mutated return of Object value for org/jfree/chart/renderer/xy/ClusteredXYBarRenderer::findDomainBoundsWithOffset to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return null; |
| 194 | } | |
| 195 | else { | |
| 196 |
1
1. findDomainBoundsWithOffset : mutated return of Object value for org/jfree/chart/renderer/xy/ClusteredXYBarRenderer::findDomainBoundsWithOffset to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return new Range(minimum, maximum); |
| 197 | } | |
| 198 | } | |
| 199 | ||
| 200 | /** | |
| 201 | * Draws the visual representation of a single data item. This method | |
| 202 | * is mostly copied from the superclass, the change is that in the | |
| 203 | * calculated space for a singe bar we draw bars for each series next to | |
| 204 | * each other. The width of each bar is the available width divided by | |
| 205 | * the number of series. Bars for each series are drawn in order left to | |
| 206 | * right. | |
| 207 | * | |
| 208 | * @param g2 the graphics device. | |
| 209 | * @param state the renderer state. | |
| 210 | * @param dataArea the area within which the plot is being drawn. | |
| 211 | * @param plot the plot (can be used to obtain standard color | |
| 212 | * information etc). | |
| 213 | * @param domainAxis the domain axis. | |
| 214 | * @param rangeAxis the range axis. | |
| 215 | * @param dataset the dataset. | |
| 216 | * @param series the series index. | |
| 217 | * @param item the item index. | |
| 218 | * @param pass the pass index. | |
| 219 | */ | |
| 220 | public void drawItem(Graphics2D g2, XYItemRendererState state, | |
| 221 | Rectangle2D dataArea, XYPlot plot, ValueAxis domainAxis, | |
| 222 | ValueAxis rangeAxis, XYDataset dataset, int series, int item, | |
| 223 | boolean selected, int pass) { | |
| 224 | ||
| 225 | IntervalXYDataset intervalDataset = (IntervalXYDataset) dataset; | |
| 226 | ||
| 227 | double y0; | |
| 228 | double y1; | |
| 229 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (getUseYInterval()) { |
| 230 | y0 = intervalDataset.getStartYValue(series, item); | |
| 231 | y1 = intervalDataset.getEndYValue(series, item); | |
| 232 | } | |
| 233 | else { | |
| 234 | y0 = getBase(); | |
| 235 | y1 = intervalDataset.getYValue(series, item); | |
| 236 | } | |
| 237 |
2
1. drawItem : negated conditional → NO_COVERAGE 2. drawItem : negated conditional → NO_COVERAGE |
if (Double.isNaN(y0) || Double.isNaN(y1)) { |
| 238 | return; | |
| 239 | } | |
| 240 | ||
| 241 | double yy0 = rangeAxis.valueToJava2D(y0, dataArea, | |
| 242 | plot.getRangeAxisEdge()); | |
| 243 | double yy1 = rangeAxis.valueToJava2D(y1, dataArea, | |
| 244 | plot.getRangeAxisEdge()); | |
| 245 | ||
| 246 | RectangleEdge xAxisLocation = plot.getDomainAxisEdge(); | |
| 247 | double x0 = intervalDataset.getStartXValue(series, item); | |
| 248 | double xx0 = domainAxis.valueToJava2D(x0, dataArea, xAxisLocation); | |
| 249 | ||
| 250 | double x1 = intervalDataset.getEndXValue(series, item); | |
| 251 | double xx1 = domainAxis.valueToJava2D(x1, dataArea, xAxisLocation); | |
| 252 | ||
| 253 |
1
1. drawItem : Replaced double subtraction with addition → NO_COVERAGE |
double intervalW = xx1 - xx0; // this may be negative |
| 254 | double baseX = xx0; | |
| 255 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (this.centerBarAtStartValue) { |
| 256 |
2
1. drawItem : Replaced double division with multiplication → NO_COVERAGE 2. drawItem : Replaced double subtraction with addition → NO_COVERAGE |
baseX = baseX - intervalW / 2.0; |
| 257 | } | |
| 258 | double m = getMargin(); | |
| 259 |
2
1. drawItem : changed conditional boundary → NO_COVERAGE 2. drawItem : negated conditional → NO_COVERAGE |
if (m > 0.0) { |
| 260 |
1
1. drawItem : Replaced double multiplication with division → NO_COVERAGE |
double cut = intervalW * getMargin(); |
| 261 |
1
1. drawItem : Replaced double subtraction with addition → NO_COVERAGE |
intervalW = intervalW - cut; |
| 262 |
2
1. drawItem : Replaced double division with multiplication → NO_COVERAGE 2. drawItem : Replaced double addition with subtraction → NO_COVERAGE |
baseX = baseX + (cut / 2); |
| 263 | } | |
| 264 | ||
| 265 |
1
1. drawItem : Replaced double subtraction with addition → NO_COVERAGE |
double intervalH = Math.abs(yy0 - yy1); // we don't need the sign |
| 266 | ||
| 267 | PlotOrientation orientation = plot.getOrientation(); | |
| 268 | ||
| 269 | int numSeries = dataset.getSeriesCount(); | |
| 270 |
1
1. drawItem : Replaced double division with multiplication → NO_COVERAGE |
double seriesBarWidth = intervalW / numSeries; // may be negative |
| 271 | ||
| 272 | Rectangle2D bar = null; | |
| 273 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (orientation == PlotOrientation.HORIZONTAL) { |
| 274 |
2
1. drawItem : Replaced double multiplication with division → NO_COVERAGE 2. drawItem : Replaced double addition with subtraction → NO_COVERAGE |
double barY0 = baseX + (seriesBarWidth * series); |
| 275 |
1
1. drawItem : Replaced double addition with subtraction → NO_COVERAGE |
double barY1 = barY0 + seriesBarWidth; |
| 276 | double rx = Math.min(yy0, yy1); | |
| 277 | double rw = intervalH; | |
| 278 | double ry = Math.min(barY0, barY1); | |
| 279 |
1
1. drawItem : Replaced double subtraction with addition → NO_COVERAGE |
double rh = Math.abs(barY1 - barY0); |
| 280 | bar = new Rectangle2D.Double(rx, ry, rw, rh); | |
| 281 | } | |
| 282 |
1
1. drawItem : negated conditional → NO_COVERAGE |
else if (orientation == PlotOrientation.VERTICAL) { |
| 283 |
2
1. drawItem : Replaced double multiplication with division → NO_COVERAGE 2. drawItem : Replaced double addition with subtraction → NO_COVERAGE |
double barX0 = baseX + (seriesBarWidth * series); |
| 284 |
1
1. drawItem : Replaced double addition with subtraction → NO_COVERAGE |
double barX1 = barX0 + seriesBarWidth; |
| 285 | double rx = Math.min(barX0, barX1); | |
| 286 |
1
1. drawItem : Replaced double subtraction with addition → NO_COVERAGE |
double rw = Math.abs(barX1 - barX0); |
| 287 | double ry = Math.min(yy0, yy1); | |
| 288 | double rh = intervalH; | |
| 289 | bar = new Rectangle2D.Double(rx, ry, rw, rh); | |
| 290 | } | |
| 291 |
2
1. drawItem : changed conditional boundary → NO_COVERAGE 2. drawItem : negated conditional → NO_COVERAGE |
boolean positive = (y1 > 0.0); |
| 292 | boolean inverted = rangeAxis.isInverted(); | |
| 293 | RectangleEdge barBase; | |
| 294 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (orientation == PlotOrientation.HORIZONTAL) { |
| 295 |
4
1. drawItem : negated conditional → NO_COVERAGE 2. drawItem : negated conditional → NO_COVERAGE 3. drawItem : negated conditional → NO_COVERAGE 4. drawItem : negated conditional → NO_COVERAGE |
if (positive && inverted || !positive && !inverted) { |
| 296 | barBase = RectangleEdge.RIGHT; | |
| 297 | } | |
| 298 | else { | |
| 299 | barBase = RectangleEdge.LEFT; | |
| 300 | } | |
| 301 | } | |
| 302 | else { | |
| 303 |
4
1. drawItem : negated conditional → NO_COVERAGE 2. drawItem : negated conditional → NO_COVERAGE 3. drawItem : negated conditional → NO_COVERAGE 4. drawItem : negated conditional → NO_COVERAGE |
if (positive && !inverted || !positive && inverted) { |
| 304 | barBase = RectangleEdge.BOTTOM; | |
| 305 | } | |
| 306 | else { | |
| 307 | barBase = RectangleEdge.TOP; | |
| 308 | } | |
| 309 | } | |
| 310 |
2
1. drawItem : negated conditional → NO_COVERAGE 2. drawItem : negated conditional → NO_COVERAGE |
if (pass == 0 && getShadowsVisible()) { |
| 311 |
2
1. drawItem : negated conditional → NO_COVERAGE 2. drawItem : removed call to org/jfree/chart/renderer/xy/XYBarPainter::paintBarShadow → NO_COVERAGE |
getBarPainter().paintBarShadow(g2, this, series, item, selected, |
| 312 | bar, barBase, !getUseYInterval()); | |
| 313 | } | |
| 314 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (pass == 1) { |
| 315 |
1
1. drawItem : removed call to org/jfree/chart/renderer/xy/XYBarPainter::paintBar → NO_COVERAGE |
getBarPainter().paintBar(g2, this, series, item, selected, bar, |
| 316 | barBase); | |
| 317 | ||
| 318 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (isItemLabelVisible(series, item, selected)) { |
| 319 | XYItemLabelGenerator generator = getItemLabelGenerator(series, | |
| 320 | item, selected); | |
| 321 |
3
1. drawItem : changed conditional boundary → NO_COVERAGE 2. drawItem : negated conditional → NO_COVERAGE 3. drawItem : removed call to org/jfree/chart/renderer/xy/ClusteredXYBarRenderer::drawItemLabelForBar → NO_COVERAGE |
drawItemLabelForBar(g2, plot, dataset, series, item, selected, |
| 322 | generator, bar, y1 < 0.0); | |
| 323 | } | |
| 324 | ||
| 325 | // add an entity for the item... | |
| 326 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (state.getInfo() != null) { |
| 327 | EntityCollection entities | |
| 328 | = state.getInfo().getOwner().getEntityCollection(); | |
| 329 |
1
1. drawItem : negated conditional → NO_COVERAGE |
if (entities != null) { |
| 330 |
1
1. drawItem : removed call to org/jfree/chart/renderer/xy/ClusteredXYBarRenderer::addEntity → NO_COVERAGE |
addEntity(entities, bar, dataset, series, item, selected, |
| 331 | bar.getCenterX(), bar.getCenterY()); | |
| 332 | } | |
| 333 | } | |
| 334 | } | |
| 335 | ||
| 336 | } | |
| 337 | ||
| 338 | /** | |
| 339 | * Tests this renderer for equality with an arbitrary object, returning | |
| 340 | * true if obj is a | |
| 341 | * ClusteredXYBarRenderer with the same settings as this | |
| 342 | * renderer, and false otherwise. | |
| 343 | * | |
| 344 | * @param obj the object (null permitted). | |
| 345 | * | |
| 346 | * @return A boolean. | |
| 347 | */ | |
| 348 | public boolean equals(Object obj) { | |
| 349 |
1
1. equals : negated conditional → KILLED |
if (obj == this) { |
| 350 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return true; |
| 351 | } | |
| 352 |
1
1. equals : negated conditional → KILLED |
if (!(obj instanceof ClusteredXYBarRenderer)) { |
| 353 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return false; |
| 354 | } | |
| 355 | ClusteredXYBarRenderer that = (ClusteredXYBarRenderer) obj; | |
| 356 |
1
1. equals : negated conditional → KILLED |
if (this.centerBarAtStartValue != that.centerBarAtStartValue) { |
| 357 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return false; |
| 358 | } | |
| 359 |
1
1. equals : replaced return of integer sized value with (x == 0 ? 1 : 0) → KILLED |
return super.equals(obj); |
| 360 | } | |
| 361 | ||
| 362 | /** | |
| 363 | * Returns a clone of the renderer. | |
| 364 | * | |
| 365 | * @return A clone. | |
| 366 | * | |
| 367 | * @throws CloneNotSupportedException if the renderer cannot be cloned. | |
| 368 | */ | |
| 369 | public Object clone() throws CloneNotSupportedException { | |
| 370 |
1
1. clone : mutated return of Object value for org/jfree/chart/renderer/xy/ClusteredXYBarRenderer::clone to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return super.clone(); |
| 371 | } | |
| 372 | ||
| 373 | } | |
Mutations | ||
| 138 |
1.1 |
|
| 149 |
1.1 |
|
| 150 |
1.1 |
|
| 153 |
1.1 |
|
| 154 |
1.1 |
|
| 157 |
1.1 |
|
| 171 |
1.1 |
|
| 179 |
1.1 2.2 3.3 |
|
| 181 |
1.1 2.2 3.3 |
|
| 184 |
1.1 2.2 |
|
| 185 |
1.1 |
|
| 186 |
1.1 |
|
| 192 |
1.1 2.2 |
|
| 193 |
1.1 |
|
| 196 |
1.1 |
|
| 229 |
1.1 |
|
| 237 |
1.1 2.2 |
|
| 253 |
1.1 |
|
| 255 |
1.1 |
|
| 256 |
1.1 2.2 |
|
| 259 |
1.1 2.2 |
|
| 260 |
1.1 |
|
| 261 |
1.1 |
|
| 262 |
1.1 2.2 |
|
| 265 |
1.1 |
|
| 270 |
1.1 |
|
| 273 |
1.1 |
|
| 274 |
1.1 2.2 |
|
| 275 |
1.1 |
|
| 279 |
1.1 |
|
| 282 |
1.1 |
|
| 283 |
1.1 2.2 |
|
| 284 |
1.1 |
|
| 286 |
1.1 |
|
| 291 |
1.1 2.2 |
|
| 294 |
1.1 |
|
| 295 |
1.1 2.2 3.3 4.4 |
|
| 303 |
1.1 2.2 3.3 4.4 |
|
| 310 |
1.1 2.2 |
|
| 311 |
1.1 2.2 |
|
| 314 |
1.1 |
|
| 315 |
1.1 |
|
| 318 |
1.1 |
|
| 321 |
1.1 2.2 3.3 |
|
| 326 |
1.1 |
|
| 329 |
1.1 |
|
| 330 |
1.1 |
|
| 349 |
1.1 |
|
| 350 |
1.1 |
|
| 352 |
1.1 |
|
| 353 |
1.1 |
|
| 356 |
1.1 |
|
| 357 |
1.1 |
|
| 359 |
1.1 |
|
| 370 |
1.1 |


DCST
Diploma in Mechanical Engeneering
Name of Department: Department of Mechanical
Mission Statement:
M1: To provide knowledge in the field of Mechanical Engeneering
M3: To provide hands-on practical knowledge for growing professional in the field of Mechanical by engaging them in self-learning process.
M4: To provide an environment for analytical and logical reasoning.
M5: To provide appropriate assistance that meets the need of the present and emerging computing technologies.
Vision Statement:
To attain excellence in the field of Mechanical Engeneering
Brief Profile of Department:
Mechanical engineering is an engineering branch that combines engineering physics and mathematics principles with materials science to design, analyze, manufacture, and maintain mechanical systems. It is one of the oldest and broadest of the engineering branches.


105 Hansen Rd #50, L6V 3C9
Freshly renovated house for rent at Queen St E and Kennedy. Three bedrooms and 3 piece bath upstairs plus one bedroom with 3 piece bath in bsmt, extended finished deck in back, laundry, parking, cable, you name it. Walking distance to grocery store. Rooms rented separately or whole house. Available Dec 1st. Contact Realtor Samantha Nash for a showing
| Other information | |
|---|---|
| Tel |<PHONE_NUMBER> |
|<EMAIL_ADDRESS>| |
| Room 1 (Standard) | $550 |
| Room 2 (Superior) | $550 |
| Room 3 (Double) | $560 |
| Room 4 (Triple) | $570 |


License
This software is distributed under the Modified BSD License.
All files in the examples directory are PDS.
Achivements
- Analysis of caper input file is doing by the same engine.
- Input files of capella uses caper.
- It seems it uses table construction engine ported by castling.
Such achivements for now.


Menu
About
Education
Skills
Projects
Education
Education
M.S Computer Engineering - San Jose State University
GPA: 4.0/4.0
Coursework : Computer Networks, Network Security, Data Structures & Algorithms / C++, Network Protocols
Graduating December 2019
B.E Computer Science and Engineering - Shivaji University
GPA: 3.5/4.0
Coursework : Computer Networks, Network Security, Data Structures & Algorithms / C++, Network Protocols
Graduated May 2017


---
layout: def
---
The Hamiltonian is an operator that corresponds to the total energy of a system. Its eigenvalues are the allowed energy values of a system, which can be continuous or discret.
Let $H$ be the Hamiltonian operator, $|E_N\rangle$ the energy eigenstate, and $E_n$ the associated energy eigenvalue. The eigenvalue equation is then
$$\begin{align*}
H|E_N\rangle = E_n|E_n\rangle
\end{align*}$$
Notations
Coming soon
Concepts
Coming soon


Originally published as a chapter the tutorial has now been updated and improved:
This extension does not collect data.
Dietrick, Joelle, Gretta Louw, and Owen Mundy. “Browser Blowup: Explode Web Pages Containing Third-Party Trackers.” In Signal Culture Cookbook Vol.2, edited by Jason Bernagozzi, Vol. 2, 2019.


IN
vision
Help
Design Better.
Faster.Together.
The world's leading prototyping, collaboration and workflow platform
Get Started.
Watch video
Tour
Customers
New Features
Enterprise
Blog
Login
Signup


This is a site for movie buffs to post and read reviews about the cinemas in Singapore
Click on the ticket to begin
Ran Fang - Did frontend for our webapp. Unguided projects: Maps 1, Maps 2, Styling
Jiang Yue - Did backend for our webapp. Unguided projects: Translation, Charts 2, Maps 3
Meghana Narayanan - Did backend for our webapp. Unguided projects: Images 1, Sentiment Analysis, Images 2


WE'RE BACK! A DINOSAUR'S STORY A film review by Scott Renshaw Copyright 1993 Scott Renshaw
Voices: John Goodman, Joey Shea, Yeardley Smith, Kenneth Mars, Walter Cronkite. Screenplay: John Patrick Shanley. Directors: Dick Zondag & Ralph Zondag.
For the first time in several years, Disney does not have a new animated release for the holidays, as The House the Mouse Built instead readies THE LION KING for summer 1994. Into that void steps WE'RE BACK! A DINOSAUR'S STORY, hoping to rake up some of the family entertainment dollars now available for the taking. If I didn't know how long animation takes to produce, I'd swear Universal had thrown it together in a few months just for that purpose. WE'RE BACK is sadly uninspired kiddie fare, perhaps moderately diverting for elementary schoolers but likely to be a tedious 70 minutes for their parents.
WE'RE BACK is the story of four dinosaurs subjected to a unique experiment by time-traveling scientist Captain NewEyes (voice of Walter Cronkite). Rex the Tyrannosaurus rex (John Goodman), Elsa the pterodactyl (Felicity Kendal), Woog the triceratops (Rene Levant) and Dweeb the apatosaurus (Charles Fleischer) are all given an intelligence-enhancing grain and invited to the future to fulfill the wishes of children who want to see a real dinosaur. They agree, and find themselves in modern day New York where they meet two lonely kids: cocky Louie (Joey Shea) and poor-little-rich-girl Cecilia (Yeardley Smith). They also meet Captain NewEyes' evil brother Professor ScrewEyes (Kenneth Mars), whose scary circus threatens both children and dinosaurs.
From a story standpoint, WE'RE BACK is a mess. It seems to have no idea what it wants to be--fast paced adventure, goofy comedy, dark mood piece--so it throws a little bit of everything into the stew in the hope that something will work. But the chase sequences are only interesting thanks to gut-churning computer effects, the comedy is limp and the scarier segments, which are the best, come far too late. There is even an attempt at a musical production number, a lively enough James Horner-Thomas Dolby composition called "Roll Back the Rock," but it strains so hard to be charming that it's an effort to watch. The schizophrenic tone is not necessarily a problem for a 7-year-old attention span, but the lack of continuity gave me a headache.
Visually, the film fares only slightly better. The prehistoric setting is appropriately gloomy, but we only see it for about a minute. Most of the film takes place in a New York colored in oranges and golds, and it's just not at all interesting to look at. Professor ScrewEyes' circus is dark and creepy, but it is a real missed opportunity. Directors Dick and Ralph Zondag could have gone for a real PINOCCHIO-style funhouse of frights, but they just let the circus sit there full of unexplored potential. They manage to pull out one truly arresting image, involving a flock of crows, but the film is almost over by that time. Nothing in WE'RE BACK captures the eye or the imagination.
Perhaps the fatal flaw in WE'RE BACK is a collection of characters which might almost scrape together a personality between them. Disney built its empire on carefully created and memorably performed characters, but screenwriter John Patrick Shanley turns in as bland a bunch as I can imagine. John Goodman does a half-hearted Bing Crosby impression as the affable Rex, Charles Fleischer simply recycles Roger Rabbit as Dweeb, and Felicity Kendal and Rene Levant are each thrown a token character trait as the other dinosaurs. Walter Cronkite and Julia Child seem to be present only for the novelty of doing trademark lines to animation, and Jay Leno is genuinely annoying as Captain NewEyes' alien sidekick. The kids are not bad, nicely performed by Joey Shea and "The Simpsons'" Yeardley Smith, but the only real fun comes from Martin Short as a frustrated clown in the scary circus. His antics are as random as everything else, but at least they were funny.
As if the slipshod Disney knockoffs (the contract signing from THE LITTLE MERMAID, zoom-ins on the wide-eyed heroine) weren't bad enough, WE'RE BACK gives in to insipid moralizing. Uncle Walt had more respect for kids than that. It's too bad when parents' only matinee options are as monotonous as WE'RE BACK. Better to rent FREE WILLY again.
Or wait for THE LION KING ... seven months and counting.
On the Renshaw scale of 0 to 10 dino-snores: 3.
-- Scott Renshaw Stanford University Office of the General Counsel
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


XOCL extends OCL with a number of imperative programming features, which turn it into a powerful programming language.
Objects are instances of classes. Objects are created by calling a class constructor. The syntax is as follows:
class_name(parameter_values)
Assumng that the Components model example is in scope, the following can be typed into the console:
Port();
This will create an instance of the class Port using the default (empty) constructor.
Note, if we define a constructor for the class then we could call this by passing the appropriate parameter values. For example, if the following constructor has been created:
context Port @Constructor(name,type) end
We can pass the name and type of the Port to the instance like so:
Port("x","Integer");
An alternative instantiation syntax is also provided, which enables values to be bound to slots using name bindings. The following binds the values to the slots by their name:
Port[name = "x", type = "Integer");
Values can be assigned to attributes (slot update) using the assignment operator.
var := expression // assigns the result of evaluating the expression to var
The following operation gives an example of setting the owner of a Component to be the ComponentModel, c.
context Component @Operation setOwner(c : ComponentModel) self.owner := c end
Note, that self is required when setting slot values.
A common assignment pattern is adding a new element to a collection. This can be easily achieved using the including() operation:
context ComponentModel @Operation addToComponents(v : Component) self.components := self.components->including(v) end
A sequential operator (";") is provided for sequencing different operations. For example, adding a component to a component model and setting it to be owned by the component model.
context ComponentModel @Operation addToComponents(c : Component) self.components := self.components->including(v); c.owner := self end
The dot notation (".") is used to invoke operations on objects. The following operation invokes the setOwner() operation on the component, c.
context ComponentModel @Operation addToComponents(c : Component) self.components := self.components->including(v); c.setOwner(self) end
XOCL provides a number of looping constructs, including while loops and for loops.
The syntax for a "for" loop is as follows:
@For var in collection do expression end
The reAssign() operation uses a for loop to reassign any connections that target the Port, old, to the Port, new.
context ComponentModel @Operation reAssign(old:Port,new:Port) @For c in connectors do if c.target = old then c.target := new end end end
The syntax for a "while" loop is as follows:
@While condition do expression end
Here is an example of a simple counter that makes use of a while loop.
context Root @Operation count() let x = 0 in @While x < 1000000 do x := x + 1 end; x.println() end end


Let me answer your beautiful question by parts.
- What is this? An amazing On Air sign. The app you were waiting for.
 Everyone. More importantly super low budget radios, and (like in my case) a very loud digital agancy that needed a visual cue to be silent while someone is in call with a client.
- Why does it look like it was designed by a 5 years old? @huemula said she was going to design it. So, talk to her, it's not my fault.
- Why did you build this piece of crap? Because building crappy sites is much easier than building good ones. And I don't know how to code.
Thanks!
@tomicrom


Preferences
Fission's preferences can be accessed from the Fission menu.
Fission's Preferences window
Audio Settings
Fade around removed audio: This setting adjusts the length of audio automatically faded in and out when removing a section of audio from a file, when the Fade Around Removed Audio option in the Clip menu is on. The time length of fades can be adjusted with this preference. To prevent automatic fades altogether, turn the Fade Around Removed Audio menu option off.
Play audio through: Adjust this to change the output device through which audio from Fission plays.
Audio Scrubbing: When this setting is active, audio near the playhead will be heard as the playhead is moved.
Appearance
Appearance: Select between a dark or light theme for Fission.
Software Update
Automatically check for software updates: With this option activated, Fission compares itself to the most current version available from our server and alerts you when a new version is available. Leave this on and Fission will help you stay up-to-date.


Caution: This page is still in beta testing so some features may not work properly. Chrome, Firefox, IE9 or greater, or Safari are required to properly view this page.
Text Search: Complete a field and press a Search by button to search for wells based on that attribute. Selecting LAS data will open the LAS data in a text file. The selected LAS data can be saved and downloaded by using the save page as function.
Map of Arizona State Meridians
| API No | State Permit No | Operator | Well Name | County | Township | Range | Section | Depth (ft) | Formation at Depth | Well Folder | Scanned Well Log | LAS Data |
|---|


Me
User
Role
Service Account
Client Certificate
Agent
Manage Role
Role
All
Administrator
User
Administrator
Id
<EMAIL_ADDRESS>Maintainer
Delete
<EMAIL_ADDRESS>Become maintainer
Delete
Id
Role
Submit
Add User
User
Id
<EMAIL_ADDRESS>Maintainer
Delete
Id
Role
Submit
Add User


clay - A minimalist framework for large scale OO Projects
Clay introduces a method ensemble to both oo::class and oo::object called clay. This ensemble handles all of the high level interactions within the framework. Clay stores structured data. Clan manages method delegation. Clay has facilities to manage the complex interactions that come about with mixins.
The central concept is that inside of every object and class (which are actually objects too) is a dict called clay. What is stored in that dict is left to the imagination. But because this dict is exposed via a public method, we can share structured data between object, classes, and mixins.
Clay uses a standardized set of method interactions and introspection that TclOO already provides to perform on-the-fly searches. On-the-fly searches mean that the data is never stale, and we avoid many of the sorts of collisions that would arise when objects start mixing in other classes during operation.
The clay methods for both classes and objects have a get and a set method. For objects, get will search through the local clay dict. If the requested leaf is not found, or the query is for a branch, the system will then begin to poll the clay methods of all of the class that implements the object, all of that classes’ ancestors, as well as all of the classes that have been mixed into this object, and all of their ancestors.
Intended branches on a tree end with a directory slash (/). Intended leaves are left unadorned. This is a guide for the tool that builds the search results to know what parts of a dict are intended to be branches and which are intended to be leaves. For simple cases, branch marking can be ignored:
::oo::class create ::foo { } ::foo clay set property/ color blue ::foo clay set property/ shape round set A [::foo new] $A clay get property/ {color blue shape round} $A clay set property/ shape square $A clay get property/ {color blue shape square}
But when you start storing blocks of text, guessing what field is a dict and what isn’t gets messy:
::foo clay set description {A generic thing of designated color and shape} $A clay get description {A generic thing of designated color and shape} Without a convention for discerning branches for leaves what should have been a value can be accidentally parsed as a dictionary, and merged with all of the other values that were never intended to be merge. Here is an example of it all going wrong: ::oo::class create ::foo { } # Add description as a leaf ::foo clay set description {A generic thing of designated color and shape} # Add description as a branch ::foo clay set description/ {A generic thing of designated color and shape} ::oo::class create ::bar { superclass foo } # Add description as a leaf ::bar clay set description {A drinking establishment of designated color and shape and size} # Add description as a branch ::bar clay set description/ {A drinking establishment of designated color and shape and size} set B [::bar new] # As a leaf we get the value verbatim from he nearest ancestor $B clay get description {A drinking establishment of designated color and shape and size} # As a branch we get a recursive merge $B clay get description/ {A drinking establishment of designated color and size thing of}
Clay is built using the oo::dialect module from Tcllib. oo::dialect allows you to either add keywords directly to clay, or to create your own metaclass and keyword set using Clay as a foundation. For details on the keywords and what they do, consult the functions in the ::clay::define namespace.
Method Delegation It is sometimes useful to have an external object that can be invoked as if it were a method of the object. Clay provides a delegate ensemble method to perform that delegation, as well as introspect which methods are delegated in that manner. All delegated methods are marked with html-like tag markings (< >) around them.
::clay::define counter { Variable counter 0 method incr {{howmuch 1}} { my variable counter incr counter $howmuch } method value {} { my variable counter return $counter } method reset {} { my variable counter set counter 0 } } ::clay::define example { variable buffer constructor {} { # Build a counter object set obj [namespace current]::counter ::counter create $obj # Delegate the counter my delegate <counter> $obj } method line {text} { my <counter> incr append buffer $text } } set A [example new] $A line {Who’s line is it anyway?} $A <counter> value 1
Because many features in this package may be added as commands to future tcl cores, or be provided in binary form by packages, I need a declaritive way of saying Create this command if there isn't one already. The ninja argument is a script to execute if the command is created by this mechanism.
Perform a noop. Useful in prototyping for commenting out blocks of code without actually having to comment them out. It also makes a handy default for method delegation if a delegate has not been assigned yet.
Process the queue of objects to be destroyed
Mark an objects for destruction on the next cleanup
Append a line of text to a variable. Optionally apply a string mapping.
Convert a string representation of a uuid into its binary format.
Compare two uuids for equality.
uuid generate -> string rep of a new uuid uuid equal uuid1 uuid2
Output a dictionary removing any . entries added by clay::tree::merge
Helper function for ::clay::tree::sanitize Formats the string representation for a dictionary element within a human readable stream of lines, and determines if it needs to call itself with further indentation to express a sub-branch
Return the path as a storage path for clay::tree with all branch terminators removed. This command will also break arguments up if they contain /.
Example:
> clay::tree::storage {foo bar baz bang} foo bar baz bang > clay::tree::storage {foo bar baz bang/} foo bar baz bang > clay::tree::storage {foo bar baz bang:} foo bar baz bang: > clay::tree::storage {foo/bar/baz bang:} foo bar baz bang: > clay::tree::storage {foo/bar/baz/bang} foo bar baz bang
Set an element with a recursive dictionary, marking all branches on the way down to the final element. If the value does not exists in the nested dictionary it is added as a leaf. If the value already exists as a branch the value given is merged if the value is a valid dict. If the incoming value is not a valid dict, the value overrides the value stored, and the value is treated as a leaf from then on.
Example:
> set r {} > ::clay::tree::dictset r option color default Green . {} option {. {} color {. {} default Green}} > ::clay::tree::dictset r option {Something not dictlike} . {} option {Something not dictlike} # Note that if the value is not a dict, and you try to force it to be # an error with be thrown on the merge > ::clay::tree::dictset r option color default Blue missing value to go with key
A recursive form of dict merge, intended for modifying variables in place.
Example:
> set mydict {sub/ {sub/ {description {a block of text}}}} > ::clay::tree::dictmerge mydict {sub/ {sub/ {field {another block of text}}}}] > clay::tree::print $mydict sub/ { sub/ { description {a block of text} field {another block of text} } }
A recursive form of dict merge
A routine to recursively dig through dicts and merge adapted from http://stevehavelka.com/tcl-dict-operation-nested-merge/
Example:
> set mydict {sub/ {sub/ {description {a block of text}}}} > set odict [clay::tree::merge $mydict {sub/ {sub/ {field {another block of text}}}}] > clay::tree::print $odict sub/ { sub/ { description {a block of text} field {another block of text} } }
Named Procedures as new command
This proc will generate a namespace, a "mother of all classes", and a rudimentary set of policies for this dialect.
Support commands; not intended to be called directly.
Implementation of the languages' define command
New OO Keywords for clay
An annotation that objects of this class interact with delegated methods. The annotation is intended to be a dictionary, and the only reserved key is description, a human readable description.
Specify the a method for the class object itself, instead of for objects of the class
And alias to the new Class_Method keyword
Define an option for the class
Define a class of options All field / value pairs will be be inherited by an option that specify name as it class field.
This keyword can also be expressed:
property variable NAME {default DEFAULT}
Variables registered in the variable property are also initialized (if missing) when the object changes class via the morph method.
Produce the body of an ensemble's public dispatch method ensemble is the name of the the ensemble. einfo is a dictionary of methods for the ensemble, and each value is a script to execute on dispatch
Example:
::clay::ensemble_methodbody foo { bar {tailcall my Foo_bar {*}$args} baz {tailcall my Foo_baz {*}$args} clock {return [clock seconds]} default {puts "You gave me $method"} }
Cancel a scheduled event
Generate an event Adds a subscription mechanism for objects to see who has recieved this event and prevent spamming or infinite recursion
Called recursively to produce a list of who recieves notifications
Final delivery to intended recipient object
Evaluate an event script in the global namespace
Schedule an event to occur later
Subscribe an object to an event pattern
Unsubscribe an object from an event pattern
An object which is intended to be it's own class.
Methods
Return this class and all ancestors in search order.
Return a complete dump of this object's clay data, but only this object's clay data.
Pull a chunk of data from the clay system. If the last element of path is a branch, returns a recursive merge of all data from this object and it's constituent classes of the data in that branch. If the last element is a leaf, search this object for a matching leaf, or search all constituent classes for a matching leaf and return the first value found. If no value is found, returns an empty string. If a branch is returned the topmost . entry is omitted.
Pull a chunk of data from the class's clay system. If no value is found, returns an empty string. If a branch is returned the topmost . entry is omitted.
Pull a chunk of data from the class's clay system. If no value is found, returns an empty string.
Recursively merge the dictionaries given into the object's local clay storage.
Replace the contents of the internal clay storage with the dictionary given.
Return the first matching value for the path in either this class's clay data or one of its ancestors
Merge the conents of value with the object's clay storage at path.
clay::object This class is inherited by all classes that have options.
Methods
Return the class this object belongs to, all classes mixed into this object, and all ancestors of those classes in search order.
Store VALUE in such a way that request in SEARCH for PATH will always return it until the cache is flushed
Pull a value from either the object's clay structure or one of its constituent classes that matches the field name. The order of search us:
1. The as a value in local dict variable config
2. The as a value in local dict variable clay
3. As a leaf in any ancestor as a root of the clay tree
4. As a leaf in any ancestor as const field
5. As a leaf in any ancestor as option field default
Introspect or control method delegation. With no arguments, the method will return a key/value list of stubs and objects. With just the stub argument, the method will return the object (if any) attached to the stub. With a stub and an object this command will forward all calls to the method stub to the object.
Return a complete dump of this object's clay data, as well as the data from all constituent classes recursively blended in.
Return a dictionary describing the method ensembles to be assembled for this object
Evaluated a script in the namespace of this object
Trigger the InitializePublic private method
Returns 1 if path exists in either the object's clay data. Values greater than one indicate the element exists in one of the object's constituent classes. A value of zero indicates the path could not be found.
Wipe any caches built by the clay implementation
A convenience wrapper for
oo::objdefine [self] forward {*}$args
Pull a chunk of data from the clay system. If the last element of path is a branch (ends in a slash /), returns a recursive merge of all data from this object and it's constituent classes of the data in that branch. If the last element is a leaf, search this object for a matching leaf, or search all constituent classes for a matching leaf and return the first value found. If no value is found, returns an empty string.
A modified get which is tailored to pull only leaf elements
Recursively merge the dictionaries given into the object's local clay storage.
Perform [oo::objdefine [self] mixin] on this object, with a few additional rules: Prior to the call, for any class was previously mixed in, but not in the new result, execute the script registered to mixin/ unmap-script (if given.) For all new classes, that were not present prior to this call, after the native TclOO mixin is invoked, execute the script registered to mixin/ map-script (if given.) Fall all classes that are now present and “mixed in”, execute the script registered to mixin/ react-script (if given.)
With no arguments returns the map of stubs and classes mixed into the current object. When only stub is given, returns the classes mixed in on that stub. When stub and classlist given, replace the classes currently on that stub with the given classes and invoke clay mixin on the new matrix of mixed in classes.
Return either self if that path exists in the current object, or return the first class (if any) along the clay search path which contains that element.
Replace the contents of the internal clay storage with the dictionary given.
Return true, and set valuevar to the value and isleafar to true for false if PATH was found in the cache.
Source the given filename within the object's namespace
Merge the conents of value with the object's clay storage at path.
Instantiate variables. Called on object creation and during clay mixin.
Sean Woods<EMAIL_ADDRESS>This document, and the package it describes, will undoubtedly contain bugs and other problems. Please report such in the category oo of the Tcllib Trackers. Please also report any ideas for enhancements you may have for either package and/or documentation.
When proposing code changes, please provide unified diffs, i.e the output of diff -u.
Note further that attachments are strongly preferred over inlined patches. Attachments can be made by going to the Edit form of the ticket immediately after its creation, and then using the left-most button in the secondary navigation bar.
Programming tools
Copyright © 2018 Sean Woods <yoda@etoyoc.com>


Pink-Ball Test: Bangladesh Name Mehidy Hasan, Taijul Islam as Concussion Substitutes
Bangladesh now have two concussion replacements. Mehidy can only bat as he replaced a batsman while Taijul can bowl for the same reason.
Bangladesh’s Mehidy Hasan and Taijul Islam were named concussion substitutes for Liton Das and Nayeem Hasan respectively after both batsmen picked up knocks on the helmet by Mohammed Shami deliveries, during their first innings against India on Day 1 of the second Test at the Eden Gardens on Friday.
Bangladesh now have two concussion replacements. Mehidy can only bat as he replaced a batsman while Taijul can bowl for the same reason.
Liton was looking good on 15 when a quick Shami delivery thudded on to his helmet. He took off his helmet immediately and took a look as Shami walked up to apologise.
The physiotherapist rushed in as per the latest concussion protocols. Liton continued for some time but after umpires Joel Wilson and Marais Erasmus had a look just before tea, he was seen walking off and later retired hurt.
Liton scored a brisk 24 to show some fight after all Bangladesh batsmen succumbed to the might of the Indian pace battery.
Nayeem, playing his first match of the two-match series, scored 19 and was hit on the helmet just after tea.
Meanwhile, Ishant Sharma took five wickets to lead the pacers’ show as Bangladesh were shot out for 106 before the hosts reached 35/1 at dinner break on Day 1 of the first Day-Night Test in the country at the Eden Gardens here on Friday.
Opener Rohit Sharma, who was dropped on 12 by Al Amin Hossain off Abu Jayed, was batting on 13 with Cheteshwar Pujara who was unbeaten on 7.
Mayank Agarwal, who scored a career-best 243 in the first Test, was caught at gully by Mehidy Hasan off Al Amin.
For breaking news and live news updates, like us on Facebook or follow us on Twitter and Instagram. Read more on Cricket Latest News on India.com.
Story Timeline
- 22 Nov 2019 Pink-Ball Test: Bangladesh Name Mehidy Hasan, Taijul Islam as Concussion Substitutes
- 22 Nov 2019 WATCH: Eden Crowd Gets Nostalgic, Chants of 'Sachin, Sachin' During Pink Test Will Give Goosebumps
- 22 Nov 2019 'Spirit of Cricket': India Physio Attends Nayeem After Nasty Hit on Helmet | WATCH
- 22 Nov 2019 IND vs BAN, Day/Night Test, Day 1: Three Wickets for Umesh Yadav as Bangladesh Find Themselves in Deep Trouble
Comments - Join the Discussion


My final project was a personal online portfolio that will allow me to present my resume and writing samples to future employers, internship interviewers, and family. The content showcases my job experience, personal biography, blogs, and past writing. While my website is professional I still wanted it to reflect my personality as much as possible. As such, my website has a bold color scheme and city theme throughout.
Content on each page of my website contains different material within a similar layout. Each page contains a header, content body, and footer. The navigation bar at the top of each page, under the header, allows easily access to all the content on the website. Each page follows the theme of its title. For example, the resume page has my resume, and the writing page will have writing samples, et cetera.
The techniques I used to design and build the website were very similar to the method we learned in class. After deciding what my website was going to be (personal portfolio), I created a site map to help me organize my thoughts. The site map was a great point of reference to help me with my next step, website layouts/prototypes. The prototypes helped me plan what my website was going to look like, not just what it would contain. All in all, the final website looked similar to my original prototypes.
Once I had what my website was going to look like I started to build the most basic home page. I began with a skeleton frame on columns and bars, which helped me, create an outline for all the pages. The first things I made were elements that would be present on every page; for example to header, navigation bar, social media buttons, search bar, and footer. After those were finish and applied to all the pages I started to customize the decoration and content put on each page.
Content was added to all the pages. All the pages were eventually linked together, allowing my to travel from page to page through the navigation bar. Lastly, I styled the pages with my color scheme and additional pictures to compliment the themes. Minor additions were added later, like a quote in the footer, fun facts in the about section, and links to outside website (i.e. Facebook, Green Philly Blog).
My style greatly reflected my personality. While still having the atmosphere of a professional resource, my color scheme was mostly bright hues and pastels and my header and footer resembled a city skyline and graffiti. All the icons I used for the navigation bar, social media, and organizations are the simplest form. I do not want my website to have too much going on or for it to be an eyesore.
I faced some challenges with designing and building my website. My first biggest challenge was making the navigation bar I got from Bootstrap. Adding it was not hard, making the icons, padding and margins, and customized buttons was the most difficult. The hardest was trying to remove the search bar from the navigation bar and putting it underneath. It took a while to figure out because I had to look though a lot of Bootstrap code to remove it without messing up everything else I did.
Another challenge I had was on the Resume and Writing pages. I originally wanted my second menu to scroll the requested class when a button was selected, but it didn’t want to work and I wouldn’t find anything on the Internet to help out. So I ended up making cloned pages for each section of the resume or writing samples and had the buttons on the second menu direct me to the new pages. In the end it all worked out.
My final challenge I encountered was repeating the image of my city skyline across the bottom of the page but above the footer. Some instructional websites aided me with the uploading of the image but not the repetition. I eventually figured out that I was getting my x-axis and y-axis confused (I was never very good at math and graphing). The image repeated nicely and I was able to figure out how have it respond the size of the page.
I used three Bootstrap templates: a navbar, a search bar, and a sidebar. The navbar and the search bar were located on all pages of the website while only the sidebar was located on the Resume and Writing pages for extra organization. I customized the navbar by removing some of the original buttons (such as the search bar). Then added icons and padded the buttons so they looked how I wanted them to look. I removed the search bar from the navbar and made it its own element. I reworded the content of the search bar and the accompanied button so they both read ‘search’. Finally, the sidebars I changed the link colors so it would match the theme.
The biggest thing I learned from building my final website was that planning pays off. I am positive that if I did not make a site map or prototypes I would have been lost when starting to create my website. Also, my imagination sometimes goes a little wild so having a reference kept me on track.
Thank you!