litesoft
Subversion Repository Public Repository

litesoft

URLs

Copy to Clipboard
Explore
Commits

Diff Revisions 947 vs 948 for /trunk/Java/DATT/src/org/litesoft/datt/client/support/PriorityGroup.java

Diff revisions: vs.
  @@ -1,7 +1,6 @@
1 1 package org.litesoft.datt.client.support;
2 2
3 - public enum PriorityGroup
4 - {
3 + public enum PriorityGroup {
5 4 Initial( 0 ),
6 5 Low( 2000, 0, false ),
7 6 MediumLow( 4000, 2000 ),
  @@ -18,148 +17,119 @@
18 17 private float mRangeBottom;
19 18 private boolean mBottomInclusive;
20 19
21 - public PriorityGroup higherGroup()
22 - {
20 + public PriorityGroup higherGroup() {
23 21 return (Critical == this) ? this : values()[ordinal() + 1];
24 22 }
25 23
26 - public static PriorityGroup from( Float pValue )
27 - {
28 - if ( (pValue == null) || (pValue < BOTTOM_INCLUSIVE_VALUE) )
29 - {
24 + public static PriorityGroup from( Float pValue ) {
25 + if ( (pValue == null) || (pValue < BOTTOM_INCLUSIVE_VALUE) ) {
30 26 return Initial;
31 27 }
32 - for ( PriorityGroup zValue : values() )
33 - {
34 - if ( zValue.isInRange( pValue ) )
35 - {
28 + for ( PriorityGroup zValue : values() ) {
29 + if ( zValue.isInRange( pValue ) ) {
36 30 return zValue;
37 31 }
38 32 }
39 33 return Critical;
40 34 }
41 35
42 - PriorityGroup( float pRangeTop, boolean pTopInclusive, float pRangeBottom, boolean pBottomInclusive )
43 - {
36 + PriorityGroup( float pRangeTop, boolean pTopInclusive, float pRangeBottom, boolean pBottomInclusive ) {
44 37 mRangeTop = pRangeTop;
45 38 mTopInclusive = pTopInclusive;
46 39 mRangeBottom = pRangeBottom;
47 40 mBottomInclusive = pBottomInclusive;
48 41 }
49 42
50 - PriorityGroup( float pRangeTop, float pRangeBottom, boolean pBottomInclusive )
51 - {
43 + PriorityGroup( float pRangeTop, float pRangeBottom, boolean pBottomInclusive ) {
52 44 this( pRangeTop, false, pRangeBottom, pBottomInclusive );
53 45 }
54 46
55 - PriorityGroup( float pRangeTop, float pRangeBottom )
56 - {
47 + PriorityGroup( float pRangeTop, float pRangeBottom ) {
57 48 this( pRangeTop, pRangeBottom, true );
58 49 }
59 50
60 - PriorityGroup( float pRangeValue )
61 - {
51 + PriorityGroup( float pRangeValue ) {
62 52 this( pRangeValue, true, pRangeValue, true );
63 53 }
64 54
65 - public float getRangeTop()
66 - {
55 + public float getRangeTop() {
67 56 return mRangeTop;
68 57 }
69 58
70 - public boolean isTopInclusive()
71 - {
59 + public boolean isTopInclusive() {
72 60 return mTopInclusive;
73 61 }
74 62
75 - public float getRangeBottom()
76 - {
63 + public float getRangeBottom() {
77 64 return mRangeBottom;
78 65 }
79 66
80 - public boolean isBottomInclusive()
81 - {
67 + public boolean isBottomInclusive() {
82 68 return mBottomInclusive;
83 69 }
84 70
85 - public float getMidRange()
86 - {
71 + public float getMidRange() {
87 72 return (getRangeTop() + getRangeBottom()) / 2;
88 73 }
89 74
90 - public boolean isInRange( float pValue )
91 - {
75 + public boolean isInRange( float pValue ) {
92 76 return isNotTooSmall( pValue ) && isNotTooLarge( pValue );
93 77 }
94 78
95 - public Range getRangeAssumingExclusive()
96 - {
79 + public Range getRangeAssumingExclusive() {
97 80 return new Range( getRangeBottom(), getRangeTop() );
98 81 }
99 82
100 - public static PriorityGroup deNull( PriorityGroup pGroup, PriorityGroup pDefault )
101 - {
83 + public static PriorityGroup deNull( PriorityGroup pGroup, PriorityGroup pDefault ) {
102 84 return (pGroup != null) ? pGroup : pDefault;
103 85 }
104 86
105 87 /**
106 88 * @param pValues - are !null & are NOT to be decending in value between any two sequential pairs
107 89 */
108 - public static float[] rePrioritizeBetween( Float pBottomExclusive, Float pTopExclusive, Float... pValues )
109 - {
90 + public static float[] rePrioritizeBetween( Float pBottomExclusive, Float pTopExclusive, Float... pValues ) {
110 91 return new Range( pBottomExclusive, pTopExclusive ).update().rePrioritizeBetween( pValues );
111 92 }
112 93
113 - private boolean isNotTooLarge( float pValue )
114 - {
94 + private boolean isNotTooLarge( float pValue ) {
115 95 return mTopInclusive ? (pValue <= mRangeTop) : (pValue < mRangeTop);
116 96 }
117 97
118 - private boolean isNotTooSmall( float pValue )
119 - {
98 + private boolean isNotTooSmall( float pValue ) {
120 99 return mBottomInclusive ? (mRangeBottom <= pValue) : (mRangeBottom < pValue);
121 100 }
122 101
123 - public static class Range
124 - {
102 + public static class Range {
125 103 private float mBottomExclusive, mTopExclusive;
126 104
127 - public Range( Float pBottomExclusive, Float pTopExclusive )
128 - {
105 + public Range( Float pBottomExclusive, Float pTopExclusive ) {
129 106 mBottomExclusive = normalize( pBottomExclusive, BOTTOM_INCLUSIVE_VALUE );
130 107 mTopExclusive = normalize( pTopExclusive, TOP_EXCLUSIVE_VALUE );
131 108
132 - if ( mTopExclusive <= mBottomExclusive )
133 - {
109 + if ( mTopExclusive <= mBottomExclusive ) {
134 110 throw new IllegalArgumentException( "Bottom (" + mBottomExclusive + ") must be less than Top (" + mTopExclusive + ")" );
135 111 }
136 112 }
137 113
138 - private static float normalize( Float pValue, float pDefault )
139 - {
114 + private static float normalize( Float pValue, float pDefault ) {
140 115 return (pValue != null) && (BOTTOM_INCLUSIVE_VALUE <= pValue) && (pValue < TOP_EXCLUSIVE_VALUE) ? pValue : pDefault;
141 116 }
142 117
143 - public float getTopExclusive()
144 - {
118 + public float getTopExclusive() {
145 119 return mTopExclusive;
146 120 }
147 121
148 - public float getBottomExclusive()
149 - {
122 + public float getBottomExclusive() {
150 123 return mBottomExclusive;
151 124 }
152 125
153 - public Range update()
154 - {
126 + public Range update() {
155 127 PriorityGroup zGroup = from( mBottomExclusive );
156 - if ( mBottomExclusive == zGroup.getRangeTop() )
157 - {
128 + if ( mBottomExclusive == zGroup.getRangeTop() ) {
158 129 zGroup = zGroup.higherGroup();
159 130 mBottomExclusive = zGroup.getRangeBottom();
160 131 }
161 - if ( zGroup != from( mTopExclusive ) )
162 - {
132 + if ( zGroup != from( mTopExclusive ) ) {
163 133 mTopExclusive = zGroup.getRangeTop();
164 134 }
165 135 return this;
  @@ -168,14 +138,12 @@
168 138 /**
169 139 * @param pValues - are !null & are NOT to be decending in value between any two sequential pairs
170 140 */
171 - public float[] rePrioritizeBetween( Float... pValues )
172 - {
141 + public float[] rePrioritizeBetween( Float... pValues ) {
173 142 int zValuesLength = (pValues == null) ? 0 : pValues.length;
174 143 float[] rvs = new float[zValuesLength];
175 144 float zDelta = (mTopExclusive - mBottomExclusive) / (zValuesLength + 1);
176 145 float zRunningValue = mTopExclusive;
177 - for ( int i = 0; i < zValuesLength; i++ )
178 - {
146 + for ( int i = 0; i < zValuesLength; i++ ) {
179 147 rvs[i] = zRunningValue -= zDelta;
180 148 }
181 149 return rvs;

View View this file contents

History View the full history

Feeds

Commits for /trunk/Java/DATT/src/org/litesoft/datt/client/support/PriorityGroup.java

Need assistance?   Get in touch, or head to our documentation site.