Source code

001/**
002 * AbstractPrimitiveWrapper.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.ConcurrencyStrategy;
026import net.sf.jaccumulator.Domain;
027import net.sf.jaccumulator.StructureStrategy;
028import net.sf.jaccumulator.reals.Real;
029import net.sf.jaccumulator.scalars.NumericPrecision;
030import net.sf.jaccumulator.scalars.RoundingStrategy;
031import net.sf.jaccumulator.scalars.Scalar;
032import net.sf.jaccumulator.scalars.SealedScalar;
033import net.sf.jaccumulator.texts.Text;
034
035/**
036 * An abstract {@link Primitive primitive} wrapper, ready to be overridden and
037 * missing only the protected {@link #getTarget()} and the explicit
038 * {@link #copy() copy} functions
039 * 
040 * @param <PRIMITIVE>
041 *        this primitive type (used to facilitate operation chaining on write
042 *        operations)
043 * @since JCXell 1.0
044 * @author Nicole Tedesco (<a
045 *         href="mailto:Nicole@NicoleTedesco.com">Nicole@NicoleTedesco.com</a>)
046 */
047public abstract class AbstractPrimitiveWrapper<PRIMITIVE extends Primitive<PRIMITIVE>>
048    extends
049        AbstractPrimitive<PRIMITIVE>
050    implements
051        Primitive<PRIMITIVE>
052{
053    private static final long serialVersionUID = -7056832351567652246L;
054
055    public AbstractPrimitiveWrapper()
056    {
057    }
058
059    protected abstract Primitive<?> getTarget();
060
061    @Override
062    @SuppressWarnings( "unchecked" )
063    public PRIMITIVE absoluteValue() throws UnsupportedOperationException
064    {
065        this.getTarget().absoluteValue();
066        return (PRIMITIVE)this;
067    }
068
069    @Override
070    @SuppressWarnings( "unchecked" )
071    public PRIMITIVE and( final BigInteger aValue )
072        throws UnsupportedOperationException,
073            IllegalArgumentException,
074            ArithmeticException
075    {
076        this.getTarget().and(aValue);
077        return (PRIMITIVE)this;
078    }
079
080    @Override
081    @SuppressWarnings( "unchecked" )
082    public PRIMITIVE and( final boolean aValue )
083        throws UnsupportedOperationException,
084            IllegalArgumentException,
085            ArithmeticException
086    {
087        this.getTarget().and(aValue);
088        return (PRIMITIVE)this;
089    }
090
091    @Override
092    @SuppressWarnings( "unchecked" )
093    public PRIMITIVE and( final byte aValue )
094        throws UnsupportedOperationException,
095            IllegalArgumentException,
096            ArithmeticException
097    {
098        this.getTarget().and(aValue);
099        return (PRIMITIVE)this;
100    }
101
102    @Override
103    @SuppressWarnings( "unchecked" )
104    public PRIMITIVE and( final char aValue )
105        throws UnsupportedOperationException,
106            IllegalArgumentException,
107            ArithmeticException
108    {
109        this.getTarget().and(aValue);
110        return (PRIMITIVE)this;
111    }
112
113    @Override
114    @SuppressWarnings( "unchecked" )
115    public PRIMITIVE and( final int aValue )
116        throws UnsupportedOperationException,
117            IllegalArgumentException,
118            ArithmeticException
119    {
120        this.getTarget().and(aValue);
121        return (PRIMITIVE)this;
122    }
123
124    @Override
125    @SuppressWarnings( "unchecked" )
126    public PRIMITIVE and( final long aValue )
127        throws UnsupportedOperationException,
128            IllegalArgumentException,
129            ArithmeticException
130    {
131        this.getTarget().and(aValue);
132        return (PRIMITIVE)this;
133    }
134
135    @Override
136    @SuppressWarnings( "unchecked" )
137    public PRIMITIVE and( final short aValue )
138        throws UnsupportedOperationException,
139            IllegalArgumentException,
140            ArithmeticException
141    {
142        this.getTarget().and(aValue);
143        return (PRIMITIVE)this;
144    }
145
146    @Override
147    @SuppressWarnings( "unchecked" )
148    public PRIMITIVE angleWith( final double aValue )
149        throws UnsupportedOperationException,
150            IllegalArgumentException,
151            ArithmeticException
152    {
153        this.getTarget().angleWith(aValue);
154        return (PRIMITIVE)this;
155    }
156
157    @Override
158    @SuppressWarnings( "unchecked" )
159    public PRIMITIVE append( final boolean aValue )
160        throws UnsupportedOperationException
161    {
162        this.getTarget().append(aValue);
163        return (PRIMITIVE)this;
164    }
165
166    @Override
167    @SuppressWarnings( "unchecked" )
168    public PRIMITIVE append( final char c )
169        throws UnsupportedOperationException
170    {
171        this.getTarget().append(c);
172        return (PRIMITIVE)this;
173    }
174
175    @Override
176    @SuppressWarnings( "unchecked" )
177    public PRIMITIVE append( final char[] content )
178        throws UnsupportedOperationException
179    {
180        this.getTarget().append(content);
181        return (PRIMITIVE)this;
182    }
183
184    @Override
185    @SuppressWarnings( "unchecked" )
186    public PRIMITIVE append( final char[] content, final int contentIndex )
187        throws UnsupportedOperationException
188    {
189        this.getTarget().append(content, contentIndex);
190        return (PRIMITIVE)this;
191    }
192
193    @Override
194    @SuppressWarnings( "unchecked" )
195    public PRIMITIVE append(
196        final char[] content,
197        final int contentIndex,
198        final int contentLength ) throws UnsupportedOperationException
199    {
200        this.getTarget().append(content, contentIndex, contentLength);
201        return (PRIMITIVE)this;
202    }
203
204    @Override
205    @SuppressWarnings( "unchecked" )
206    public PRIMITIVE append( final CharSequence s )
207        throws UnsupportedOperationException
208    {
209        this.getTarget().append(s);
210        return (PRIMITIVE)this;
211    }
212
213    @Override
214    @SuppressWarnings( "unchecked" )
215    public PRIMITIVE append(
216        final CharSequence content,
217        final int contentStartIndex ) throws UnsupportedOperationException
218    {
219        this.getTarget().append(content, contentStartIndex);
220        return (PRIMITIVE)this;
221    }
222
223    @Override
224    @SuppressWarnings( "unchecked" )
225    public PRIMITIVE append(
226        final CharSequence s,
227        final int start,
228        final int end ) throws UnsupportedOperationException
229    {
230        this.getTarget().append(s, start, end);
231        return (PRIMITIVE)this;
232    }
233
234    @Override
235    @SuppressWarnings( "unchecked" )
236    public PRIMITIVE append( final double aValue )
237        throws UnsupportedOperationException
238    {
239        this.getTarget().append(aValue);
240        return (PRIMITIVE)this;
241    }
242
243    @Override
244    @SuppressWarnings( "unchecked" )
245    public PRIMITIVE append( final float aValue )
246        throws UnsupportedOperationException
247    {
248        this.getTarget().append(aValue);
249        return (PRIMITIVE)this;
250    }
251
252    @Override
253    @SuppressWarnings( "unchecked" )
254    public PRIMITIVE append( final int aValue )
255        throws UnsupportedOperationException
256    {
257        this.getTarget().append(aValue);
258        return (PRIMITIVE)this;
259    }
260
261    @Override
262    @SuppressWarnings( "unchecked" )
263    public PRIMITIVE append( final long aValue )
264        throws UnsupportedOperationException
265    {
266        this.getTarget().append(aValue);
267        return (PRIMITIVE)this;
268    }
269
270    @Override
271    @SuppressWarnings( "unchecked" )
272    public PRIMITIVE append( final Object aValue )
273        throws UnsupportedOperationException
274    {
275        this.getTarget().append(aValue);
276        return (PRIMITIVE)this;
277    }
278
279    @Override
280    @SuppressWarnings( "unchecked" )
281    public PRIMITIVE append( final StringBuffer sb )
282        throws UnsupportedOperationException
283    {
284        this.getTarget().append(sb);
285        return (PRIMITIVE)this;
286    }
287
288    @Override
289    @SuppressWarnings( "unchecked" )
290    public PRIMITIVE appendCodePoint( final int codePoint )
291        throws UnsupportedOperationException
292    {
293        this.getTarget().appendCodePoint(codePoint);
294        return (PRIMITIVE)this;
295    }
296
297    @Override
298    @SuppressWarnings( "unchecked" )
299    public PRIMITIVE arcCosine()
300        throws UnsupportedOperationException,
301            IllegalArgumentException,
302            ArithmeticException
303    {
304        this.getTarget().arcCosine();
305        return (PRIMITIVE)this;
306    }
307
308    @Override
309    @SuppressWarnings( "unchecked" )
310    public PRIMITIVE arcSine()
311        throws UnsupportedOperationException,
312            IllegalArgumentException,
313            ArithmeticException
314    {
315        this.getTarget().arcSine();
316        return (PRIMITIVE)this;
317    }
318
319    @Override
320    @SuppressWarnings( "unchecked" )
321    public PRIMITIVE arcTangent()
322        throws UnsupportedOperationException,
323            IllegalArgumentException,
324            ArithmeticException
325    {
326        this.getTarget().arcTangent();
327        return (PRIMITIVE)this;
328    }
329
330    @Override
331    @SuppressWarnings( "unchecked" )
332    public PRIMITIVE assertDomain( final Domain aDomain )
333    {
334        this.getTarget().assertDomain(aDomain);
335        return (PRIMITIVE)this;
336    }
337
338    @Override
339    @SuppressWarnings( "unchecked" )
340    public PRIMITIVE assertPrecision( final NumericPrecision prec )
341    {
342        this.getTarget().assertPrecision(prec);
343        return (PRIMITIVE)this;
344    }
345
346    @Override
347    @SuppressWarnings( "unchecked" )
348    public PRIMITIVE base10Log()
349        throws UnsupportedOperationException,
350            IllegalArgumentException,
351            ArithmeticException
352    {
353        this.getTarget().base10Log();
354        return (PRIMITIVE)this;
355    }
356
357    @Override
358    public boolean booleanPostDecrement()
359        throws UnsupportedOperationException,
360            ArithmeticException,
361            IllegalArgumentException
362    {
363        return this.getTarget().booleanPostDecrement();
364    }
365
366    @Override
367    public boolean booleanPostIncrement()
368        throws UnsupportedOperationException,
369            ArithmeticException,
370            IllegalArgumentException
371    {
372        return this.getTarget().booleanPostIncrement();
373    }
374
375    @Override
376    public boolean booleanValue()
377    {
378        return this.getTarget().booleanValue();
379    }
380
381    @Override
382    public byte bytePostDecrement()
383        throws UnsupportedOperationException,
384            ArithmeticException,
385            IllegalArgumentException
386    {
387        return this.getTarget().bytePostDecrement();
388    }
389
390    @Override
391    public byte bytePostIncrement()
392        throws UnsupportedOperationException,
393            ArithmeticException,
394            IllegalArgumentException
395    {
396        return this.getTarget().bytePostIncrement();
397    }
398
399    @Override
400    public byte byteValue()
401    {
402        return this.getTarget().byteValue();
403    }
404
405    @Override
406    public char charAt( final int index )
407    {
408        return this.getTarget().charAt(index);
409    }
410
411    @Override
412    public char charPostDecrement()
413        throws UnsupportedOperationException,
414            ArithmeticException,
415            IllegalArgumentException
416    {
417        return this.getTarget().charPostDecrement();
418    }
419
420    @Override
421    public char charPostIncrement()
422        throws UnsupportedOperationException,
423            ArithmeticException,
424            IllegalArgumentException
425    {
426        return this.getTarget().charPostIncrement();
427    }
428
429    @Override
430    public char charValue()
431    {
432        return this.getTarget().charValue();
433    }
434
435    @Override
436    public void clear() throws UnsupportedOperationException
437    {
438        this.getTarget().clear();
439    }
440
441    @Override
442    @SuppressWarnings( "unchecked" )
443    public PRIMITIVE clearContents() throws UnsupportedOperationException
444    {
445        this.getTarget().clearContents();
446        return (PRIMITIVE)this;
447    }
448
449    @Override
450    @SuppressWarnings( "unchecked" )
451    public PRIMITIVE clearText() throws UnsupportedOperationException
452    {
453        this.getTarget().clearText();
454        return (PRIMITIVE)this;
455    }
456
457    @Override
458    public int codePointAt( final int index )
459    {
460        return this.getTarget().codePointAt(index);
461    }
462
463    @Override
464    public int codePointBefore( final int index )
465    {
466        return this.getTarget().codePointBefore(index);
467    }
468
469    @Override
470    public int codePointCount( final int beginIndex, final int endIndex )
471    {
472        return this.getTarget().codePointCount(beginIndex, endIndex);
473    }
474
475    @Override
476    public int compareTo( final SealedPrimitive<?> o )
477    {
478        return this.getTarget().compareTo(o);
479    }
480
481    @Override
482    public int compareToPrimitive( final SealedPrimitive<?> aPrimitive )
483    {
484        if (aPrimitive.getPrecision().isNumeric())
485            return this.compareToReal(aPrimitive);
486        return this.compareToText(aPrimitive.toString());
487    }
488
489    @Override
490    public int compareToScalar( final boolean aValue )
491    {
492        return this.getTarget().compareToScalar(aValue);
493    }
494
495    @Override
496    public int compareToScalar( final byte aValue )
497    {
498        return this.getTarget().compareToScalar(aValue);
499    }
500
501    @Override
502    public int compareToScalar( final char aValue )
503    {
504        return this.getTarget().compareToScalar(aValue);
505    }
506
507    @Override
508    public int compareToScalar( final double aValue )
509    {
510        return this.getTarget().compareToScalar(aValue);
511    }
512
513    @Override
514    public int compareToScalar( final float aValue )
515    {
516        return this.getTarget().compareToScalar(aValue);
517    }
518
519    @Override
520    public int compareToScalar( final int aValue )
521    {
522        return this.getTarget().compareToScalar(aValue);
523    }
524
525    @Override
526    public int compareToScalar( final long aValue )
527    {
528        return this.getTarget().compareToScalar(aValue);
529    }
530
531    @Override
532    public int compareToScalar( final short aValue )
533    {
534        return this.getTarget().compareToScalar(aValue);
535    }
536
537    @Override
538    public int compareToText( final CharSequence text )
539    {
540        return this.getTarget().compareToText(text);
541    }
542
543    @Override
544    public int compareToZero()
545    {
546        return this.getTarget().compareToZero();
547    }
548
549    @Override
550    @SuppressWarnings( "unchecked" )
551    public PRIMITIVE cosine()
552        throws UnsupportedOperationException,
553            IllegalArgumentException,
554            ArithmeticException
555    {
556        this.getTarget().cosine();
557        return (PRIMITIVE)this;
558    }
559
560    @Override
561    @SuppressWarnings( "unchecked" )
562    public PRIMITIVE cube()
563        throws UnsupportedOperationException,
564            IllegalArgumentException,
565            ArithmeticException
566    {
567        this.getTarget().cube();
568        return (PRIMITIVE)this;
569    }
570
571    @Override
572    @SuppressWarnings( "unchecked" )
573    public PRIMITIVE cubeRoot()
574        throws UnsupportedOperationException,
575            IllegalArgumentException,
576            ArithmeticException
577    {
578        this.getTarget().cubeRoot();
579        return (PRIMITIVE)this;
580    }
581
582    @Override
583    @SuppressWarnings( "unchecked" )
584    public PRIMITIVE decrement()
585        throws UnsupportedOperationException,
586            IllegalArgumentException,
587            ArithmeticException
588    {
589        this.getTarget().decrement();
590        return (PRIMITIVE)this;
591    }
592
593    @Override
594    @SuppressWarnings( "unchecked" )
595    public PRIMITIVE degrees()
596        throws UnsupportedOperationException,
597            IllegalArgumentException,
598            ArithmeticException
599    {
600        this.getTarget().degrees();
601        return (PRIMITIVE)this;
602    }
603
604    @Override
605    @SuppressWarnings( "unchecked" )
606    public PRIMITIVE delete( final int start, final int end )
607        throws UnsupportedOperationException
608    {
609        this.getTarget().delete(start, end);
610        return (PRIMITIVE)this;
611    }
612
613    @Override
614    @SuppressWarnings( "unchecked" )
615    public PRIMITIVE deleteCharAt( final int anIndex )
616        throws UnsupportedOperationException
617    {
618        this.getTarget().deleteCharAt(anIndex);
619        return (PRIMITIVE)this;
620    }
621
622    @Override
623    @SuppressWarnings( "unchecked" )
624    public PRIMITIVE difference( final BigDecimal aValue )
625        throws UnsupportedOperationException,
626            IllegalArgumentException,
627            ArithmeticException
628    {
629        this.getTarget().difference(aValue);
630        return (PRIMITIVE)this;
631    }
632
633    @Override
634    @SuppressWarnings( "unchecked" )
635    public PRIMITIVE difference( final BigInteger aValue )
636        throws UnsupportedOperationException,
637            IllegalArgumentException,
638            ArithmeticException
639    {
640        this.getTarget().difference(aValue);
641        return (PRIMITIVE)this;
642    }
643
644    @Override
645    @SuppressWarnings( "unchecked" )
646    public PRIMITIVE difference( final boolean aValue )
647        throws UnsupportedOperationException,
648            IllegalArgumentException,
649            ArithmeticException
650    {
651        this.getTarget().difference(aValue);
652        return (PRIMITIVE)this;
653    }
654
655    @Override
656    @SuppressWarnings( "unchecked" )
657    public PRIMITIVE difference( final byte aValue )
658        throws UnsupportedOperationException,
659            IllegalArgumentException,
660            ArithmeticException
661    {
662        this.getTarget().difference(aValue);
663        return (PRIMITIVE)this;
664    }
665
666    @Override
667    @SuppressWarnings( "unchecked" )
668    public PRIMITIVE difference( final char aValue )
669        throws UnsupportedOperationException,
670            IllegalArgumentException,
671            ArithmeticException
672    {
673        this.getTarget().difference(aValue);
674        return (PRIMITIVE)this;
675    }
676
677    @Override
678    @SuppressWarnings( "unchecked" )
679    public PRIMITIVE difference( final double aValue )
680        throws UnsupportedOperationException,
681            IllegalArgumentException,
682            ArithmeticException
683    {
684        this.getTarget().difference(aValue);
685        return (PRIMITIVE)this;
686    }
687
688    @Override
689    @SuppressWarnings( "unchecked" )
690    public PRIMITIVE difference( final float aValue )
691        throws UnsupportedOperationException,
692            IllegalArgumentException,
693            ArithmeticException
694    {
695        this.getTarget().difference(aValue);
696        return (PRIMITIVE)this;
697    }
698
699    @Override
700    @SuppressWarnings( "unchecked" )
701    public PRIMITIVE difference( final int aValue )
702        throws UnsupportedOperationException,
703            IllegalArgumentException,
704            ArithmeticException
705    {
706        this.getTarget().difference(aValue);
707        return (PRIMITIVE)this;
708    }
709
710    @Override
711    @SuppressWarnings( "unchecked" )
712    public PRIMITIVE difference( final long aValue )
713        throws UnsupportedOperationException,
714            IllegalArgumentException,
715            ArithmeticException
716    {
717        this.getTarget().difference(aValue);
718        return (PRIMITIVE)this;
719    }
720
721    @Override
722    @SuppressWarnings( "unchecked" )
723    public PRIMITIVE difference( final short aValue )
724        throws UnsupportedOperationException,
725            IllegalArgumentException,
726            ArithmeticException
727    {
728        this.getTarget().difference(aValue);
729        return (PRIMITIVE)this;
730    }
731
732    @Override
733    public double doublePostDecrement()
734        throws UnsupportedOperationException,
735            ArithmeticException,
736            IllegalArgumentException
737    {
738        return this.getTarget().doublePostDecrement();
739    }
740
741    @Override
742    public double doublePostIncrement()
743        throws UnsupportedOperationException,
744            ArithmeticException,
745            IllegalArgumentException
746    {
747        return this.getTarget().doublePostIncrement();
748    }
749
750    @Override
751    public double doubleValue()
752    {
753        return this.getTarget().doubleValue();
754    }
755
756    @Override
757    public boolean equals( final Object anObject )
758    {
759        return this.getTarget().equals(anObject);
760    }
761
762    @Override
763    @SuppressWarnings( "unchecked" )
764    public PRIMITIVE exponential()
765        throws UnsupportedOperationException,
766            IllegalArgumentException,
767            ArithmeticException
768    {
769        this.getTarget().exponential();
770        return (PRIMITIVE)this;
771    }
772
773    @Override
774    @SuppressWarnings( "unchecked" )
775    public PRIMITIVE exponentialLessOne()
776        throws UnsupportedOperationException,
777            IllegalArgumentException,
778            ArithmeticException
779    {
780        this.getTarget().exponentialLessOne();
781        return (PRIMITIVE)this;
782    }
783
784    @Override
785    public float floatPostDecrement()
786        throws UnsupportedOperationException,
787            ArithmeticException,
788            IllegalArgumentException
789    {
790        return this.getTarget().floatPostDecrement();
791    }
792
793    @Override
794    public float floatPostIncrement()
795        throws UnsupportedOperationException,
796            ArithmeticException,
797            IllegalArgumentException
798    {
799        return this.getTarget().floatPostIncrement();
800    }
801
802    @Override
803    public float floatValue()
804    {
805        return this.getTarget().floatValue();
806    }
807
808    @Override
809    @SuppressWarnings( "unchecked" )
810    public PRIMITIVE gcd( final BigInteger aValue )
811        throws UnsupportedOperationException,
812            ArithmeticException,
813            IllegalArgumentException
814    {
815        this.getTarget().gcd(aValue);
816        return (PRIMITIVE)this;
817    }
818
819    @Override
820    @SuppressWarnings( "unchecked" )
821    public PRIMITIVE gcd( final byte aValue )
822        throws UnsupportedOperationException,
823            ArithmeticException,
824            IllegalArgumentException
825    {
826        this.getTarget().gcd(aValue);
827        return (PRIMITIVE)this;
828    }
829
830    @Override
831    @SuppressWarnings( "unchecked" )
832    public PRIMITIVE gcd( final char aValue )
833        throws UnsupportedOperationException,
834            ArithmeticException,
835            IllegalArgumentException
836    {
837        this.getTarget().gcd(aValue);
838        return (PRIMITIVE)this;
839    }
840
841    @Override
842    @SuppressWarnings( "unchecked" )
843    public PRIMITIVE gcd( final int aValue )
844        throws UnsupportedOperationException,
845            ArithmeticException,
846            IllegalArgumentException
847    {
848        this.getTarget().gcd(aValue);
849        return (PRIMITIVE)this;
850    }
851
852    @Override
853    @SuppressWarnings( "unchecked" )
854    public PRIMITIVE gcd( final long aValue )
855        throws UnsupportedOperationException,
856            ArithmeticException,
857            IllegalArgumentException
858    {
859        this.getTarget().gcd(aValue);
860        return (PRIMITIVE)this;
861    }
862
863    @Override
864    @SuppressWarnings( "unchecked" )
865    public PRIMITIVE gcd( final short aValue )
866        throws UnsupportedOperationException,
867            ArithmeticException,
868            IllegalArgumentException
869    {
870        this.getTarget().gcd(aValue);
871        return (PRIMITIVE)this;
872    }
873
874    @Override
875    public ConcurrencyStrategy getConcurrency()
876    {
877        return this.getTarget().getConcurrency();
878    }
879
880    @Override
881    public Domain getDomain()
882    {
883        return this.getTarget().getDomain();
884    }
885
886    @Override
887    public NumericPrecision getPrecision()
888    {
889        return this.getTarget().getPrecision();
890    }
891
892    @Override
893    public StructureStrategy getStructureStrategy()
894    {
895        return this.getTarget().getStructureStrategy();
896    }
897
898    @Override
899    public int hashCode()
900    {
901        return this.getTarget().hashCode();
902    }
903
904    @Override
905    @SuppressWarnings( "unchecked" )
906    public PRIMITIVE hyperbolicCosine()
907        throws UnsupportedOperationException,
908            IllegalArgumentException,
909            ArithmeticException
910    {
911        this.getTarget().hyperbolicCosine();
912        return (PRIMITIVE)this;
913    }
914
915    @Override
916    @SuppressWarnings( "unchecked" )
917    public PRIMITIVE hyperbolicSine()
918        throws UnsupportedOperationException,
919            IllegalArgumentException,
920            ArithmeticException
921    {
922        this.getTarget().hyperbolicSine();
923        return (PRIMITIVE)this;
924    }
925
926    @Override
927    @SuppressWarnings( "unchecked" )
928    public PRIMITIVE hyperbolicTangent()
929        throws UnsupportedOperationException,
930            IllegalArgumentException,
931            ArithmeticException
932    {
933        this.getTarget().hyperbolicTangent();
934        return (PRIMITIVE)this;
935    }
936
937    @Override
938    @SuppressWarnings( "unchecked" )
939    public PRIMITIVE increment()
940        throws UnsupportedOperationException,
941            ArithmeticException,
942            IllegalArgumentException
943    {
944        this.getTarget().increment();
945        return (PRIMITIVE)this;
946    }
947
948    @Override
949    public int indexOfText( final CharSequence str )
950    {
951        return this.getTarget().indexOfText(str);
952    }
953
954    @Override
955    public int indexOfText( final CharSequence str, final int beginIndex )
956    {
957        return this.getTarget().indexOfText(str, beginIndex);
958    }
959
960    @Override
961    public <P extends Primitive<?>> P inducePostDecrement( final P aTarget )
962        throws NullPointerException,
963            NoSuchElementException,
964            UnsupportedOperationException,
965            IllegalStateException
966    {
967        return this.getTarget().inducePostDecrement(aTarget);
968    }
969
970    @Override
971    public <R extends Real<?>> R inducePostDecrement( final R aTarget )
972        throws NullPointerException,
973            NoSuchElementException,
974            UnsupportedOperationException,
975            IllegalStateException
976    {
977        this.getTarget().inducePostDecrement(aTarget);
978        return aTarget;
979    }
980
981    @Override
982    public <S extends Scalar<?>> S inducePostDecrement( final S aTarget )
983        throws NullPointerException,
984            NoSuchElementException,
985            UnsupportedOperationException,
986            IllegalStateException
987    {
988        return this.getTarget().inducePostDecrement(aTarget);
989    }
990
991    @Override
992    public <P extends Primitive<?>> P inducePostIncrement( final P aTarget )
993        throws NullPointerException,
994            NoSuchElementException,
995            UnsupportedOperationException,
996            IllegalStateException
997    {
998        return this.getTarget().inducePostIncrement(aTarget);
999    }
1000
1001    @Override
1002    public <R extends Real<?>> R inducePostIncrement( final R aTarget )
1003        throws NullPointerException,
1004            NoSuchElementException,
1005            UnsupportedOperationException,
1006            IllegalStateException
1007    {
1008        this.getTarget().inducePostIncrement(aTarget);
1009        return aTarget;
1010    }
1011
1012    @Override
1013    public <S extends Scalar<?>> S inducePostIncrement( final S aTarget )
1014        throws NullPointerException,
1015            NoSuchElementException,
1016            UnsupportedOperationException,
1017            IllegalStateException
1018    {
1019        return this.getTarget().inducePostIncrement(aTarget);
1020    }
1021
1022    @Override
1023    public <P extends Primitive<?>> P inducePrimitiveMaximum( final P aTarget )
1024    {
1025        return this.getTarget().inducePrimitiveMaximum(aTarget);
1026    }
1027
1028    @Override
1029    public <P extends Primitive<?>> P inducePrimitiveMinimum( final P aTarget )
1030    {
1031        return this.getTarget().inducePrimitiveMinimum(aTarget);
1032    }
1033
1034    @Override
1035    public <P extends Primitive<?>> P inducePrimitiveValue( final P aTarget )
1036    {
1037        return this.getTarget().inducePrimitiveValue(aTarget);
1038    }
1039
1040    @Override
1041    public <R extends Real<?>> R induceRealMaximum( final R aTarget )
1042    {
1043        return this.getTarget().induceRealMaximum(aTarget);
1044    }
1045
1046    @Override
1047    public <R extends Real<?>> R induceRealMinimum( final R aTarget )
1048    {
1049        return this.getTarget().induceRealMinimum(aTarget);
1050    }
1051
1052    @Override
1053    public <R extends Real<?>> R induceRealSize( final R aTarget )
1054        throws NullPointerException,
1055            NoSuchElementException,
1056            UnsupportedOperationException,
1057            IllegalStateException
1058    {
1059        return this.getTarget().induceRealSize(aTarget);
1060    }
1061
1062    @Override
1063    public <R extends Real<?>> R induceRealValue( final R aTarget )
1064    {
1065        return this.getTarget().induceRealValue(aTarget);
1066    }
1067
1068    @Override
1069    public <S extends Scalar<?>> S induceScalarMaximum( final S aTarget )
1070    {
1071        return this.getTarget().induceScalarMaximum(aTarget);
1072    }
1073
1074    @Override
1075    public <S extends Scalar<?>> S induceScalarMinimum( final S aTarget )
1076    {
1077        return this.getTarget().induceScalarMinimum(aTarget);
1078    }
1079
1080    @Override
1081    public <R extends Scalar<?>> R induceScalarSize( final R aTarget )
1082        throws NullPointerException,
1083            NoSuchElementException,
1084            UnsupportedOperationException,
1085            IllegalStateException
1086    {
1087        return this.getTarget().induceScalarSize(aTarget);
1088    }
1089
1090    @Override
1091    public <S extends Scalar<?>> S induceScalarValue( final S aTarget )
1092    {
1093        return this.getTarget().induceScalarValue(aTarget);
1094    }
1095
1096    @Override
1097    public <SCALAR extends Scalar<?>> SCALAR induceTextSize(
1098        final SCALAR aTarget )
1099        throws NullPointerException,
1100            NoSuchElementException,
1101            UnsupportedOperationException,
1102            IllegalStateException
1103    {
1104        return this.getTarget().induceTextSize(aTarget);
1105    }
1106
1107    @Override
1108    public <TEXT extends Text<?>> TEXT induceTextValue( final TEXT aTarget )
1109        throws NullPointerException,
1110            NoSuchElementException,
1111            UnsupportedOperationException,
1112            IllegalStateException
1113    {
1114        return this.getTarget().induceTextValue(aTarget);
1115    }
1116
1117    @Override
1118    @SuppressWarnings( "unchecked" )
1119    public PRIMITIVE insert( final int anIndex, final boolean aValue )
1120        throws UnsupportedOperationException
1121    {
1122        this.getTarget().insert(anIndex, aValue);
1123        return (PRIMITIVE)this;
1124    }
1125
1126    @Override
1127    @SuppressWarnings( "unchecked" )
1128    public PRIMITIVE insert( final int anIndex, final char aValue )
1129        throws UnsupportedOperationException
1130    {
1131        this.getTarget().insert(anIndex, aValue);
1132        return (PRIMITIVE)this;
1133    }
1134
1135    @Override
1136    @SuppressWarnings( "unchecked" )
1137    public PRIMITIVE insert( final int anIndex, final char[] content )
1138        throws UnsupportedOperationException
1139    {
1140        this.getTarget().insert(anIndex, content);
1141        return (PRIMITIVE)this;
1142    }
1143
1144    @Override
1145    @SuppressWarnings( "unchecked" )
1146    public PRIMITIVE insert(
1147        final int targetIndex,
1148        final char[] content,
1149        final int contentIndex,
1150        final int contentLength ) throws UnsupportedOperationException
1151    {
1152        this.getTarget().insert(targetIndex, content, contentIndex,
1153            contentLength);
1154        return (PRIMITIVE)this;
1155    }
1156
1157    @Override
1158    @SuppressWarnings( "unchecked" )
1159    public PRIMITIVE insert( final int anIndex, final CharSequence content )
1160        throws UnsupportedOperationException
1161    {
1162        this.getTarget().insert(anIndex, content);
1163        return (PRIMITIVE)this;
1164    }
1165
1166    @Override
1167    @SuppressWarnings( "unchecked" )
1168    public PRIMITIVE insert(
1169        final int targetIndex,
1170        final CharSequence content,
1171        final int contentIndex ) throws UnsupportedOperationException
1172    {
1173        this.getTarget().insert(targetIndex, content, contentIndex);
1174        return (PRIMITIVE)this;
1175    }
1176
1177    @Override
1178    @SuppressWarnings( "unchecked" )
1179    public PRIMITIVE insert(
1180        final int targetIndex,
1181        final CharSequence content,
1182        final int contentStartIndex,
1183        final int contentEndIndexPlusOne ) throws UnsupportedOperationException
1184    {
1185        this.getTarget().insert(targetIndex, content, contentStartIndex,
1186            contentEndIndexPlusOne);
1187        return (PRIMITIVE)this;
1188    }
1189
1190    @Override
1191    @SuppressWarnings( "unchecked" )
1192    public PRIMITIVE insert( final int anIndex, final double aValue )
1193        throws UnsupportedOperationException
1194    {
1195        this.getTarget().insert(anIndex, aValue);
1196        return (PRIMITIVE)this;
1197    }
1198
1199    @Override
1200    @SuppressWarnings( "unchecked" )
1201    public PRIMITIVE insert( final int anIndex, final float aValue )
1202        throws UnsupportedOperationException
1203    {
1204        this.getTarget().insert(anIndex, aValue);
1205        return (PRIMITIVE)this;
1206    }
1207
1208    @Override
1209    @SuppressWarnings( "unchecked" )
1210    public PRIMITIVE insert( final int anIndex, final int aValue )
1211        throws UnsupportedOperationException
1212    {
1213        this.getTarget().insert(anIndex, aValue);
1214        return (PRIMITIVE)this;
1215    }
1216
1217    @Override
1218    @SuppressWarnings( "unchecked" )
1219    public PRIMITIVE insert( final int anIndex, final long aValue )
1220        throws UnsupportedOperationException
1221    {
1222        this.getTarget().insert(anIndex, aValue);
1223        return (PRIMITIVE)this;
1224    }
1225
1226    @Override
1227    @SuppressWarnings( "unchecked" )
1228    public PRIMITIVE insert( final int anIndex, final Object aValue )
1229        throws UnsupportedOperationException
1230    {
1231        this.getTarget().insert(anIndex, aValue);
1232        return (PRIMITIVE)this;
1233    }
1234
1235    @Override
1236    public int intPostDecrement()
1237        throws UnsupportedOperationException,
1238            ArithmeticException,
1239            IllegalArgumentException
1240    {
1241        return this.getTarget().intPostDecrement();
1242    }
1243
1244    @Override
1245    public int intPostIncrement()
1246        throws UnsupportedOperationException,
1247            ArithmeticException,
1248            IllegalArgumentException
1249    {
1250        return this.getTarget().intPostIncrement();
1251    }
1252
1253    @Override
1254    public int intValue()
1255    {
1256        return this.getTarget().intValue();
1257    }
1258
1259    @Override
1260    @SuppressWarnings( "unchecked" )
1261    public PRIMITIVE invalidate()
1262        throws UnsupportedOperationException,
1263            IllegalArgumentException,
1264            ArithmeticException
1265    {
1266        this.getTarget().invalidate();
1267        return (PRIMITIVE)this;
1268    }
1269
1270    @Override
1271    @SuppressWarnings( "unchecked" )
1272    public PRIMITIVE inverse()
1273        throws UnsupportedOperationException,
1274            ArithmeticException,
1275            IllegalArgumentException
1276    {
1277        this.getTarget().inverse();
1278        return (PRIMITIVE)this;
1279    }
1280
1281    @Override
1282    public boolean isAlphabetic()
1283    {
1284        return this.getTarget().isAlphabetic();
1285    }
1286
1287    @Override
1288    public boolean isBmpCodePoint()
1289    {
1290        return this.getTarget().isBmpCodePoint();
1291    }
1292
1293    @Override
1294    public boolean isConfigurable()
1295    {
1296        return this.getTarget().isConfigurable();
1297    }
1298
1299    @Override
1300    public boolean isCountable()
1301    {
1302        return this.getTarget().isCountable();
1303    }
1304
1305    @Override
1306    public boolean isDigit()
1307    {
1308        return this.getTarget().isDigit();
1309    }
1310
1311    @Override
1312    public boolean isElastic()
1313    {
1314        return this.getTarget().isElastic();
1315    }
1316
1317    @Override
1318    public boolean isEmpty()
1319    {
1320        return this.getTarget().isEmpty();
1321    }
1322
1323    @Override
1324    public boolean isEqual( final BigDecimal aValue )
1325    {
1326        return this.getTarget().isEqual(aValue);
1327    }
1328
1329    @Override
1330    public boolean isEqual( final BigInteger aValue )
1331    {
1332        return this.getTarget().isEqual(aValue);
1333    }
1334
1335    @Override
1336    public boolean isEqual( final boolean aValue )
1337    {
1338        return this.getTarget().isEqual(aValue);
1339    }
1340
1341    @Override
1342    public boolean isEqual( final byte aValue )
1343    {
1344        return this.getTarget().isEqual(aValue);
1345    }
1346
1347    @Override
1348    public boolean isEqual( final char aValue )
1349    {
1350        return this.getTarget().isEqual(aValue);
1351    }
1352
1353    @Override
1354    public boolean isEqual( final double aValue )
1355    {
1356        return this.getTarget().isEqual(aValue);
1357    }
1358
1359    @Override
1360    public boolean isEqual( final float aValue )
1361    {
1362        return this.getTarget().isEqual(aValue);
1363    }
1364
1365    @Override
1366    public boolean isEqual( final int aValue )
1367    {
1368        return this.getTarget().isEqual(aValue);
1369    }
1370
1371    @Override
1372    public boolean isEqual( final long aValue )
1373    {
1374        return this.getTarget().isEqual(aValue);
1375    }
1376
1377    @Override
1378    public boolean isEqual( final short aValue )
1379    {
1380        return this.getTarget().isEqual(aValue);
1381    }
1382
1383    @Override
1384    public boolean isEqualToPrimitive( final SealedPrimitive<?> aPrimitive )
1385    {
1386        if (aPrimitive.getPrecision().isNumeric())
1387            return this.isEqualToReal(aPrimitive);
1388        return this.isEqualToText(aPrimitive.toString());
1389    }
1390
1391    @Override
1392    public boolean isEqualToText( final CharSequence aValue )
1393    {
1394        return this.getTarget().isEqualToText(aValue);
1395    }
1396
1397    @Override
1398    public boolean isExpandable()
1399    {
1400        return this.getTarget().isExpandable();
1401    }
1402
1403    @Override
1404    public boolean isFinite()
1405    {
1406        return this.getTarget().isFinite();
1407    }
1408
1409    @Override
1410    public boolean isGreater( final BigDecimal aValue )
1411    {
1412        return this.getTarget().isGreater(aValue);
1413    }
1414
1415    @Override
1416    public boolean isGreater( final BigInteger aValue )
1417    {
1418        return this.getTarget().isGreater(aValue);
1419    }
1420
1421    @Override
1422    public boolean isGreater( final boolean aValue )
1423    {
1424        return this.getTarget().isGreater(aValue);
1425    }
1426
1427    @Override
1428    public boolean isGreater( final byte aValue )
1429    {
1430        return this.getTarget().isGreater(aValue);
1431    }
1432
1433    @Override
1434    public boolean isGreater( final char aValue )
1435    {
1436        return this.getTarget().isGreater(aValue);
1437    }
1438
1439    @Override
1440    public boolean isGreater( final double aValue )
1441    {
1442        return this.getTarget().isGreater(aValue);
1443    }
1444
1445    @Override
1446    public boolean isGreater( final float aValue )
1447    {
1448        return this.getTarget().isGreater(aValue);
1449    }
1450
1451    @Override
1452    public boolean isGreater( final int aValue )
1453    {
1454        return this.getTarget().isGreater(aValue);
1455    }
1456
1457    @Override
1458    public boolean isGreater( final long aValue )
1459    {
1460        return this.getTarget().isGreater(aValue);
1461    }
1462
1463    @Override
1464    public boolean isGreater( final short aValue )
1465    {
1466        return this.getTarget().isGreater(aValue);
1467    }
1468
1469    @Override
1470    public boolean isGreaterOrEqual( final BigDecimal aValue )
1471    {
1472        return this.getTarget().isGreaterOrEqual(aValue);
1473    }
1474
1475    @Override
1476    public boolean isGreaterOrEqual( final BigInteger aValue )
1477    {
1478        return this.getTarget().isGreaterOrEqual(aValue);
1479    }
1480
1481    @Override
1482    public boolean isGreaterOrEqual( final boolean aValue )
1483    {
1484        return this.getTarget().isGreaterOrEqual(aValue);
1485    }
1486
1487    @Override
1488    public boolean isGreaterOrEqual( final byte aValue )
1489    {
1490        return this.getTarget().isGreaterOrEqual(aValue);
1491    }
1492
1493    @Override
1494    public boolean isGreaterOrEqual( final char aValue )
1495    {
1496        return this.getTarget().isGreaterOrEqual(aValue);
1497    }
1498
1499    @Override
1500    public boolean isGreaterOrEqual( final double aValue )
1501    {
1502        return this.getTarget().isGreaterOrEqual(aValue);
1503    }
1504
1505    @Override
1506    public boolean isGreaterOrEqual( final float aValue )
1507    {
1508        return this.getTarget().isGreaterOrEqual(aValue);
1509    }
1510
1511    @Override
1512    public boolean isGreaterOrEqual( final int aValue )
1513    {
1514        return this.getTarget().isGreaterOrEqual(aValue);
1515    }
1516
1517    @Override
1518    public boolean isGreaterOrEqual( final long aValue )
1519    {
1520        return this.getTarget().isGreaterOrEqual(aValue);
1521    }
1522
1523    @Override
1524    public boolean isGreaterOrEqual( final short aValue )
1525    {
1526        return this.getTarget().isGreaterOrEqual(aValue);
1527    }
1528
1529    @Override
1530    public boolean isGreaterOrEqualToPrimitive(
1531        final SealedPrimitive<?> aPrimitive )
1532    {
1533        if (aPrimitive.getPrecision().isNumeric())
1534            return this.isGreaterOrEqualToReal(aPrimitive);
1535        return this.isGreaterOrEqualToText(aPrimitive.toString());
1536    }
1537
1538    @Override
1539    public boolean isGreaterOrEqualToText( final CharSequence aValue )
1540    {
1541        return this.getTarget().isGreaterOrEqualToText(aValue);
1542    }
1543
1544    @Override
1545    public boolean isGreaterThanPrimitive( final SealedPrimitive<?> aPrimitive )
1546    {
1547        if (aPrimitive.getPrecision().isNumeric())
1548            return this.isGreaterThanReal(aPrimitive);
1549        return this.isGreaterThanText(aPrimitive.toString());
1550    }
1551
1552    @Override
1553    public boolean isGreaterThanText( final CharSequence aValue )
1554    {
1555        return this.getTarget().isGreaterThanText(aValue);
1556    }
1557
1558    @Override
1559    public boolean isHighSurrogate()
1560    {
1561        return this.getTarget().isHighSurrogate();
1562    }
1563
1564    @Override
1565    public boolean isIdentifierIgnorable()
1566    {
1567        return this.getTarget().isIdentifierIgnorable();
1568    }
1569
1570    @Override
1571    public boolean isIdeographic()
1572    {
1573        return this.getTarget().isIdeographic();
1574    }
1575
1576    @Override
1577    public boolean isImaginary()
1578    {
1579        return this.getTarget().isImaginary();
1580    }
1581
1582    @Override
1583    public boolean isInfinity()
1584    {
1585        return this.getTarget().isInfinity();
1586    }
1587
1588    @Override
1589    public boolean isInvalid()
1590    {
1591        return this.getTarget().isInvalid();
1592    }
1593
1594    @Override
1595    public boolean isISOControl()
1596    {
1597        return this.getTarget().isISOControl();
1598    }
1599
1600    @Override
1601    public boolean isJavaIdentifierPart()
1602    {
1603        return this.getTarget().isJavaIdentifierPart();
1604    }
1605
1606    @Override
1607    public boolean isJavaIdentifierStart()
1608    {
1609        return this.getTarget().isJavaIdentifierStart();
1610    }
1611
1612    @Override
1613    public boolean isLess( final BigDecimal aValue )
1614    {
1615        return this.getTarget().isLess(aValue);
1616    }
1617
1618    @Override
1619    public boolean isLess( final BigInteger aValue )
1620    {
1621        return this.getTarget().isLess(aValue);
1622    }
1623
1624    @Override
1625    public boolean isLess( final boolean aValue )
1626    {
1627        return this.getTarget().isLess(aValue);
1628    }
1629
1630    @Override
1631    public boolean isLess( final byte aValue )
1632    {
1633        return this.getTarget().isLess(aValue);
1634    }
1635
1636    @Override
1637    public boolean isLess( final char aValue )
1638    {
1639        return this.getTarget().isLess(aValue);
1640    }
1641
1642    @Override
1643    public boolean isLess( final double aValue )
1644    {
1645        return this.getTarget().isLess(aValue);
1646    }
1647
1648    @Override
1649    public boolean isLess( final float aValue )
1650    {
1651        return this.getTarget().isLess(aValue);
1652    }
1653
1654    @Override
1655    public boolean isLess( final int aValue )
1656    {
1657        return this.getTarget().isLess(aValue);
1658    }
1659
1660    @Override
1661    public boolean isLess( final long aValue )
1662    {
1663        return this.getTarget().isLess(aValue);
1664    }
1665
1666    @Override
1667    public boolean isLess( final short aValue )
1668    {
1669        return this.getTarget().isLess(aValue);
1670    }
1671
1672    @Override
1673    public boolean isLessOrEqual( final BigDecimal aValue )
1674    {
1675        return this.getTarget().isLessOrEqual(aValue);
1676    }
1677
1678    @Override
1679    public boolean isLessOrEqual( final BigInteger aValue )
1680    {
1681        return this.getTarget().isLessOrEqual(aValue);
1682    }
1683
1684    @Override
1685    public boolean isLessOrEqual( final boolean aValue )
1686    {
1687        return this.getTarget().isLessOrEqual(aValue);
1688    }
1689
1690    @Override
1691    public boolean isLessOrEqual( final byte aValue )
1692    {
1693        return this.getTarget().isLessOrEqual(aValue);
1694    }
1695
1696    @Override
1697    public boolean isLessOrEqual( final char aValue )
1698    {
1699        return this.getTarget().isLessOrEqual(aValue);
1700    }
1701
1702    @Override
1703    public boolean isLessOrEqual( final double aValue )
1704    {
1705        return this.getTarget().isLessOrEqual(aValue);
1706    }
1707
1708    @Override
1709    public boolean isLessOrEqual( final float aValue )
1710    {
1711        return this.getTarget().isLessOrEqual(aValue);
1712    }
1713
1714    @Override
1715    public boolean isLessOrEqual( final int aValue )
1716    {
1717        return this.getTarget().isLessOrEqual(aValue);
1718    }
1719
1720    @Override
1721    public boolean isLessOrEqual( final long aValue )
1722    {
1723        return this.getTarget().isLessOrEqual(aValue);
1724    }
1725
1726    @Override
1727    public boolean isLessOrEqual( final short aValue )
1728    {
1729        return this.getTarget().isLessOrEqual(aValue);
1730    }
1731
1732    @Override
1733    public boolean isLessOrEqualToPrimitive( final SealedPrimitive<?> aPrimitive )
1734    {
1735        if (aPrimitive.getPrecision().isNumeric())
1736            return this.isLessOrEqualToReal(aPrimitive);
1737        return this.isLessOrEqualToText(aPrimitive.toString());
1738    }
1739
1740    @Override
1741    public boolean isLessOrEqualToText( final CharSequence aValue )
1742    {
1743        return this.getTarget().isLessOrEqualToText(aValue);
1744    }
1745
1746    @Override
1747    public boolean isLessThanPrimitive( final SealedPrimitive<?> aPrimitive )
1748    {
1749        if (aPrimitive.getPrecision().isNumeric())
1750            return this.isLessThanReal(aPrimitive);
1751        return this.isLessThanText(aPrimitive.toString());
1752    }
1753
1754    @Override
1755    public boolean isLessThanText( final CharSequence aValue )
1756    {
1757        return this.getTarget().isLessThanText(aValue);
1758    }
1759
1760    @Override
1761    public boolean isLetter()
1762    {
1763        return this.getTarget().isLetter();
1764    }
1765
1766    @Override
1767    public boolean isLetterOrDigit()
1768    {
1769        return this.getTarget().isLetterOrDigit();
1770    }
1771
1772    @Override
1773    public boolean isLowerCase()
1774    {
1775        return this.getTarget().isLowerCase();
1776    }
1777
1778    @Override
1779    public boolean isLowSurrogate()
1780    {
1781        return this.getTarget().isLowSurrogate();
1782    }
1783
1784    @Override
1785    public boolean isMaximum()
1786    {
1787        return this.getTarget().isMaximum();
1788    }
1789
1790    @Override
1791    public boolean isMinimum()
1792    {
1793        return this.getTarget().isMinimum();
1794    }
1795
1796    @Override
1797    public boolean isMirrored()
1798    {
1799        return this.getTarget().isMirrored();
1800    }
1801
1802    @Override
1803    public boolean isModulo()
1804    {
1805        return this.getTarget().isModulo();
1806    }
1807
1808    @Override
1809    public boolean isMutable()
1810    {
1811        return this.getTarget().isMutable();
1812    }
1813
1814    @Override
1815    public boolean isNegative()
1816    {
1817        return this.getTarget().isNegative();
1818    }
1819
1820    @Override
1821    public boolean isNegativeFinite()
1822    {
1823        return this.getTarget().isNegativeFinite();
1824    }
1825
1826    @Override
1827    public boolean isNegativeInfinity()
1828    {
1829        return this.getTarget().isNegativeInfinity();
1830    }
1831
1832    @Override
1833    public boolean isNotEqual( final BigDecimal aValue )
1834    {
1835        return this.getTarget().isNotEqual(aValue);
1836    }
1837
1838    @Override
1839    public boolean isNotEqual( final BigInteger aValue )
1840    {
1841        return this.getTarget().isNotEqual(aValue);
1842    }
1843
1844    @Override
1845    public boolean isNotEqual( final boolean aValue )
1846    {
1847        return this.getTarget().isNotEqual(aValue);
1848    }
1849
1850    @Override
1851    public boolean isNotEqual( final byte aValue )
1852    {
1853        return this.getTarget().isNotEqual(aValue);
1854    }
1855
1856    @Override
1857    public boolean isNotEqual( final char aValue )
1858    {
1859        return this.getTarget().isNotEqual(aValue);
1860    }
1861
1862    @Override
1863    public boolean isNotEqual( final double aValue )
1864    {
1865        return this.getTarget().isNotEqual(aValue);
1866    }
1867
1868    @Override
1869    public boolean isNotEqual( final float aValue )
1870    {
1871        return this.getTarget().isNotEqual(aValue);
1872    }
1873
1874    @Override
1875    public boolean isNotEqual( final int aValue )
1876    {
1877        return this.getTarget().isNotEqual(aValue);
1878    }
1879
1880    @Override
1881    public boolean isNotEqual( final long aValue )
1882    {
1883        return this.getTarget().isNotEqual(aValue);
1884    }
1885
1886    @Override
1887    public boolean isNotEqual( final short aValue )
1888    {
1889        return this.getTarget().isNotEqual(aValue);
1890    }
1891
1892    @Override
1893    public boolean isNotEqualToPrimitive( final SealedPrimitive<?> aPrimitive )
1894    {
1895        if (aPrimitive.getPrecision().isNumeric())
1896            return this.isNotEqualToReal(aPrimitive);
1897        return this.isNotEqualToText(aPrimitive.toString());
1898    }
1899
1900    @Override
1901    public boolean isNotEqualToText( final CharSequence aValue )
1902    {
1903        return this.getTarget().isNotEqualToText(aValue);
1904    }
1905
1906    @Override
1907    public boolean isOrdered()
1908    {
1909        return this.getTarget().isOrdered();
1910    }
1911
1912    @Override
1913    public boolean isPositive()
1914    {
1915        return this.getTarget().isPositive();
1916    }
1917
1918    @Override
1919    public boolean isPositiveFinite()
1920    {
1921        return this.getTarget().isPositiveFinite();
1922    }
1923
1924    @Override
1925    public boolean isPositiveInfinity()
1926    {
1927        return this.getTarget().isPositiveInfinity();
1928    }
1929
1930    @Override
1931    public boolean isReal()
1932    {
1933        return this.getTarget().isReal();
1934    }
1935
1936    @Override
1937    public boolean isReducible()
1938    {
1939        return this.getTarget().isReducible();
1940    }
1941
1942    @Override
1943    public boolean isSupplementaryCodePoint()
1944    {
1945        return this.getTarget().isSupplementaryCodePoint();
1946    }
1947
1948    @Override
1949    public boolean isSurrogate()
1950    {
1951        return this.getTarget().isSurrogate();
1952    }
1953
1954    @Override
1955    public boolean isText()
1956    {
1957        return this.getTarget().isText();
1958    }
1959
1960    @Override
1961    public boolean isTitleCase()
1962    {
1963        return this.getTarget().isTitleCase();
1964    }
1965
1966    @Override
1967    public boolean isUnicode()
1968    {
1969        return this.getTarget().isUnicode();
1970    }
1971
1972    @Override
1973    public boolean isUnicodeIdentifierPart()
1974    {
1975        return this.getTarget().isUnicodeIdentifierPart();
1976    }
1977
1978    @Override
1979    public boolean isUnicodeIdentifierStart()
1980    {
1981        return this.getTarget().isUnicodeIdentifierStart();
1982    }
1983
1984    @Override
1985    public boolean isUnique()
1986    {
1987        return this.getTarget().isUnique();
1988    }
1989
1990    @Override
1991    public boolean isUnity()
1992    {
1993        return this.getTarget().isUnity();
1994    }
1995
1996    @Override
1997    public boolean isUpperCase()
1998    {
1999        return this.getTarget().isUpperCase();
2000    }
2001
2002    @Override
2003    public boolean isValidCodePoint()
2004    {
2005        return this.getTarget().isValidCodePoint();
2006    }
2007
2008    @Override
2009    public boolean isWhitespace()
2010    {
2011        return this.getTarget().isWhitespace();
2012    }
2013
2014    @Override
2015    public boolean isZero()
2016    {
2017        return this.getTarget().isZero();
2018    }
2019
2020    @Override
2021    public int length()
2022    {
2023        return this.getTarget().length();
2024    }
2025
2026    @Override
2027    public long longPostDecrement()
2028        throws UnsupportedOperationException,
2029            ArithmeticException,
2030            IllegalArgumentException
2031    {
2032        return this.getTarget().longPostDecrement();
2033    }
2034
2035    @Override
2036    public long longPostIncrement()
2037        throws UnsupportedOperationException,
2038            ArithmeticException,
2039            IllegalArgumentException
2040    {
2041        return this.getTarget().longPostIncrement();
2042    }
2043
2044    @Override
2045    public long longSize()
2046    {
2047        return this.getTarget().longSize();
2048    }
2049
2050    @Override
2051    public long longValue()
2052    {
2053        return this.getTarget().longValue();
2054    }
2055
2056    @Override
2057    @SuppressWarnings( "unchecked" )
2058    public PRIMITIVE lowerCase()
2059    {
2060        this.getTarget().lowerCase();
2061        return (PRIMITIVE)this;
2062    }
2063
2064    @Override
2065    @SuppressWarnings( "unchecked" )
2066    public PRIMITIVE milliseconds() throws UnsupportedOperationException
2067    {
2068        this.getTarget().milliseconds();
2069        return (PRIMITIVE)this;
2070    }
2071
2072    @Override
2073    @SuppressWarnings( "unchecked" )
2074    public PRIMITIVE mod( final BigDecimal aValue )
2075        throws UnsupportedOperationException,
2076            IllegalArgumentException,
2077            ArithmeticException
2078    {
2079        this.getTarget().mod(aValue);
2080        return (PRIMITIVE)this;
2081    }
2082
2083    @Override
2084    @SuppressWarnings( "unchecked" )
2085    public PRIMITIVE mod( final BigInteger aValue )
2086        throws UnsupportedOperationException,
2087            IllegalArgumentException,
2088            ArithmeticException
2089    {
2090        this.getTarget().mod(aValue);
2091        return (PRIMITIVE)this;
2092    }
2093
2094    @Override
2095    @SuppressWarnings( "unchecked" )
2096    public PRIMITIVE mod( final boolean aValue )
2097        throws UnsupportedOperationException,
2098            IllegalArgumentException,
2099            ArithmeticException
2100    {
2101        this.getTarget().mod(aValue);
2102        return (PRIMITIVE)this;
2103    }
2104
2105    @Override
2106    @SuppressWarnings( "unchecked" )
2107    public PRIMITIVE mod( final byte aValue )
2108        throws UnsupportedOperationException,
2109            IllegalArgumentException,
2110            ArithmeticException
2111    {
2112        this.getTarget().mod(aValue);
2113        return (PRIMITIVE)this;
2114    }
2115
2116    @Override
2117    @SuppressWarnings( "unchecked" )
2118    public PRIMITIVE mod( final char aValue )
2119        throws UnsupportedOperationException,
2120            IllegalArgumentException,
2121            ArithmeticException
2122    {
2123        this.getTarget().mod(aValue);
2124        return (PRIMITIVE)this;
2125    }
2126
2127    @Override
2128    @SuppressWarnings( "unchecked" )
2129    public PRIMITIVE mod( final double aValue )
2130        throws UnsupportedOperationException,
2131            IllegalArgumentException,
2132            ArithmeticException
2133    {
2134        this.getTarget().mod(aValue);
2135        return (PRIMITIVE)this;
2136    }
2137
2138    @Override
2139    @SuppressWarnings( "unchecked" )
2140    public PRIMITIVE mod( final float aValue )
2141        throws UnsupportedOperationException,
2142            IllegalArgumentException,
2143            ArithmeticException
2144    {
2145        this.getTarget().mod(aValue);
2146        return (PRIMITIVE)this;
2147    }
2148
2149    @Override
2150    @SuppressWarnings( "unchecked" )
2151    public PRIMITIVE mod( final int aValue )
2152        throws UnsupportedOperationException,
2153            IllegalArgumentException,
2154            ArithmeticException
2155    {
2156        this.getTarget().mod(aValue);
2157        return (PRIMITIVE)this;
2158    }
2159
2160    @Override
2161    @SuppressWarnings( "unchecked" )
2162    public PRIMITIVE mod( final long aValue )
2163        throws UnsupportedOperationException,
2164            IllegalArgumentException,
2165            ArithmeticException
2166    {
2167        this.getTarget().mod(aValue);
2168        return (PRIMITIVE)this;
2169    }
2170
2171    @Override
2172    @SuppressWarnings( "unchecked" )
2173    public PRIMITIVE mod( final short aValue )
2174        throws UnsupportedOperationException,
2175            IllegalArgumentException,
2176            ArithmeticException
2177    {
2178        this.getTarget().mod(aValue);
2179        return (PRIMITIVE)this;
2180    }
2181
2182    @Override
2183    @SuppressWarnings( "unchecked" )
2184    public PRIMITIVE nanoseconds() throws UnsupportedOperationException
2185    {
2186        this.getTarget().nanoseconds();
2187        return (PRIMITIVE)this;
2188    }
2189
2190    @Override
2191    @SuppressWarnings( "unchecked" )
2192    public PRIMITIVE naturalLog()
2193        throws UnsupportedOperationException,
2194            IllegalArgumentException,
2195            ArithmeticException
2196    {
2197        this.getTarget().naturalLog();
2198        return (PRIMITIVE)this;
2199    }
2200
2201    @Override
2202    @SuppressWarnings( "unchecked" )
2203    public PRIMITIVE naturalLogPlusOne()
2204        throws UnsupportedOperationException,
2205            IllegalArgumentException,
2206            ArithmeticException
2207    {
2208        this.getTarget().naturalLogPlusOne();
2209        return (PRIMITIVE)this;
2210    }
2211
2212    @Override
2213    @SuppressWarnings( "unchecked" )
2214    public PRIMITIVE negate()
2215        throws UnsupportedOperationException,
2216            ArithmeticException,
2217            IllegalArgumentException
2218    {
2219        this.getTarget().negate();
2220        return (PRIMITIVE)this;
2221    }
2222
2223    @Override
2224    @SuppressWarnings( "unchecked" )
2225    public PRIMITIVE not()
2226        throws UnsupportedOperationException,
2227            IllegalArgumentException,
2228            ArithmeticException
2229    {
2230        this.getTarget().not();
2231        return (PRIMITIVE)this;
2232    }
2233
2234    @Override
2235    @SuppressWarnings( "unchecked" )
2236    public PRIMITIVE or( final BigInteger aValue )
2237        throws UnsupportedOperationException,
2238            IllegalArgumentException,
2239            ArithmeticException
2240    {
2241        this.getTarget().or(aValue);
2242        return (PRIMITIVE)this;
2243    }
2244
2245    @Override
2246    @SuppressWarnings( "unchecked" )
2247    public PRIMITIVE or( final boolean aValue )
2248        throws UnsupportedOperationException,
2249            IllegalArgumentException,
2250            ArithmeticException
2251    {
2252        this.getTarget().or(aValue);
2253        return (PRIMITIVE)this;
2254    }
2255
2256    @Override
2257    @SuppressWarnings( "unchecked" )
2258    public PRIMITIVE or( final byte aValue )
2259        throws UnsupportedOperationException,
2260            IllegalArgumentException,
2261            ArithmeticException
2262    {
2263        this.getTarget().or(aValue);
2264        return (PRIMITIVE)this;
2265    }
2266
2267    @Override
2268    @SuppressWarnings( "unchecked" )
2269    public PRIMITIVE or( final char aValue )
2270        throws UnsupportedOperationException,
2271            IllegalArgumentException,
2272            ArithmeticException
2273    {
2274        this.getTarget().or(aValue);
2275        return (PRIMITIVE)this;
2276    }
2277
2278    @Override
2279    @SuppressWarnings( "unchecked" )
2280    public PRIMITIVE or( final int aValue )
2281        throws UnsupportedOperationException,
2282            IllegalArgumentException,
2283            ArithmeticException
2284    {
2285        this.getTarget().or(aValue);
2286        return (PRIMITIVE)this;
2287    }
2288
2289    @Override
2290    @SuppressWarnings( "unchecked" )
2291    public PRIMITIVE or( final long aValue )
2292        throws UnsupportedOperationException,
2293            IllegalArgumentException,
2294            ArithmeticException
2295    {
2296        this.getTarget().or(aValue);
2297        return (PRIMITIVE)this;
2298    }
2299
2300    @Override
2301    @SuppressWarnings( "unchecked" )
2302    public PRIMITIVE or( final short aValue )
2303        throws UnsupportedOperationException,
2304            IllegalArgumentException,
2305            ArithmeticException
2306    {
2307        this.getTarget().or(aValue);
2308        return (PRIMITIVE)this;
2309    }
2310
2311    @Override
2312    @SuppressWarnings( "unchecked" )
2313    public PRIMITIVE power( final double n )
2314        throws UnsupportedOperationException,
2315            IllegalArgumentException,
2316            ArithmeticException
2317    {
2318        this.getTarget().power(n);
2319        return (PRIMITIVE)this;
2320    }
2321
2322    @Override
2323    @SuppressWarnings( "unchecked" )
2324    public PRIMITIVE power( final int n )
2325        throws UnsupportedOperationException,
2326            IllegalArgumentException,
2327            ArithmeticException
2328    {
2329        this.getTarget().power(n);
2330        return (PRIMITIVE)this;
2331    }
2332
2333    @Override
2334    @SuppressWarnings( "unchecked" )
2335    public PRIMITIVE prepend( final boolean aValue )
2336        throws UnsupportedOperationException
2337    {
2338        this.getTarget().prepend(aValue);
2339        return (PRIMITIVE)this;
2340    }
2341
2342    @Override
2343    @SuppressWarnings( "unchecked" )
2344    public PRIMITIVE prepend( final char aValue )
2345        throws UnsupportedOperationException
2346    {
2347        this.getTarget().prepend(aValue);
2348        return (PRIMITIVE)this;
2349    }
2350
2351    @Override
2352    @SuppressWarnings( "unchecked" )
2353    public PRIMITIVE prepend( final char[] content )
2354        throws UnsupportedOperationException
2355    {
2356        this.getTarget().prepend(content);
2357        return (PRIMITIVE)this;
2358    }
2359
2360    @Override
2361    @SuppressWarnings( "unchecked" )
2362    public PRIMITIVE prepend( final char[] content, final int contentIndex )
2363        throws UnsupportedOperationException
2364    {
2365        this.getTarget().prepend(content, contentIndex);
2366        return (PRIMITIVE)this;
2367    }
2368
2369    @Override
2370    @SuppressWarnings( "unchecked" )
2371    public PRIMITIVE prepend(
2372        final char[] content,
2373        final int contentIndex,
2374        final int contentLength ) throws UnsupportedOperationException
2375    {
2376        this.getTarget().prepend(content, contentIndex, contentLength);
2377        return (PRIMITIVE)this;
2378    }
2379
2380    @Override
2381    @SuppressWarnings( "unchecked" )
2382    public PRIMITIVE prepend( final CharSequence content )
2383        throws UnsupportedOperationException
2384    {
2385        this.getTarget().prepend(content);
2386        return (PRIMITIVE)this;
2387    }
2388
2389    @Override
2390    @SuppressWarnings( "unchecked" )
2391    public PRIMITIVE prepend( final CharSequence content, final int contentIndex )
2392        throws UnsupportedOperationException
2393    {
2394        this.getTarget().prepend(content, contentIndex);
2395        return (PRIMITIVE)this;
2396    }
2397
2398    @Override
2399    @SuppressWarnings( "unchecked" )
2400    public PRIMITIVE prepend(
2401        final CharSequence content,
2402        final int contentStartIndex,
2403        final int contentEndIndexPlusOne ) throws UnsupportedOperationException
2404    {
2405        this.getTarget().prepend(content, contentStartIndex,
2406            contentEndIndexPlusOne);
2407        return (PRIMITIVE)this;
2408    }
2409
2410    @Override
2411    @SuppressWarnings( "unchecked" )
2412    public PRIMITIVE prepend( final double aValue )
2413        throws UnsupportedOperationException
2414    {
2415        this.getTarget().prepend(aValue);
2416        return (PRIMITIVE)this;
2417    }
2418
2419    @Override
2420    @SuppressWarnings( "unchecked" )
2421    public PRIMITIVE prepend( final float aValue )
2422        throws UnsupportedOperationException
2423    {
2424        this.getTarget().prepend(aValue);
2425        return (PRIMITIVE)this;
2426    }
2427
2428    @Override
2429    @SuppressWarnings( "unchecked" )
2430    public PRIMITIVE prepend( final int aValue )
2431        throws UnsupportedOperationException
2432    {
2433        this.getTarget().prepend(aValue);
2434        return (PRIMITIVE)this;
2435    }
2436
2437    @Override
2438    @SuppressWarnings( "unchecked" )
2439    public PRIMITIVE prepend( final long aValue )
2440        throws UnsupportedOperationException
2441    {
2442        this.getTarget().prepend(aValue);
2443        return (PRIMITIVE)this;
2444    }
2445
2446    @Override
2447    @SuppressWarnings( "unchecked" )
2448    public PRIMITIVE prepend( final Object aValue )
2449        throws UnsupportedOperationException
2450    {
2451        this.getTarget().prepend(aValue);
2452        return (PRIMITIVE)this;
2453    }
2454
2455    @Override
2456    @SuppressWarnings( "unchecked" )
2457    public PRIMITIVE product( final BigDecimal aValue )
2458        throws UnsupportedOperationException,
2459            IllegalArgumentException,
2460            ArithmeticException
2461    {
2462        this.getTarget().product(aValue);
2463        return (PRIMITIVE)this;
2464    }
2465
2466    @Override
2467    @SuppressWarnings( "unchecked" )
2468    public PRIMITIVE product( final BigInteger aValue )
2469        throws UnsupportedOperationException,
2470            IllegalArgumentException,
2471            ArithmeticException
2472    {
2473        this.getTarget().product(aValue);
2474        return (PRIMITIVE)this;
2475    }
2476
2477    @Override
2478    @SuppressWarnings( "unchecked" )
2479    public PRIMITIVE product( final boolean aValue )
2480        throws UnsupportedOperationException,
2481            IllegalArgumentException,
2482            ArithmeticException
2483    {
2484        this.getTarget().product(aValue);
2485        return (PRIMITIVE)this;
2486    }
2487
2488    @Override
2489    @SuppressWarnings( "unchecked" )
2490    public PRIMITIVE product( final byte aValue )
2491        throws UnsupportedOperationException,
2492            IllegalArgumentException,
2493            ArithmeticException
2494    {
2495        this.getTarget().product(aValue);
2496        return (PRIMITIVE)this;
2497    }
2498
2499    @Override
2500    @SuppressWarnings( "unchecked" )
2501    public PRIMITIVE product( final char aValue )
2502        throws UnsupportedOperationException,
2503            IllegalArgumentException,
2504            ArithmeticException
2505    {
2506        this.getTarget().product(aValue);
2507        return (PRIMITIVE)this;
2508    }
2509
2510    @Override
2511    @SuppressWarnings( "unchecked" )
2512    public PRIMITIVE product( final double aValue )
2513        throws UnsupportedOperationException,
2514            IllegalArgumentException,
2515            ArithmeticException
2516    {
2517        this.getTarget().product(aValue);
2518        return (PRIMITIVE)this;
2519    }
2520
2521    @Override
2522    @SuppressWarnings( "unchecked" )
2523    public PRIMITIVE product( final float aValue )
2524        throws UnsupportedOperationException,
2525            IllegalArgumentException,
2526            ArithmeticException
2527    {
2528        this.getTarget().product(aValue);
2529        return (PRIMITIVE)this;
2530    }
2531
2532    @Override
2533    @SuppressWarnings( "unchecked" )
2534    public PRIMITIVE product( final int aValue )
2535        throws UnsupportedOperationException,
2536            IllegalArgumentException,
2537            ArithmeticException
2538    {
2539        this.getTarget().product(aValue);
2540        return (PRIMITIVE)this;
2541    }
2542
2543    @Override
2544    @SuppressWarnings( "unchecked" )
2545    public PRIMITIVE product( final long aValue )
2546        throws UnsupportedOperationException,
2547            IllegalArgumentException,
2548            ArithmeticException
2549    {
2550        this.getTarget().product(aValue);
2551        return (PRIMITIVE)this;
2552    }
2553
2554    @Override
2555    @SuppressWarnings( "unchecked" )
2556    public PRIMITIVE product( final short aValue )
2557        throws UnsupportedOperationException,
2558            IllegalArgumentException,
2559            ArithmeticException
2560    {
2561        this.getTarget().product(aValue);
2562        return (PRIMITIVE)this;
2563    }
2564
2565    @Override
2566    @SuppressWarnings( "unchecked" )
2567    public PRIMITIVE promoteTo( final NumericPrecision prec )
2568    {
2569        this.getTarget().promoteTo(prec);
2570        return (PRIMITIVE)this;
2571    }
2572
2573    @Override
2574    @SuppressWarnings( "unchecked" )
2575    public PRIMITIVE quotient( final BigDecimal aValue )
2576        throws UnsupportedOperationException,
2577            IllegalArgumentException,
2578            ArithmeticException
2579    {
2580        this.getTarget().quotient(aValue);
2581        return (PRIMITIVE)this;
2582    }
2583
2584    @Override
2585    @SuppressWarnings( "unchecked" )
2586    public PRIMITIVE quotient( final BigInteger aValue )
2587        throws UnsupportedOperationException,
2588            IllegalArgumentException,
2589            ArithmeticException
2590    {
2591        this.getTarget().quotient(aValue);
2592        return (PRIMITIVE)this;
2593    }
2594
2595    @Override
2596    @SuppressWarnings( "unchecked" )
2597    public PRIMITIVE quotient( final boolean aValue )
2598        throws UnsupportedOperationException,
2599            IllegalArgumentException,
2600            ArithmeticException
2601    {
2602        this.getTarget().quotient(aValue);
2603        return (PRIMITIVE)this;
2604    }
2605
2606    @Override
2607    @SuppressWarnings( "unchecked" )
2608    public PRIMITIVE quotient( final byte aValue )
2609        throws UnsupportedOperationException,
2610            IllegalArgumentException,
2611            ArithmeticException
2612    {
2613        this.getTarget().quotient(aValue);
2614        return (PRIMITIVE)this;
2615    }
2616
2617    @Override
2618    @SuppressWarnings( "unchecked" )
2619    public PRIMITIVE quotient( final char aValue )
2620        throws UnsupportedOperationException,
2621            IllegalArgumentException,
2622            ArithmeticException
2623    {
2624        this.getTarget().quotient(aValue);
2625        return (PRIMITIVE)this;
2626    }
2627
2628    @Override
2629    @SuppressWarnings( "unchecked" )
2630    public PRIMITIVE quotient( final double aValue )
2631        throws UnsupportedOperationException,
2632            IllegalArgumentException,
2633            ArithmeticException
2634    {
2635        this.getTarget().quotient(aValue);
2636        return (PRIMITIVE)this;
2637    }
2638
2639    @Override
2640    @SuppressWarnings( "unchecked" )
2641    public PRIMITIVE quotient( final float aValue )
2642        throws UnsupportedOperationException,
2643            IllegalArgumentException,
2644            ArithmeticException
2645    {
2646        this.getTarget().quotient(aValue);
2647        return (PRIMITIVE)this;
2648    }
2649
2650    @Override
2651    @SuppressWarnings( "unchecked" )
2652    public PRIMITIVE quotient( final int aValue )
2653        throws UnsupportedOperationException,
2654            IllegalArgumentException,
2655            ArithmeticException
2656    {
2657        this.getTarget().quotient(aValue);
2658        return (PRIMITIVE)this;
2659    }
2660
2661    @Override
2662    @SuppressWarnings( "unchecked" )
2663    public PRIMITIVE quotient( final long aValue )
2664        throws UnsupportedOperationException,
2665            IllegalArgumentException,
2666            ArithmeticException
2667    {
2668        this.getTarget().quotient(aValue);
2669        return (PRIMITIVE)this;
2670    }
2671
2672    @Override
2673    @SuppressWarnings( "unchecked" )
2674    public PRIMITIVE quotient( final short aValue )
2675        throws UnsupportedOperationException,
2676            IllegalArgumentException,
2677            ArithmeticException
2678    {
2679        this.getTarget().quotient(aValue);
2680        return (PRIMITIVE)this;
2681    }
2682
2683    @Override
2684    @SuppressWarnings( "unchecked" )
2685    public PRIMITIVE radians()
2686        throws UnsupportedOperationException,
2687            IllegalArgumentException,
2688            ArithmeticException
2689    {
2690        this.getTarget().radians();
2691        return (PRIMITIVE)this;
2692    }
2693
2694    @Override
2695    @SuppressWarnings( "unchecked" )
2696    public PRIMITIVE random() throws UnsupportedOperationException
2697    {
2698        this.getTarget().random();
2699        return (PRIMITIVE)this;
2700    }
2701
2702    @Override
2703    @SuppressWarnings( "unchecked" )
2704    public PRIMITIVE replace(
2705        final CharSequence target,
2706        final CharSequence replacement )
2707    {
2708        this.getTarget().replace(target, replacement);
2709        return (PRIMITIVE)this;
2710    }
2711
2712    @Override
2713    @SuppressWarnings( "unchecked" )
2714    public PRIMITIVE replace( final int start, final int end, final String str )
2715        throws UnsupportedOperationException
2716    {
2717        this.getTarget().replace(start, end, str);
2718        return (PRIMITIVE)this;
2719    }
2720
2721    @Override
2722    @SuppressWarnings( "unchecked" )
2723    public PRIMITIVE replaceAll( final String regex, final String replacement )
2724    {
2725        this.getTarget().replaceAll(regex, replacement);
2726        return (PRIMITIVE)this;
2727    }
2728
2729    @Override
2730    @SuppressWarnings( "unchecked" )
2731    public PRIMITIVE replaceCharacter( final char oldChar, final char newChar )
2732    {
2733        this.getTarget().replaceCharacter(oldChar, newChar);
2734        return (PRIMITIVE)this;
2735    }
2736
2737    @Override
2738    @SuppressWarnings( "unchecked" )
2739    public PRIMITIVE replaceFirst( final String regex, final String replacement )
2740    {
2741        this.getTarget().replaceFirst(regex, replacement);
2742        return (PRIMITIVE)this;
2743    }
2744
2745    @Override
2746    @SuppressWarnings( "unchecked" )
2747    public PRIMITIVE reverse() throws UnsupportedOperationException
2748    {
2749        this.getTarget().reverse();
2750        return (PRIMITIVE)this;
2751    }
2752
2753    @Override
2754    @SuppressWarnings( "unchecked" )
2755    public PRIMITIVE round( final RoundingStrategy aRoundingStrategy )
2756        throws UnsupportedOperationException,
2757            IllegalArgumentException,
2758            ArithmeticException,
2759            NullPointerException
2760    {
2761        this.getTarget().round(aRoundingStrategy);
2762        return (PRIMITIVE)this;
2763    }
2764
2765    @Override
2766    @SuppressWarnings( "unchecked" )
2767    public PRIMITIVE setBoolean( final Boolean aValue )
2768        throws UnsupportedOperationException,
2769            IllegalArgumentException,
2770            ArithmeticException,
2771            NullPointerException
2772    {
2773        this.getTarget().setBoolean(aValue);
2774        return (PRIMITIVE)this;
2775    }
2776
2777    @Override
2778    @SuppressWarnings( "unchecked" )
2779    public PRIMITIVE setCharacter( final Character aValue )
2780        throws UnsupportedOperationException,
2781            IllegalArgumentException,
2782            ArithmeticException,
2783            NullPointerException
2784    {
2785        this.getTarget().setCharacter(aValue);
2786        return (PRIMITIVE)this;
2787    }
2788
2789    @Override
2790    @SuppressWarnings( "unchecked" )
2791    public PRIMITIVE setCharAt( final int index, final char ch )
2792        throws UnsupportedOperationException
2793    {
2794        this.getTarget().setCharAt(index, ch);
2795        return (PRIMITIVE)this;
2796    }
2797
2798    @Override
2799    @SuppressWarnings( "unchecked" )
2800    public PRIMITIVE setE()
2801        throws UnsupportedOperationException,
2802            IllegalArgumentException,
2803            ArithmeticException
2804    {
2805        this.getTarget().setE();
2806        return (PRIMITIVE)this;
2807    }
2808
2809    @Override
2810    @SuppressWarnings( "unchecked" )
2811    public <E extends Enum<E>> PRIMITIVE setEnumeration( final E aValue )
2812        throws UnsupportedOperationException,
2813            ArithmeticException,
2814            IllegalArgumentException,
2815            NullPointerException
2816    {
2817        this.getTarget().setEnumeration(aValue);
2818        return (PRIMITIVE)this;
2819    }
2820
2821    @Override
2822    @SuppressWarnings( "unchecked" )
2823    public PRIMITIVE setFalse()
2824        throws UnsupportedOperationException,
2825            ArithmeticException
2826    {
2827        this.getTarget().setFalse();
2828        return (PRIMITIVE)this;
2829    }
2830
2831    @Override
2832    @SuppressWarnings( "unchecked" )
2833    public PRIMITIVE setLength( final int newLength )
2834        throws UnsupportedOperationException
2835    {
2836        this.getTarget().setLength(newLength);
2837        return (PRIMITIVE)this;
2838    }
2839
2840    @Override
2841    @SuppressWarnings( "unchecked" )
2842    public PRIMITIVE setMaximum()
2843        throws UnsupportedOperationException,
2844            ArithmeticException,
2845            IllegalArgumentException
2846    {
2847        this.getTarget().setMaximum();
2848        return (PRIMITIVE)this;
2849    }
2850
2851    @Override
2852    @SuppressWarnings( "unchecked" )
2853    public PRIMITIVE setMinimum()
2854        throws UnsupportedOperationException,
2855            ArithmeticException,
2856            IllegalArgumentException
2857    {
2858        this.getTarget().setMinimum();
2859        return (PRIMITIVE)this;
2860    }
2861
2862    @Override
2863    @SuppressWarnings( "unchecked" )
2864    public PRIMITIVE setNegativeInfinity()
2865        throws UnsupportedOperationException,
2866            ArithmeticException,
2867            IllegalArgumentException
2868    {
2869        this.getTarget().setNegativeInfinity();
2870        return (PRIMITIVE)this;
2871    }
2872
2873    @Override
2874    @SuppressWarnings( "unchecked" )
2875    public PRIMITIVE setPi()
2876        throws UnsupportedOperationException,
2877            ArithmeticException,
2878            IllegalArgumentException
2879    {
2880        this.getTarget().setPi();
2881        return (PRIMITIVE)this;
2882    }
2883
2884    @Override
2885    @SuppressWarnings( "unchecked" )
2886    public PRIMITIVE setPositiveInfinity()
2887        throws UnsupportedOperationException,
2888            ArithmeticException,
2889            IllegalArgumentException
2890    {
2891        this.getTarget().setPositiveInfinity();
2892        return (PRIMITIVE)this;
2893    }
2894
2895    @Override
2896    @SuppressWarnings( "unchecked" )
2897    public final PRIMITIVE setPrimitive( final SealedPrimitive<?> aValue )
2898        throws UnsupportedOperationException,
2899            IllegalArgumentException,
2900            ArithmeticException,
2901            NullPointerException
2902    {
2903        this.getTarget().setPrimitive(aValue);
2904        return (PRIMITIVE)this;
2905    }
2906
2907    @Override
2908    @SuppressWarnings( "unchecked" )
2909    public PRIMITIVE setReal( final BigDecimal aValue )
2910        throws UnsupportedOperationException,
2911            IllegalArgumentException,
2912            ArithmeticException,
2913            NullPointerException
2914    {
2915        this.getTarget().setReal(aValue);
2916        return (PRIMITIVE)this;
2917    }
2918
2919    @Override
2920    @SuppressWarnings( "unchecked" )
2921    public PRIMITIVE setReal( final BigInteger aValue )
2922        throws UnsupportedOperationException,
2923            IllegalArgumentException,
2924            ArithmeticException,
2925            NullPointerException
2926    {
2927        this.getTarget().setReal(aValue);
2928        return (PRIMITIVE)this;
2929    }
2930
2931    @Override
2932    @SuppressWarnings( "unchecked" )
2933    public PRIMITIVE setScalar( final boolean aValue )
2934        throws UnsupportedOperationException,
2935            IllegalArgumentException,
2936            ArithmeticException
2937    {
2938        this.getTarget().setScalar(aValue);
2939        return (PRIMITIVE)this;
2940    }
2941
2942    @Override
2943    @SuppressWarnings( "unchecked" )
2944    public PRIMITIVE setScalar( final byte aValue )
2945        throws UnsupportedOperationException,
2946            IllegalArgumentException,
2947            ArithmeticException
2948    {
2949        this.getTarget().setScalar(aValue);
2950        return (PRIMITIVE)this;
2951    }
2952
2953    @Override
2954    @SuppressWarnings( "unchecked" )
2955    public PRIMITIVE setScalar( final char aValue )
2956        throws UnsupportedOperationException,
2957            IllegalArgumentException,
2958            ArithmeticException
2959    {
2960        this.getTarget().setScalar(aValue);
2961        return (PRIMITIVE)this;
2962    }
2963
2964    @Override
2965    @SuppressWarnings( "unchecked" )
2966    public PRIMITIVE setScalar( final double aValue )
2967        throws UnsupportedOperationException,
2968            IllegalArgumentException,
2969            ArithmeticException
2970    {
2971        this.getTarget().setScalar(aValue);
2972        return (PRIMITIVE)this;
2973    }
2974
2975    @Override
2976    @SuppressWarnings( "unchecked" )
2977    public PRIMITIVE setScalar( final float aValue )
2978        throws UnsupportedOperationException,
2979            IllegalArgumentException,
2980            ArithmeticException
2981    {
2982        this.getTarget().setScalar(aValue);
2983        return (PRIMITIVE)this;
2984    }
2985
2986    @Override
2987    @SuppressWarnings( "unchecked" )
2988    public PRIMITIVE setScalar( final int aValue )
2989        throws UnsupportedOperationException,
2990            IllegalArgumentException,
2991            ArithmeticException
2992    {
2993        this.getTarget().setScalar(aValue);
2994        return (PRIMITIVE)this;
2995    }
2996
2997    @Override
2998    @SuppressWarnings( "unchecked" )
2999    public PRIMITIVE setScalar( final long aValue )
3000        throws UnsupportedOperationException,
3001            IllegalArgumentException,
3002            ArithmeticException
3003    {
3004        this.getTarget().setScalar(aValue);
3005        return (PRIMITIVE)this;
3006    }
3007
3008    @Override
3009    @SuppressWarnings( "unchecked" )
3010    public PRIMITIVE setScalar( final SealedScalar<?> aValue )
3011        throws UnsupportedOperationException,
3012            IllegalArgumentException,
3013            ArithmeticException,
3014            NullPointerException
3015    {
3016        this.getTarget().setScalar(aValue);
3017        return (PRIMITIVE)this;
3018    }
3019
3020    @Override
3021    @SuppressWarnings( "unchecked" )
3022    public PRIMITIVE setScalar( final short aValue )
3023        throws UnsupportedOperationException,
3024            IllegalArgumentException,
3025            ArithmeticException
3026    {
3027        this.getTarget().setScalar(aValue);
3028        return (PRIMITIVE)this;
3029    }
3030
3031    @Override
3032    @SuppressWarnings( "unchecked" )
3033    public PRIMITIVE setText( final CharSequence content )
3034        throws UnsupportedOperationException,
3035            IllegalArgumentException,
3036            NullPointerException
3037    {
3038        this.getTarget().setText(content);
3039        return (PRIMITIVE)this;
3040    }
3041
3042    @Override
3043    @SuppressWarnings( "unchecked" )
3044    public PRIMITIVE setTrue()
3045        throws UnsupportedOperationException,
3046            ArithmeticException
3047    {
3048        this.getTarget().setTrue();
3049        return (PRIMITIVE)this;
3050    }
3051
3052    @Override
3053    @SuppressWarnings( "unchecked" )
3054    public PRIMITIVE setUnity()
3055        throws UnsupportedOperationException,
3056            IllegalArgumentException,
3057            ArithmeticException
3058    {
3059        this.getTarget().setUnity();
3060        return (PRIMITIVE)this;
3061    }
3062
3063    @Override
3064    @SuppressWarnings( "unchecked" )
3065    public PRIMITIVE setZero()
3066        throws UnsupportedOperationException,
3067            IllegalArgumentException,
3068            ArithmeticException
3069    {
3070        this.getTarget().setZero();
3071        return (PRIMITIVE)this;
3072    }
3073
3074    @Override
3075    @SuppressWarnings( "unchecked" )
3076    public PRIMITIVE shiftLeft( final int count )
3077        throws UnsupportedOperationException,
3078            IllegalArgumentException,
3079            ArithmeticException
3080    {
3081        this.getTarget().shiftLeft(count);
3082        return (PRIMITIVE)this;
3083    }
3084
3085    @Override
3086    @SuppressWarnings( "unchecked" )
3087    public PRIMITIVE shiftRight( final int count )
3088        throws UnsupportedOperationException,
3089            IllegalArgumentException,
3090            ArithmeticException
3091    {
3092        this.getTarget().shiftRight(count);
3093        return (PRIMITIVE)this;
3094    }
3095
3096    @Override
3097    @SuppressWarnings( "unchecked" )
3098    public PRIMITIVE shiftRightExtendZero( final int count )
3099        throws UnsupportedOperationException,
3100            IllegalArgumentException,
3101            ArithmeticException
3102    {
3103        this.getTarget().shiftRightExtendZero(count);
3104        return (PRIMITIVE)this;
3105    }
3106
3107    @Override
3108    public short shortPostDecrement()
3109        throws UnsupportedOperationException,
3110            ArithmeticException,
3111            IllegalArgumentException
3112    {
3113        return this.getTarget().shortPostDecrement();
3114    }
3115
3116    @Override
3117    public short shortPostIncrement()
3118        throws UnsupportedOperationException,
3119            ArithmeticException,
3120            IllegalArgumentException
3121    {
3122        return this.getTarget().shortPostIncrement();
3123    }
3124
3125    @Override
3126    public short shortValue()
3127    {
3128        return this.getTarget().shortValue();
3129    }
3130
3131    @Override
3132    public int signum()
3133    {
3134        return this.getTarget().signum();
3135    }
3136
3137    @Override
3138    @SuppressWarnings( "unchecked" )
3139    public PRIMITIVE sine()
3140        throws UnsupportedOperationException,
3141            IllegalArgumentException,
3142            ArithmeticException
3143    {
3144        this.getTarget().sine();
3145        return (PRIMITIVE)this;
3146    }
3147
3148    @Override
3149    public int size()
3150    {
3151        return this.getTarget().size();
3152    }
3153
3154    @Override
3155    @SuppressWarnings( "unchecked" )
3156    public PRIMITIVE square()
3157        throws UnsupportedOperationException,
3158            IllegalArgumentException,
3159            ArithmeticException
3160    {
3161        this.getTarget().square();
3162        return (PRIMITIVE)this;
3163    }
3164
3165    @Override
3166    @SuppressWarnings( "unchecked" )
3167    public PRIMITIVE squareRoot()
3168        throws UnsupportedOperationException,
3169            IllegalArgumentException,
3170            ArithmeticException
3171    {
3172        this.getTarget().squareRoot();
3173        return (PRIMITIVE)this;
3174    }
3175
3176    @Override
3177    public CharSequence subSequence( final int start, final int end )
3178    {
3179        return this.getTarget().subSequence(start, end);
3180    }
3181
3182    @Override
3183    public String substring( final int beginIndex )
3184        throws IndexOutOfBoundsException
3185    {
3186        return this.getTarget().substring(beginIndex);
3187    }
3188
3189    @Override
3190    public String substring( final int beginIndex, final int endIndex )
3191        throws IndexOutOfBoundsException
3192    {
3193        return this.getTarget().substring(beginIndex, endIndex);
3194    }
3195
3196    @Override
3197    @SuppressWarnings( "unchecked" )
3198    public PRIMITIVE sum( final BigDecimal aValue )
3199        throws UnsupportedOperationException,
3200            IllegalArgumentException,
3201            ArithmeticException
3202    {
3203        this.getTarget().sum(aValue);
3204        return (PRIMITIVE)this;
3205    }
3206
3207    @Override
3208    @SuppressWarnings( "unchecked" )
3209    public PRIMITIVE sum( final BigInteger aValue )
3210        throws UnsupportedOperationException,
3211            IllegalArgumentException,
3212            ArithmeticException
3213    {
3214        this.getTarget().sum(aValue);
3215        return (PRIMITIVE)this;
3216    }
3217
3218    @Override
3219    @SuppressWarnings( "unchecked" )
3220    public PRIMITIVE sum( final boolean aValue )
3221        throws UnsupportedOperationException,
3222            IllegalArgumentException,
3223            ArithmeticException
3224    {
3225        this.getTarget().sum(aValue);
3226        return (PRIMITIVE)this;
3227    }
3228
3229    @Override
3230    @SuppressWarnings( "unchecked" )
3231    public PRIMITIVE sum( final byte aValue )
3232        throws UnsupportedOperationException,
3233            IllegalArgumentException,
3234            ArithmeticException
3235    {
3236        this.getTarget().sum(aValue);
3237        return (PRIMITIVE)this;
3238    }
3239
3240    @Override
3241    @SuppressWarnings( "unchecked" )
3242    public PRIMITIVE sum( final char aValue )
3243        throws UnsupportedOperationException,
3244            IllegalArgumentException,
3245            ArithmeticException
3246    {
3247        this.getTarget().sum(aValue);
3248        return (PRIMITIVE)this;
3249    }
3250
3251    @Override
3252    @SuppressWarnings( "unchecked" )
3253    public PRIMITIVE sum( final double aValue )
3254        throws UnsupportedOperationException,
3255            IllegalArgumentException,
3256            ArithmeticException
3257    {
3258        this.getTarget().sum(aValue);
3259        return (PRIMITIVE)this;
3260    }
3261
3262    @Override
3263    @SuppressWarnings( "unchecked" )
3264    public PRIMITIVE sum( final float aValue )
3265        throws UnsupportedOperationException,
3266            IllegalArgumentException,
3267            ArithmeticException
3268    {
3269        this.getTarget().sum(aValue);
3270        return (PRIMITIVE)this;
3271    }
3272
3273    @Override
3274    @SuppressWarnings( "unchecked" )
3275    public PRIMITIVE sum( final int aValue )
3276        throws UnsupportedOperationException,
3277            IllegalArgumentException,
3278            ArithmeticException
3279    {
3280        this.getTarget().sum(aValue);
3281        return (PRIMITIVE)this;
3282    }
3283
3284    @Override
3285    @SuppressWarnings( "unchecked" )
3286    public PRIMITIVE sum( final long aValue )
3287        throws UnsupportedOperationException,
3288            IllegalArgumentException,
3289            ArithmeticException
3290    {
3291        this.getTarget().sum(aValue);
3292        return (PRIMITIVE)this;
3293    }
3294
3295    @Override
3296    @SuppressWarnings( "unchecked" )
3297    public PRIMITIVE sum( final short aValue )
3298        throws UnsupportedOperationException,
3299            IllegalArgumentException,
3300            ArithmeticException
3301    {
3302        this.getTarget().sum(aValue);
3303        return (PRIMITIVE)this;
3304    }
3305
3306    @Override
3307    @SuppressWarnings( "unchecked" )
3308    public PRIMITIVE swapPrimitives( final Primitive<?> aValue )
3309    {
3310        this.getTarget().swapPrimitives(aValue);
3311        return (PRIMITIVE)this;
3312    }
3313
3314    @Override
3315    @SuppressWarnings( "unchecked" )
3316    public PRIMITIVE tangent()
3317        throws UnsupportedOperationException,
3318            IllegalArgumentException,
3319            ArithmeticException
3320    {
3321        this.getTarget().tangent();
3322        return (PRIMITIVE)this;
3323    }
3324
3325    @Override
3326    public String textPostDecrement()
3327        throws UnsupportedOperationException,
3328            ArithmeticException,
3329            IllegalArgumentException
3330    {
3331        final String myValue = this.toString();
3332        this.decrement();
3333        return myValue;
3334    }
3335
3336    @Override
3337    public String textPostIncrement()
3338        throws UnsupportedOperationException,
3339            ArithmeticException,
3340            IllegalArgumentException
3341    {
3342        final String myValue = this.toString();
3343        this.increment();
3344        return myValue;
3345    }
3346
3347    @Override
3348    @SuppressWarnings( "unchecked" )
3349    public PRIMITIVE titleCase()
3350    {
3351        this.getTarget().titleCase();
3352        return (PRIMITIVE)this;
3353    }
3354
3355    @Override
3356    public Boolean toBoolean()
3357    {
3358        return this.getTarget().toBoolean();
3359    }
3360
3361    @Override
3362    public Character toCharacter()
3363    {
3364        return this.getTarget().toCharacter();
3365    }
3366
3367    @Override
3368    public int toCodePoint()
3369    {
3370        return this.getTarget().toCodePoint();
3371    }
3372
3373    @Override
3374    public <E extends Enum<E>> E toEnumeration(
3375        final Class<E> anEnumerationClass )
3376        throws ArithmeticException,
3377            IllegalArgumentException,
3378            NullPointerException
3379    {
3380        return this.getTarget().toEnumeration(anEnumerationClass);
3381    }
3382
3383    @Override
3384    public Number toNumber()
3385    {
3386        return this.getTarget().toNumber();
3387    }
3388
3389    @Override
3390    public Primitive<?> toPrimitive()
3391    {
3392        return this.getTarget().toPrimitive();
3393    }
3394
3395    @Override
3396    public Real<?> toReal()
3397    {
3398        return this.getTarget().toReal();
3399    }
3400
3401    @Override
3402    public Scalar<?> toScalar()
3403    {
3404        return this.getTarget().toScalar();
3405    }
3406
3407    @Override
3408    public String toString()
3409    {
3410        return this.getTarget().toString();
3411    }
3412
3413    @Override
3414    public BigDecimal toUnlimitedDecimal()
3415    {
3416        return this.getTarget().toUnlimitedDecimal();
3417    }
3418
3419    @Override
3420    public BigInteger toUnlimitedInteger()
3421    {
3422        return this.getTarget().toUnlimitedInteger();
3423    }
3424
3425    @Override
3426    @SuppressWarnings( "unchecked" )
3427    public PRIMITIVE trim()
3428    {
3429        this.getTarget().trim();
3430        return (PRIMITIVE)this;
3431    }
3432
3433    @Override
3434    public BigDecimal unlimitedDecimalPostDecrement()
3435        throws UnsupportedOperationException,
3436            ArithmeticException,
3437            IllegalArgumentException
3438    {
3439        return this.getTarget().unlimitedDecimalPostDecrement();
3440    }
3441
3442    @Override
3443    public BigDecimal unlimitedDecimalPostIncrement()
3444        throws UnsupportedOperationException,
3445            ArithmeticException,
3446            IllegalArgumentException
3447    {
3448        return this.getTarget().unlimitedDecimalPostIncrement();
3449    }
3450
3451    @Override
3452    public BigInteger unlimitedIntegerPostDecrement()
3453        throws UnsupportedOperationException,
3454            ArithmeticException,
3455            IllegalArgumentException
3456    {
3457        return this.getTarget().unlimitedIntegerPostDecrement();
3458    }
3459
3460    @Override
3461    public BigInteger unlimitedIntegerPostIncrement()
3462        throws UnsupportedOperationException,
3463            ArithmeticException,
3464            IllegalArgumentException
3465    {
3466        return this.getTarget().unlimitedIntegerPostIncrement();
3467    }
3468
3469    @Override
3470    @SuppressWarnings( "unchecked" )
3471    public PRIMITIVE upperCase()
3472    {
3473        this.getTarget().upperCase();
3474        return (PRIMITIVE)this;
3475    }
3476
3477    @Override
3478    @SuppressWarnings( "unchecked" )
3479    public PRIMITIVE xor( final BigInteger aValue )
3480        throws UnsupportedOperationException,
3481            IllegalArgumentException,
3482            ArithmeticException
3483    {
3484        this.getTarget().xor(aValue);
3485        return (PRIMITIVE)this;
3486    }
3487
3488    @Override
3489    @SuppressWarnings( "unchecked" )
3490    public PRIMITIVE xor( final boolean aValue )
3491        throws UnsupportedOperationException,
3492            IllegalArgumentException,
3493            ArithmeticException
3494    {
3495        this.getTarget().xor(aValue);
3496        return (PRIMITIVE)this;
3497    }
3498
3499    @Override
3500    @SuppressWarnings( "unchecked" )
3501    public PRIMITIVE xor( final byte aValue )
3502        throws UnsupportedOperationException,
3503            IllegalArgumentException,
3504            ArithmeticException
3505    {
3506        this.getTarget().xor(aValue);
3507        return (PRIMITIVE)this;
3508    }
3509
3510    @Override
3511    @SuppressWarnings( "unchecked" )
3512    public PRIMITIVE xor( final char aValue )
3513        throws UnsupportedOperationException,
3514            IllegalArgumentException,
3515            ArithmeticException
3516    {
3517        this.getTarget().xor(aValue);
3518        return (PRIMITIVE)this;
3519    }
3520
3521    @Override
3522    @SuppressWarnings( "unchecked" )
3523    public PRIMITIVE xor( final int aValue )
3524        throws UnsupportedOperationException,
3525            IllegalArgumentException,
3526            ArithmeticException
3527    {
3528        this.getTarget().xor(aValue);
3529        return (PRIMITIVE)this;
3530    }
3531
3532    @Override
3533    @SuppressWarnings( "unchecked" )
3534    public PRIMITIVE xor( final long aValue )
3535        throws UnsupportedOperationException,
3536            IllegalArgumentException,
3537            ArithmeticException
3538    {
3539        this.getTarget().xor(aValue);
3540        return (PRIMITIVE)this;
3541    }
3542
3543    @Override
3544    @SuppressWarnings( "unchecked" )
3545    public PRIMITIVE xor( final short aValue )
3546        throws UnsupportedOperationException,
3547            IllegalArgumentException,
3548            ArithmeticException
3549    {
3550        this.getTarget().xor(aValue);
3551        return (PRIMITIVE)this;
3552    }
3553}