Menu
▾
▴
[Fudaa-svn-commit] SF.net SVN: fudaa:[8370] trunk/framework/ctulu-common/src
|
From: <de...@us...> - 2013-04-03 09:20:23
|
Revision: 8370
http://fudaa.svn.sourceforge.net/fudaa/?rev=8370&view=rev
Author: deniger
Date: 2013-04-03 09:20:14 +0000 (Wed, 03 Apr 2013)
Log Message:
-----------
Ajout d'un iterator sur un tableau d'entier
Added Paths:
-----------
trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/iterator/FixedIntegerIterator.java
trunk/framework/ctulu-common/src/test/java/org/fudaa/ctulu/iterator/
trunk/framework/ctulu-common/src/test/java/org/fudaa/ctulu/iterator/FixedIntegerIteratorTest.java
Copied: trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/iterator/FixedIntegerIterator.java (from rev 8335, trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/iterator/NumberIterator.java)
===================================================================
--- trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/iterator/FixedIntegerIterator.java (rev 0)
+++ trunk/framework/ctulu-common/src/main/java/org/fudaa/ctulu/iterator/FixedIntegerIterator.java 2013-04-03 09:20:14 UTC (rev 8370)
@@ -0,0 +1,262 @@
+/*
+ * Geotools 2 - OpenSource mapping toolkit
+ * (C) 2003, Geotools Project Managment Committee (PMC)
+ * (C) 2000, Institut de Recherche pour le D\xE9veloppement
+ * (C) 1999, P\xEAches et Oc\xE9ans Canada
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ *
+ * Contacts:
+ * UNITED KINGDOM: James Macgill
+ * mailto:j.m...@ge...
+ * FRANCE: Surveillance de l'Environnement Assist\xE9e par Satellite
+ * Institut de Recherche pour le D\xE9veloppement / US-Espace
+ * mailto:se...@te...
+ *
+ * CANADA: Observatoire du Saint-Laurent
+ * Institut Maurice-Lamontagne
+ * mailto:os...@os...
+ */
+package org.fudaa.ctulu.iterator;
+
+// Miscellaneous
+import com.memoire.fu.FuEmptyArrays;
+import java.util.Arrays;
+import org.apache.commons.lang.StringUtils;
+import org.fudaa.ctulu.CtuluLibArray;
+
+/**
+ * It\xE9rateur balayant les barres et \xE9tiquettes de graduation d'un axe. Cet it\xE9rateur retourne les positions des graduations \xE0 partir de la valeur
+ * minimale jusqu'\xE0 la valeur maximale.
+ *
+ * @version $Id: NumberIterator.java,v 1.1 2007-01-17 10:45:26 deniger Exp $
+ * @author Martin Desruisseaux
+ */
+public class FixedIntegerIterator implements TickIterator {
+
+ private final int[] values;
+ /**
+ * Pour eviter les loop infinie.
+ */
+ private static final int MAX_ITERATION = 200;
+ int iterationDone_;
+ /**
+ * Valeur limite des graduations. La derni\xE8re graduation n'aura pas n\xE9cessairement cette valeur. Cette valeur est fix\xE9e par {@link #init}.
+ */
+ private int maximum_;
+ /**
+ * Valeur de la premi\xE8re graduation principale. Cette valeur est fix\xE9e par {@link #init}.
+ */
+ private int minimum_;
+ /**
+ * Index de la graduation principale en cours de tra\xE7age. Cette valeur commence \xE0 0 et sera modifi\xE9e \xE0 chaque appel \xE0 {@link #next}.
+ */
+ private int idx;
+
+ /**
+ * Construit un it\xE9rateur par d\xE9faut. La m\xE9thode {@link #init(double, double, float, float)}<u>doit </u> \xEAtre appel\xE9e avant que cet it\xE9rateur ne
+ * soit utilisable.
+ */
+ public FixedIntegerIterator(int[] values) {
+ this.values = values == null ? FuEmptyArrays.INT0 : CtuluLibArray.copy(values);
+ Arrays.sort(values);
+ }
+
+ public FixedIntegerIterator(final FixedIntegerIterator _it) {
+ this.values = _it.values;
+ initFrom(_it);
+ // this.locale = locale;
+ }
+
+ protected final void initFrom(final FixedIntegerIterator _it) {
+ if (_it != null) {
+ maximum_ = _it.maximum_;
+ minimum_ = _it.minimum_;
+ idx = _it.idx;
+ }
+ }
+
+ /**
+ * Initialise l'it\xE9rateur.
+ *
+ * @param _minimum Valeur minimale de la premi\xE8re graduation.
+ * @param _maximum Valeur limite des graduations. La derni\xE8re graduation n'aura pas n\xE9cessairement cette valeur.
+ * @param _visualLength Longueur visuelle de l'axe sur laquelle tracer la graduation. Cette longueur doit \xEAtre exprim\xE9e en pixels ou en points.
+ * @param _visualTickSpacing Espace \xE0 laisser visuellement entre deux marques de graduation. Cet espace doit \xEAtre exprim\xE9 en pixels ou en points
+ * (1/72 de pouce).
+ */
+ protected void init(final double _minimum, final double _maximum, final float _visualLength,
+ final float _visualTickSpacing) {
+ if (_minimum == this.minimum_ && _maximum == this.maximum_) {
+ rewind();
+ return;
+ }
+ AssertValues.ensureFinite("minimum", _minimum);
+ AssertValues.ensureFinite("maximum", _maximum);
+ minimum_ = (int) Math.min(_minimum, _maximum);
+ maximum_ = (int) Math.max(_minimum, _maximum);
+
+ initCounters();
+ }
+
+ @Override
+ public void initExact(double _min, double _max, int _nbIteration, int _nbSousIteration) {
+ initExactCommon(_min, _max, _nbSousIteration);
+ }
+
+ private void initExactCommon(double _min, double _max, int _nbSousIteration) {
+ minimum_ = (int) Math.min(_min, _max);
+ maximum_ = (int) Math.max(_min, _max);
+ initCounters();
+ }
+
+ @Override
+ public void initExactFromDist(double _min, double _max, double _increment, int _nbSousIteration) {
+ initExactCommon(_min, _max, _nbSousIteration);
+
+ }
+
+ @Override
+ public final Object clone() throws CloneNotSupportedException {
+ final FixedIntegerIterator res = (FixedIntegerIterator) super.clone();
+ res.initFrom(this);
+ return res;
+ }
+
+ /**
+ * Retourne l'\xE9tiquette de la graduation courante. On n'appele g\xE9n\xE9ralement cette m\xE9thode que pour les graduations majeures, mais elle peut aussi
+ * \xEAtre appel\xE9e pour les graduations mineures. Cette m\xE9thode retourne
+ * <code>null</code> s'il n'y a pas d'\xE9tiquette pour la graduation courante.
+ */
+ @Override
+ public String currentLabel() {
+ if (idx >= 0 && idx < values.length) {
+ return Integer.toString(values[idx]);
+ }
+ return StringUtils.EMPTY;
+ }
+
+ /**
+ * Returns the position where to draw the current tick. The position is scaled from the graduation's minimum to maximum. This is usually the same
+ * number than {@link #currentValue}. The mean exception is for logarithmic graduation, in which the tick position is not proportional to the tick
+ * value.
+ */
+ @Override
+ public double currentPosition() {
+ if (idx >= 0 && idx < values.length) {
+ return values[idx];
+ }
+ return Double.NaN;
+ }
+
+ /**
+ * Retourne la valeur de la graduation courante. Cette m\xE9thode peut \xEAtre appel\xE9e pour une graduation majeure ou mineure.
+ */
+ @Override
+ public double currentValue() {
+ return currentPosition();
+ }
+
+ @Override
+ public String formatSubValue(final double _v) {
+ return Integer.toString((int) _v);
+ }
+
+ @Override
+ public String formatValue(final double _v) {
+ return Integer.toString((int) _v);
+ }
+
+ @Override
+ public double getIncrement() {
+ return 1;
+ }
+
+ /**
+ * Indique s'il reste des graduations \xE0 retourner. Cette m\xE9thode retourne
+ * <code>true</code> tant que {@link #currentValue}ou {@link #currentLabel}peuvent \xEAtre appel\xE9es.
+ */
+ @Override
+ public boolean hasNext() {
+ return iterationDone_ < MAX_ITERATION && idx >= 0 && idx < values.length && values[idx] <= maximum_;
+ }
+
+ /**
+ * Initialise l'it\xE9rateur.
+ *
+ * @param _minimum Valeur minimale de la premi\xE8re graduation.
+ * @param _maximum Valeur limite des graduations. La derni\xE8re graduation n'aura pas n\xE9cessairement cette valeur.
+ * @param _nbTick le nombre de graduation
+ */
+ @Override
+ public void init(final double _minimum, final double _maximum, final int _nbTick) {
+ init(_minimum, _maximum, _nbTick <= 1 ? DEFAULT_STICK_NUMBER : _nbTick, 1);
+ }
+
+ /**
+ * Indique si la graduation courante est une graduation majeure.
+ *
+ * @return <code>true</code> si la graduation courante est une graduation majeure, ou <code>false</code> si elle est une graduation mineure.
+ */
+ @Override
+ public boolean isMajorTick() {
+ return true;
+ }
+
+ @Override
+ public double getValueFromPosition(final double _v) {
+ return _v;
+ }
+
+ @Override
+ public double getPositionFromValue(final double _v) {
+ return _v;
+ }
+
+ /**
+ * Passe \xE0 la graduation suivante.
+ */
+ @Override
+ public void next() {
+ iterationDone_++;
+ idx++;
+ }
+
+ /**
+ * Passe directement \xE0 la graduation majeure suivante.
+ */
+ @Override
+ public void nextMajor() {
+ next();
+ }
+
+ /**
+ * Replace l'it\xE9rateur sur la premi\xE8re graduation.
+ */
+ @Override
+ public void rewind() {
+ initCounters();
+ }
+
+ public void initCounters() {
+ idx = Arrays.binarySearch(values, minimum_);
+ if (idx < 0) {
+ idx = -idx - 1;
+ }
+
+ iterationDone_ = 0;
+ }
+}
\ No newline at end of file
Added: trunk/framework/ctulu-common/src/test/java/org/fudaa/ctulu/iterator/FixedIntegerIteratorTest.java
===================================================================
--- trunk/framework/ctulu-common/src/test/java/org/fudaa/ctulu/iterator/FixedIntegerIteratorTest.java (rev 0)
+++ trunk/framework/ctulu-common/src/test/java/org/fudaa/ctulu/iterator/FixedIntegerIteratorTest.java 2013-04-03 09:20:14 UTC (rev 8370)
@@ -0,0 +1,60 @@
+/*
+ GPL 2
+ */
+package org.fudaa.ctulu.iterator;
+
+import java.util.ArrayList;
+import java.util.List;
+import junit.framework.TestCase;
+
+/**
+ *
+ * @author Frederic Deniger
+ */
+public class FixedIntegerIteratorTest extends TestCase {
+
+ public void testIterate() {
+ int[] values = new int[]{-1, 1, 10, 100};
+ FixedIntegerIterator iterator = new FixedIntegerIterator(values);
+ iterator.init(-100, 1000, 1);
+ assertTrue(iterator.hasNext());
+ assertEquals(-1, (int) iterator.currentValue());
+
+
+ List<String> readValues = getValuesForIterator(iterator);
+ assertSame(readValues, new String[]{"-1", "1", "10", "100"});
+
+ iterator.init(-1, 1000, 1);
+ readValues = getValuesForIterator(iterator);
+ assertSame(readValues, new String[]{"-1", "1", "10", "100"});
+
+ iterator.init(-1, 99, 1);
+ readValues = getValuesForIterator(iterator);
+ assertSame(readValues, new String[]{"-1", "1", "10"});
+
+
+ iterator.init(9, 99, 1);
+ readValues = getValuesForIterator(iterator);
+ assertSame(readValues, new String[]{"10"});
+
+
+ iterator.init(101, 1000, 1);
+ readValues = getValuesForIterator(iterator);
+ assertTrue(readValues.isEmpty());
+ }
+
+ private List<String> getValuesForIterator(FixedIntegerIterator iterator) {
+ List<String> readValues = new ArrayList<String>();
+ for (final TickIterator it = iterator; it.hasNext(); it.next()) {
+ readValues.add(iterator.currentLabel());
+ }
+ return readValues;
+ }
+
+ public void assertSame(List<String> readValues, String[] expectedValues) {
+ assertEquals(readValues.size(), expectedValues.length);
+ for (int i = 0; i < expectedValues.length; i++) {
+ assertEquals(expectedValues[i], readValues.get(i));
+ }
+ }
+}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
