Source code

001/**
002 * AbstractNumericPrimitive.java
003 * 
004 * Copyright (c) 2004-2012, Nicole C. Tedesco. All rights reserved.
005 * 
006 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
007 * use this file except in compliance with the License. You may obtain a copy of
008 * the License at:
009 * 
010 * http://www.apache.org/licenses/LICENSE-2.0
011 * 
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
014 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
015 * License for the specific language governing permissions and limitations under
016 * the License.
017 */
018
019package net.sf.jaccumulator.primitives;
020
021import java.math.BigDecimal;
022import java.math.BigInteger;
023import java.util.NoSuchElementException;
024
025import net.sf.jaccumulator.Domain;
026import net.sf.jaccumulator.StructureStrategy;
027import net.sf.jaccumulator.booleans.BooleanPrimitive;
028import net.sf.jaccumulator.bytes.BytePrimitive;
029import net.sf.jaccumulator.characters.CharacterPrimitive;
030import net.sf.jaccumulator.doubles.DoublePrimitive;
031import net.sf.jaccumulator.floats.FloatPrimitive;
032import net.sf.jaccumulator.integers.IntegerPrimitive;
033import net.sf.jaccumulator.lex.To;
034import net.sf.jaccumulator.longs.LongPrimitive;
035import net.sf.jaccumulator.reals.Real;
036import net.sf.jaccumulator.reals.SealedReal;
037import net.sf.jaccumulator.scalars.NumericPrecision;
038import net.sf.jaccumulator.scalars.Scalar;
039import net.sf.jaccumulator.scalars.SealedScalar;
040import net.sf.jaccumulator.shorts.ShortPrimitive;
041import net.sf.jaccumulator.texts.Text;
042import net.sf.jaccumulator.texts.TextPrimitive;
043import net.sf.jaccumulator.unlimiteds.UnlimitedDecimalPrimitive;
044import net.sf.jaccumulator.unlimiteds.UnlimitedIntegerPrimitive;
045
046/**
047 * Common read and write behavior for representations of {@link Domain#REAL
048 * real} number explicitly implemented either as a {@code boolean} vector into
049 * the real number domain, or any {@link BigDecimal unlimited} array
050 * 
051 * @param <PRIMITIVE>
052 *        this primitive type (used to facilitate operation chaining on write
053 *        operations)
054 * @since JAccumulator 4.0
055 * @author Nicole Tedesco (<a
056 *         href="mailto:Nicole@NicoleTedesco.com">Nicole@NicoleTedesco.com</a>)
057 */
058public abstract class AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
059    extends
060        AbstractPrimitive<PRIMITIVE>
061{
062    private static final long serialVersionUID = 6556054216961386143L;
063
064    public AbstractNumericPrimitive()
065    {
066        super();
067    }
068
069    public AbstractNumericPrimitive(
070        final Domain aDomain,
071        final NumericPrecision aPrecision )
072    {
073        super(aDomain, aPrecision);
074    }
075
076    public AbstractNumericPrimitive( final NumericPrecision aPrecision )
077    {
078        super(Domain.REAL, aPrecision);
079    }
080
081    @Override
082    public PRIMITIVE append( final boolean aValue )
083    {
084        return this.setText(this.toString() + aValue);
085    }
086
087    @Override
088    public PRIMITIVE append( final char c )
089    {
090        return this.setText(this.toString() + c);
091    }
092
093    @Override
094    public PRIMITIVE append( final char[] content )
095    {
096        return this.setText(this.toString() + new String(content));
097    }
098
099    @Override
100    public PRIMITIVE append( final char[] content, final int contentIndex )
101    {
102        return this.append(content, contentIndex, content.length - contentIndex);
103    }
104
105    @Override
106    public PRIMITIVE append(
107        final char[] content,
108        final int contentIndex,
109        final int contentLength )
110    {
111        return this.setText(this.toString()
112                + String.valueOf(content, contentIndex, contentLength));
113    }
114
115    @Override
116    public PRIMITIVE append( final CharSequence s )
117    {
118        return this.setText(this.toString() + s);
119    }
120
121    @Override
122    public PRIMITIVE append( final CharSequence s, final int start )
123    {
124        return this.append(s, start, s.length());
125    }
126
127    @Override
128    public PRIMITIVE append(
129        final CharSequence s,
130        final int start,
131        final int end )
132    {
133        return this.setText(this.toString() + s.subSequence(start, end));
134    }
135
136    @Override
137    public PRIMITIVE append( final double aValue )
138    {
139        return this.setText(this.toString() + aValue);
140    }
141
142    @Override
143    public PRIMITIVE append( final float aValue )
144    {
145        return this.setText(this.toString() + aValue);
146    }
147
148    @Override
149    public PRIMITIVE append( final int aValue )
150    {
151        return this.setText(this.toString() + aValue);
152    }
153
154    @Override
155    public PRIMITIVE append( final long aValue )
156    {
157        return this.setText(this.toString() + aValue);
158    }
159
160    @Override
161    public PRIMITIVE append( final Object aValue )
162    {
163        return this.setText(this.toString() + aValue.toString());
164    }
165
166    @Override
167    public PRIMITIVE append( final StringBuffer sb )
168    {
169        return this.setText(this.toString() + sb);
170    }
171
172    @Override
173    public PRIMITIVE appendCodePoint( final int codePoint )
174    {
175        return this.setText(this.toString()
176                + String.copyValueOf(Character.toChars(codePoint)));
177    }
178
179    @Override
180    public char charAt( final int index )
181    {
182        return this.toString().charAt(index);
183    }
184
185    @Override
186    public void clear()
187    {
188        this.setZero();
189    }
190
191    @Override
192    public PRIMITIVE clearContents() throws UnsupportedOperationException
193    {
194        return this.setZero();
195    }
196
197    @Override
198    public PRIMITIVE clearText() throws UnsupportedOperationException
199    {
200        return this.setZero();
201    }
202
203    @Override
204    public int codePointAt( final int index )
205    {
206        return this.toString().codePointAt(index);
207    }
208
209    @Override
210    public int codePointBefore( final int index )
211    {
212        return this.toString().codePointBefore(index);
213    }
214
215    @Override
216    public int codePointCount( final int beginIndex, final int endIndex )
217    {
218        return this.toString().codePointCount(beginIndex, endIndex);
219    }
220
221    @Override
222    public final int compareTo( final SealedPrimitive<?> aComparable )
223    {
224        return this.compareToReal(aComparable);
225    }
226
227    @Override
228    public final int compareToPrimitive( final SealedPrimitive<?> aComparable )
229    {
230        return this.compareToReal(aComparable);
231    }
232
233    @Override
234    public PRIMITIVE copyUsingText( final CharSequence aValue )
235    {
236        final PRIMITIVE aModel = this.copy();
237        To.REAL.reactToText(aValue, aModel);
238        return aModel;
239    }
240
241    @Override
242    public PRIMITIVE delete( final int start, final int end )
243    {
244        final String myString = this.toString();
245        return this.setText(myString.substring(0, start)
246                + myString.substring(end));
247    }
248
249    @Override
250    public PRIMITIVE deleteCharAt( final int anIndex )
251    {
252        final StringBuilder sb = new StringBuilder(this.toString());
253        sb.deleteCharAt(anIndex);
254        return this.setText(sb.toString());
255    }
256
257    @Override
258    public boolean equals( final Object anObject )
259    {
260        if (anObject == this) return true;
261        if (anObject instanceof SealedPrimitive<?>) {
262            final SealedPrimitive<?> aPrimitive = (SealedPrimitive<?>)anObject;
263            return this.isEqualToPrimitive(aPrimitive);
264        }
265        if (anObject instanceof SealedReal<?>) {
266            final SealedReal<?> aReal = (SealedReal<?>)anObject;
267            return this.isEqualToReal(aReal);
268        }
269        if (anObject instanceof SealedScalar<?>) {
270            final SealedScalar<?> aScalar = (SealedScalar<?>)anObject;
271            return this.isEqualToScalar(aScalar);
272        }
273        return this.isEqualToText(anObject.toString());
274    }
275
276    @Override
277    public StructureStrategy getStructureStrategy()
278    {
279        return StructureStrategy.BITS;
280    }
281
282    @Override
283    public int indexOfText( final CharSequence str )
284    {
285        return this.toString().indexOf(str.toString());
286    }
287
288    @Override
289    public int indexOfText( final CharSequence str, final int beginIndex )
290    {
291        return this.toString().indexOf(str.toString(), beginIndex);
292    }
293
294    @Override
295    public <P extends Primitive<?>> P inducePostDecrement( final P aTarget )
296        throws NullPointerException,
297            NoSuchElementException,
298            UnsupportedOperationException,
299            IllegalStateException
300    {
301        this.inducePostDecrement((Real<?>)aTarget);
302        return aTarget;
303    }
304
305    @Override
306    public <R extends Real<?>> R inducePostDecrement( final R aTarget )
307        throws NullPointerException,
308            NoSuchElementException,
309            UnsupportedOperationException,
310            IllegalStateException
311    {
312        this.inducePostDecrement((Scalar<?>)aTarget);
313        return aTarget;
314    }
315
316    @Override
317    public <P extends Primitive<?>> P inducePostIncrement( final P aTarget )
318        throws NullPointerException,
319            NoSuchElementException,
320            UnsupportedOperationException,
321            IllegalStateException
322    {
323        this.inducePostIncrement((Real<?>)aTarget);
324        return aTarget;
325    }
326
327    @Override
328    public <R extends Real<?>> R inducePostIncrement( final R aTarget )
329        throws NullPointerException,
330            NoSuchElementException,
331            UnsupportedOperationException,
332            IllegalStateException
333    {
334        this.inducePostIncrement((Scalar<?>)aTarget);
335        return aTarget;
336    }
337
338    @Override
339    public <P extends Primitive<?>> P inducePrimitiveValue( final P aTarget )
340        throws NullPointerException,
341            NoSuchElementException,
342            UnsupportedOperationException,
343            IllegalStateException
344    {
345        this.induceRealValue(aTarget);
346        return aTarget;
347    }
348
349    @Override
350    public <TEXT extends Text<?>> TEXT induceTextValue( final TEXT aTarget )
351        throws NullPointerException,
352            NoSuchElementException,
353            UnsupportedOperationException,
354            IllegalStateException
355    {
356        aTarget.setText(this.toString());
357        return aTarget;
358    }
359
360    @Override
361    public PRIMITIVE insert( final int anIndex, final boolean aValue )
362    {
363        final String myString = this.toString();
364        return this.setText(myString.substring(0, anIndex)
365                + String.valueOf(aValue) + myString.substring(anIndex));
366    }
367
368    @Override
369    public PRIMITIVE insert( final int anIndex, final char aValue )
370    {
371        final String myString = this.toString();
372        return this.setText(myString.substring(0, anIndex)
373                + String.valueOf(aValue) + myString.substring(anIndex));
374    }
375
376    @Override
377    public PRIMITIVE insert( final int anIndex, final char[] content )
378    {
379        final String myString = this.toString();
380        return this.setText(myString.substring(0, anIndex)
381                + String.copyValueOf(content) + myString.substring(anIndex));
382    }
383
384    @Override
385    public PRIMITIVE insert(
386        final int targetIndex,
387        final char[] content,
388        final int contentIndex,
389        final int contentLength )
390    {
391        final String myString = this.toString();
392        return this.setText(myString.substring(0, contentIndex)
393                + String.copyValueOf(content, contentIndex, contentLength)
394                + myString.substring(contentIndex));
395    }
396
397    @Override
398    public PRIMITIVE insert( final int anIndex, final CharSequence content )
399    {
400        final String myString = this.toString();
401        return this.setText(myString.substring(0, anIndex) + content
402                + myString.substring(anIndex));
403    }
404
405    @Override
406    public PRIMITIVE insert(
407        final int targetIndex,
408        final CharSequence content,
409        final int contentIndex )
410    {
411        return this.insert(targetIndex, content, contentIndex, content.length());
412    }
413
414    @Override
415    public PRIMITIVE insert(
416        final int targetIndex,
417        final CharSequence content,
418        final int contentStartIndex,
419        final int contentEndIndexPlusOne )
420    {
421        final String myString = this.toString();
422        return this.setText(myString.substring(0, targetIndex)
423                + content.subSequence(contentStartIndex, contentEndIndexPlusOne)
424                + myString.substring(targetIndex));
425    }
426
427    @Override
428    public PRIMITIVE insert( final int anIndex, final double aValue )
429    {
430        final String myString = this.toString();
431        return this.setText(myString.substring(0, anIndex)
432                + String.valueOf(aValue) + myString.substring(anIndex));
433    }
434
435    @Override
436    public PRIMITIVE insert( final int anIndex, final float aValue )
437    {
438        final String myString = this.toString();
439        return this.setText(myString.substring(0, anIndex)
440                + String.valueOf(aValue) + myString.substring(anIndex));
441    }
442
443    @Override
444    public PRIMITIVE insert( final int anIndex, final int aValue )
445    {
446        final String myString = this.toString();
447        return this.setText(myString.substring(0, anIndex)
448                + String.valueOf(aValue) + myString.substring(anIndex));
449    }
450
451    @Override
452    public PRIMITIVE insert( final int anIndex, final long aValue )
453    {
454        final String myString = this.toString();
455        return this.setText(myString.substring(0, anIndex)
456                + String.valueOf(aValue) + myString.substring(anIndex));
457    }
458
459    @Override
460    public PRIMITIVE insert( final int anIndex, final Object aValue )
461    {
462        final String myString = this.toString();
463        return this.setText(myString.substring(0, anIndex)
464                + String.valueOf(aValue) + myString.substring(anIndex));
465    }
466
467    @Override
468    public boolean isEmpty()
469    {
470        return false;
471    }
472
473    @Override
474    public final boolean isEqualToPrimitive( final SealedPrimitive<?> aValue )
475    {
476        final NumericPrecision myPrecision = this.getPrecision();
477        final NumericPrecision aPrecision = aValue.getPrecision();
478        final NumericPrecision prec = myPrecision.maximumOf(aPrecision);
479        switch (prec) {
480        case NULL:
481            return this.isZero();
482        case BIT:
483            return this.isEqual(aValue.booleanValue());
484        case BYTE:
485            return this.isEqual(aValue.byteValue());
486        case SHORT:
487            return this.isEqual(aValue.shortValue());
488        case CHARACTER:
489            return this.isEqual(aValue.charValue());
490        case INTEGER:
491            return this.isEqual(aValue.intValue());
492        case LONG:
493            return this.isEqual(aValue.longValue());
494        case FLOAT:
495            return this.isEqual(aValue.floatValue());
496        case DOUBLE:
497            return this.isEqual(aValue.doubleValue());
498        case UNLIMITED_INTEGER:
499            return this.isEqual(aValue.toUnlimitedInteger());
500        case UNLIMITED_DECIMAL:
501            return this.isEqual(aValue.toUnlimitedDecimal());
502        }
503        return this.isEqualToText(aValue);
504    }
505
506    @Override
507    public final boolean isEqualToText( final CharSequence aValue )
508    {
509        return this.toString().equals(aValue.toString());
510    }
511
512    @Override
513    public final boolean isGreaterOrEqualToPrimitive(
514        final SealedPrimitive<?> aValue )
515    {
516        final NumericPrecision myPrecision = this.getPrecision();
517        final NumericPrecision aPrecision = aValue.getPrecision();
518        final NumericPrecision prec = myPrecision.maximumOf(aPrecision);
519        switch (prec) {
520        case NULL:
521            return !this.isNegative();
522        case BIT:
523            return this.isGreaterOrEqual(aValue.booleanValue());
524        case BYTE:
525            return this.isGreaterOrEqual(aValue.byteValue());
526        case SHORT:
527            return this.isGreaterOrEqual(aValue.shortValue());
528        case CHARACTER:
529            return this.isGreaterOrEqual(aValue.charValue());
530        case INTEGER:
531            return this.isGreaterOrEqual(aValue.intValue());
532        case LONG:
533            return this.isGreaterOrEqual(aValue.longValue());
534        case FLOAT:
535            return this.isGreaterOrEqual(aValue.floatValue());
536        case DOUBLE:
537            return this.isGreaterOrEqual(aValue.doubleValue());
538        case UNLIMITED_INTEGER:
539            return this.isGreaterOrEqual(aValue.toUnlimitedInteger());
540        case UNLIMITED_DECIMAL:
541            return this.isGreaterOrEqual(aValue.toUnlimitedDecimal());
542        }
543        return this.isGreaterOrEqualToText(aValue);
544    }
545
546    @Override
547    public final boolean isGreaterOrEqualToText( final CharSequence aValue )
548    {
549        return 0 <= this.toString().compareTo(aValue.toString());
550    }
551
552    @Override
553    public final boolean isGreaterThanPrimitive( final SealedPrimitive<?> aValue )
554    {
555        final NumericPrecision myPrecision = this.getPrecision();
556        final NumericPrecision aPrecision = aValue.getPrecision();
557        final NumericPrecision prec = myPrecision.maximumOf(aPrecision);
558        switch (prec) {
559        case NULL:
560            return this.isPositive();
561        case BIT:
562            return this.isGreater(aValue.booleanValue());
563        case BYTE:
564            return this.isGreater(aValue.byteValue());
565        case SHORT:
566            return this.isGreater(aValue.shortValue());
567        case CHARACTER:
568            return this.isGreater(aValue.charValue());
569        case INTEGER:
570            return this.isGreater(aValue.intValue());
571        case LONG:
572            return this.isGreater(aValue.longValue());
573        case FLOAT:
574            return this.isGreater(aValue.floatValue());
575        case DOUBLE:
576            return this.isGreater(aValue.doubleValue());
577        case UNLIMITED_INTEGER:
578            return this.isGreater(aValue.toUnlimitedInteger());
579        case UNLIMITED_DECIMAL:
580            return this.isGreater(aValue.toUnlimitedDecimal());
581        }
582        return this.isGreaterThanText(aValue);
583    }
584
585    @Override
586    public final boolean isGreaterThanText( final CharSequence aValue )
587    {
588        return 0 < this.toString().compareTo(aValue.toString());
589    }
590
591    @Override
592    public final boolean isLessOrEqualToPrimitive(
593        final SealedPrimitive<?> aValue )
594    {
595        final NumericPrecision myPrecision = this.getPrecision();
596        final NumericPrecision aPrecision = aValue.getPrecision();
597        final NumericPrecision prec = myPrecision.maximumOf(aPrecision);
598        switch (prec) {
599        case NULL:
600            return !this.isPositive();
601        case BIT:
602            return this.isLessOrEqual(aValue.booleanValue());
603        case BYTE:
604            return this.isLessOrEqual(aValue.byteValue());
605        case SHORT:
606            return this.isLessOrEqual(aValue.shortValue());
607        case CHARACTER:
608            return this.isLessOrEqual(aValue.charValue());
609        case INTEGER:
610            return this.isLessOrEqual(aValue.intValue());
611        case LONG:
612            return this.isLessOrEqual(aValue.longValue());
613        case FLOAT:
614            return this.isLessOrEqual(aValue.floatValue());
615        case DOUBLE:
616            return this.isLessOrEqual(aValue.doubleValue());
617        case UNLIMITED_INTEGER:
618            return this.isLessOrEqual(aValue.toUnlimitedInteger());
619        case UNLIMITED_DECIMAL:
620            return this.isLessOrEqual(aValue.toUnlimitedDecimal());
621        }
622        return this.isLessOrEqualToText(aValue);
623    }
624
625    @Override
626    public final boolean isLessOrEqualToText( final CharSequence aValue )
627    {
628        return this.toString().compareTo(aValue.toString()) <= 0;
629    }
630
631    @Override
632    public final boolean isLessThanPrimitive( final SealedPrimitive<?> aValue )
633    {
634        final NumericPrecision myPrecision = this.getPrecision();
635        final NumericPrecision aPrecision = aValue.getPrecision();
636        final NumericPrecision prec = myPrecision.maximumOf(aPrecision);
637        switch (prec) {
638        case NULL:
639            return this.isNegative();
640        case BIT:
641            return this.isLess(aValue.booleanValue());
642        case BYTE:
643            return this.isLess(aValue.byteValue());
644        case SHORT:
645            return this.isLess(aValue.shortValue());
646        case CHARACTER:
647            return this.isLess(aValue.charValue());
648        case INTEGER:
649            return this.isLess(aValue.intValue());
650        case LONG:
651            return this.isLess(aValue.longValue());
652        case FLOAT:
653            return this.isLess(aValue.floatValue());
654        case DOUBLE:
655            return this.isLess(aValue.doubleValue());
656        case UNLIMITED_INTEGER:
657            return this.isLess(aValue.toUnlimitedInteger());
658        case UNLIMITED_DECIMAL:
659            return this.isLess(aValue.toUnlimitedDecimal());
660        }
661        return this.isLessThanText(aValue);
662    }
663
664    @Override
665    public final boolean isLessThanText( final CharSequence aValue )
666    {
667        return this.toString().compareTo(aValue.toString()) < 0;
668    }
669
670    @Override
671    public final boolean isNotEqualToPrimitive( final SealedPrimitive<?> aValue )
672    {
673        final NumericPrecision myPrecision = this.getPrecision();
674        final NumericPrecision aPrecision = aValue.getPrecision();
675        final NumericPrecision prec = myPrecision.maximumOf(aPrecision);
676        switch (prec) {
677        case NULL:
678            return !this.isZero();
679        case BIT:
680            return this.isNotEqual(aValue.booleanValue());
681        case BYTE:
682            return this.isNotEqual(aValue.byteValue());
683        case SHORT:
684            return this.isNotEqual(aValue.shortValue());
685        case CHARACTER:
686            return this.isNotEqual(aValue.charValue());
687        case INTEGER:
688            return this.isNotEqual(aValue.intValue());
689        case LONG:
690            return this.isNotEqual(aValue.longValue());
691        case FLOAT:
692            return this.isNotEqual(aValue.floatValue());
693        case DOUBLE:
694            return this.isNotEqual(aValue.doubleValue());
695        case UNLIMITED_INTEGER:
696            return this.isNotEqual(aValue.toUnlimitedInteger());
697        case UNLIMITED_DECIMAL:
698            return this.isNotEqual(aValue.toUnlimitedDecimal());
699        }
700        return this.isNotEqualToText(aValue);
701    }
702
703    @Override
704    public final boolean isNotEqualToText( final CharSequence aValue )
705    {
706        return this.toString().compareTo(aValue.toString()) != 0;
707    }
708
709    @Override
710    public boolean isText()
711    {
712        return false;
713    }
714
715    @Override
716    public int length()
717    {
718        return this.toString().length();
719    }
720
721    @Override
722    public PRIMITIVE lowerCase()
723    {
724        return this.setScalar(Character.toLowerCase(this.intValue()));
725    }
726
727    @Override
728    public final PRIMITIVE prepend( final boolean aValue )
729    {
730        return this.setText(String.valueOf(aValue) + this.toString());
731    }
732
733    @Override
734    public final PRIMITIVE prepend( final char c )
735    {
736        return this.setText(String.valueOf(c) + this.toString());
737    }
738
739    @Override
740    public final PRIMITIVE prepend( final char[] content )
741    {
742        return this.setText(new String(content) + this.toString());
743    }
744
745    @Override
746    public final PRIMITIVE prepend( final char[] content, final int contentIndex )
747    {
748        return this.prepend(content, contentIndex, content.length
749                - contentIndex);
750    }
751
752    @Override
753    public final PRIMITIVE prepend(
754        final char[] content,
755        final int contentIndex,
756        final int contentLength )
757    {
758        return this.setText(this.toString()
759                + String.valueOf(content, contentIndex, contentLength));
760    }
761
762    @Override
763    public final PRIMITIVE prepend( final CharSequence s )
764    {
765        return this.setText(s.toString() + this.toString());
766    }
767
768    @Override
769    public final PRIMITIVE prepend( final CharSequence s, final int start )
770    {
771        return this.prepend(s, start, s.length());
772    }
773
774    @Override
775    public final PRIMITIVE prepend(
776        final CharSequence s,
777        final int start,
778        final int end )
779    {
780        return this.setText(this.toString() + s.subSequence(start, end));
781    }
782
783    @Override
784    public final PRIMITIVE prepend( final double aValue )
785    {
786        return this.setText(String.valueOf(aValue) + this.toString());
787    }
788
789    @Override
790    public final PRIMITIVE prepend( final float aValue )
791    {
792        return this.setText(String.valueOf(aValue) + this.toString());
793    }
794
795    @Override
796    public final PRIMITIVE prepend( final int aValue )
797    {
798        return this.setText(String.valueOf(aValue) + this.toString());
799    }
800
801    @Override
802    public final PRIMITIVE prepend( final long aValue )
803    {
804        return this.setText(String.valueOf(aValue) + this.toString());
805    }
806
807    @Override
808    public final PRIMITIVE prepend( final Object aValue )
809    {
810        return this.setText(aValue.toString() + this.toString());
811    }
812
813    @Override
814    public PRIMITIVE replace(
815        final CharSequence target,
816        final CharSequence replacement )
817    {
818        final String myString = this.toString();
819        return this.setText(myString.replace(target, replacement));
820    }
821
822    @Override
823    public PRIMITIVE replace( final int start, final int end, final String str )
824    {
825        final String myString = this.toString();
826        return this.setText(myString.substring(0, start) + str
827                + myString.substring(end + 1));
828    }
829
830    @Override
831    public PRIMITIVE replaceAll( final String regex, final String replacement )
832    {
833        final String myString = this.toString();
834        return this.setText(myString.replaceAll(regex, replacement));
835    }
836
837    @Override
838    public PRIMITIVE replaceCharacter( final char oldChar, final char newChar )
839    {
840        final String myString = this.toString();
841        return this.setText(myString.replace(oldChar, newChar));
842    }
843
844    @Override
845    public PRIMITIVE replaceFirst( final String regex, final String replacement )
846    {
847        final String myString = this.toString();
848        return this.setText(myString.replaceFirst(regex, replacement));
849    }
850
851    @Override
852    public PRIMITIVE reverse()
853    {
854        final StringBuilder content = new StringBuilder(this.toString());
855        content.reverse();
856        return this.setText(content);
857    }
858
859    @Override
860    public final PRIMITIVE setBoolean( final Boolean aValue )
861        throws UnsupportedOperationException,
862            IllegalArgumentException,
863            ArithmeticException,
864            NullPointerException
865    {
866        return this.setScalar(aValue.booleanValue());
867    }
868
869    @Override
870    public final PRIMITIVE setCharacter( final Character aValue )
871        throws UnsupportedOperationException,
872            IllegalArgumentException,
873            ArithmeticException,
874            NullPointerException
875    {
876        return this.setScalar(aValue.charValue());
877    }
878
879    @Override
880    public PRIMITIVE setCharAt( final int index, final char ch )
881    {
882        final String myString = this.toString();
883        final StringBuilder sb = new StringBuilder(myString);
884        sb.setCharAt(index, ch);
885        return this.setText(sb.toString());
886    }
887
888    @Override
889    public PRIMITIVE setLength( final int newLength )
890    {
891        final String myText = this.toString();
892        final int myLength = myText.length();
893        if (myLength < 1) return this.clearText();
894        return this.setText(myText.subSequence(0, myLength - 1));
895    }
896
897    @Override
898    public PRIMITIVE setNumber( final Number aValue )
899        throws UnsupportedOperationException,
900            IllegalArgumentException,
901            ArithmeticException,
902            NullPointerException
903    {
904        final NumericPrecision myPrecision = this.getPrecision();
905        final NumericPrecision aPrecision = NumericPrecision.getPrecisionFor(aValue);
906        final NumericPrecision prec = myPrecision.maximumOf(aPrecision);
907        switch (prec) {
908        case BIT:
909        case BYTE:
910            return this.setScalar(aValue.byteValue());
911        case SHORT:
912            return this.setScalar(aValue.shortValue());
913        case CHARACTER:
914        case INTEGER:
915            return this.setScalar(aValue.intValue());
916        case LONG:
917            return this.setScalar(aValue.longValue());
918        case FLOAT:
919            return this.setScalar(aValue.floatValue());
920        case UNLIMITED_DECIMAL:
921            try {
922                final BigDecimal ud = (BigDecimal)aValue;
923                return this.setReal(ud);
924            } catch (final ClassCastException ex) {
925            }
926            break;
927        case UNLIMITED_INTEGER:
928            try {
929                final BigInteger ui = (BigInteger)aValue;
930                return this.setReal(ui);
931            } catch (final ClassCastException ex) {
932            }
933            break;
934        }
935        return this.setScalar(aValue.doubleValue());
936    }
937
938    @Override
939    public PRIMITIVE setPrimitive( final SealedPrimitive<?> aValue )
940        throws UnsupportedOperationException,
941            IllegalArgumentException,
942            ArithmeticException,
943            NullPointerException
944    {
945        final NumericPrecision myPrecision = this.getPrecision();
946        final NumericPrecision aPrecision = NumericPrecision.getPrecisionFor(aValue);
947        final NumericPrecision prec = myPrecision.maximumOf(aPrecision);
948        switch (prec) {
949        case NULL:
950            return this.setZero();
951        case BIT:
952            return this.setScalar(aValue.booleanValue());
953        case BYTE:
954            return this.setScalar(aValue.byteValue());
955        case SHORT:
956            return this.setScalar(aValue.shortValue());
957        case CHARACTER:
958            return this.setScalar(aValue.charValue());
959        case INTEGER:
960            return this.setScalar(aValue.intValue());
961        case LONG:
962            return this.setScalar(aValue.longValue());
963        case FLOAT:
964            return this.setScalar(aValue.floatValue());
965        case UNLIMITED_DECIMAL:
966            return this.setReal(aValue.toUnlimitedDecimal());
967        case UNLIMITED_INTEGER:
968            return this.setReal(aValue.toUnlimitedInteger());
969        }
970        return this.setScalar(aValue.doubleValue());
971    }
972
973    @Override
974    public PRIMITIVE setReal( final SealedReal<?> aValue )
975        throws UnsupportedOperationException,
976            IllegalArgumentException,
977            ArithmeticException,
978            NullPointerException
979    {
980        final NumericPrecision myPrecision = this.getPrecision();
981        final NumericPrecision aPrecision = NumericPrecision.getPrecisionFor(aValue);
982        final NumericPrecision prec = myPrecision.maximumOf(aPrecision);
983        switch (prec) {
984        case NULL:
985            return this.setZero();
986        case BIT:
987            return this.setScalar(aValue.booleanValue());
988        case BYTE:
989            return this.setScalar(aValue.byteValue());
990        case SHORT:
991            return this.setScalar(aValue.shortValue());
992        case CHARACTER:
993            return this.setScalar(aValue.charValue());
994        case INTEGER:
995            return this.setScalar(aValue.intValue());
996        case LONG:
997            return this.setScalar(aValue.longValue());
998        case FLOAT:
999            return this.setScalar(aValue.floatValue());
1000        case UNLIMITED_DECIMAL:
1001            return this.setReal(aValue.toUnlimitedDecimal());
1002        case UNLIMITED_INTEGER:
1003            return this.setReal(aValue.toUnlimitedInteger());
1004        }
1005        return this.setScalar(aValue.doubleValue());
1006    }
1007
1008    @Override
1009    @SuppressWarnings( "unchecked" )
1010    public PRIMITIVE setText( final CharSequence content )
1011        throws UnsupportedOperationException,
1012            NullPointerException,
1013            IllegalArgumentException
1014    {
1015        To.REAL.reactToText(content, this);
1016        return (PRIMITIVE)this;
1017    }
1018
1019    @Override
1020    public CharSequence subSequence( final int start, final int end )
1021    {
1022        return this.toString().subSequence(start, end);
1023    }
1024
1025    @Override
1026    public String substring( final int start )
1027    {
1028        return this.toString().substring(start);
1029    }
1030
1031    @Override
1032    public String substring( final int start, final int end )
1033    {
1034        return this.toString().substring(start, end);
1035    }
1036
1037    @Override
1038    public String textPostDecrement()
1039        throws UnsupportedOperationException,
1040            ArithmeticException,
1041            IllegalArgumentException
1042    {
1043        final String myValue = this.toString();
1044        this.decrement();
1045        return myValue;
1046    }
1047
1048    @Override
1049    public String textPostIncrement()
1050        throws UnsupportedOperationException,
1051            ArithmeticException,
1052            IllegalArgumentException
1053    {
1054        final String myValue = this.toString();
1055        this.increment();
1056        return myValue;
1057    }
1058
1059    @Override
1060    public PRIMITIVE titleCase()
1061    {
1062        return this.setScalar(Character.toTitleCase(this.intValue()));
1063    }
1064
1065    @Override
1066    @SuppressWarnings( "unchecked" )
1067    public PRIMITIVE trim()
1068    {
1069        return (PRIMITIVE)this;
1070    }
1071
1072    @Override
1073    public PRIMITIVE upperCase()
1074    {
1075        return this.setScalar(Character.toUpperCase(this.intValue()));
1076    }
1077
1078    public final static Primitive<?> toPrimitive( final SealedReal<?> aReal )
1079    {
1080        switch (aReal.getPrecision()) {
1081        case NULL:
1082            return Constant.NULL;
1083        case UNKNOWN:
1084            return new TextPrimitive(aReal.toString());
1085        case BIT:
1086            return new BooleanPrimitive(aReal.booleanValue());
1087        case BYTE:
1088            return new BytePrimitive(aReal.byteValue());
1089        case CHARACTER:
1090            return new CharacterPrimitive(aReal.charValue());
1091        case SHORT:
1092            return new ShortPrimitive(aReal.shortValue());
1093        case INTEGER:
1094            return new IntegerPrimitive(aReal.intValue());
1095        case LONG:
1096            return new LongPrimitive(aReal.longValue());
1097        case FLOAT:
1098            return new FloatPrimitive(aReal.floatValue());
1099        case UNLIMITED_INTEGER:
1100            return new UnlimitedIntegerPrimitive(aReal.toUnlimitedInteger());
1101        case UNLIMITED_DECIMAL:
1102            return new UnlimitedDecimalPrimitive(aReal.toUnlimitedDecimal());
1103        }
1104        return new DoublePrimitive(aReal.doubleValue());
1105    }
1106
1107    public final static Primitive<?> toPrimitive( final SealedScalar<?> aScalar )
1108    {
1109        switch (aScalar.getPrecision()) {
1110        case NULL:
1111            return Constant.NULL;
1112        case UNKNOWN:
1113            return new TextPrimitive(aScalar.toString());
1114        case BIT:
1115            return new BooleanPrimitive(aScalar.booleanValue());
1116        case BYTE:
1117            return new BytePrimitive(aScalar.byteValue());
1118        case CHARACTER:
1119            return new CharacterPrimitive(aScalar.charValue());
1120        case SHORT:
1121            return new ShortPrimitive(aScalar.shortValue());
1122        case INTEGER:
1123            return new IntegerPrimitive(aScalar.intValue());
1124        case LONG:
1125            return new LongPrimitive(aScalar.longValue());
1126        case FLOAT:
1127            return new FloatPrimitive(aScalar.floatValue());
1128        }
1129        return new DoublePrimitive(aScalar.doubleValue());
1130    }
1131}