/**
 * Variant.java
 * 
 * Copyright (c) 2004-2012, Nicole C. Tedesco. All rights reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at:
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package net.sf.jaccumulator.primitives;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.EnumMap;
import java.util.Map;

import net.sf.jaccumulator.ControlIntention;
import net.sf.jaccumulator.Domain;
import net.sf.jaccumulator.booleans.BooleanPrimitive;
import net.sf.jaccumulator.bytes.BytePrimitive;
import net.sf.jaccumulator.characters.CharacterPrimitive;
import net.sf.jaccumulator.doubles.DoublePrimitive;
import net.sf.jaccumulator.floats.FloatPrimitive;
import net.sf.jaccumulator.integers.EnumerationPrimitive;
import net.sf.jaccumulator.integers.IntegerPrimitive;
import net.sf.jaccumulator.integers.ModuloIntegerPrimitive;
import net.sf.jaccumulator.lex.PrimitiveAction;
import net.sf.jaccumulator.lex.To;
import net.sf.jaccumulator.longs.LongPrimitive;
import net.sf.jaccumulator.reals.SealedReal;
import net.sf.jaccumulator.scalars.NumericPrecision;
import net.sf.jaccumulator.scalars.RoundingStrategy;
import net.sf.jaccumulator.scalars.SealedScalar;
import net.sf.jaccumulator.shorts.ShortPrimitive;
import net.sf.jaccumulator.texts.TextPrimitive;
import net.sf.jaccumulator.unlimiteds.UnlimitedDecimalPrimitive;
import net.sf.jaccumulator.unlimiteds.UnlimitedIntegerPrimitive;

/**
 * An {@link Primitive primitive} that adjusts its numeric
 * {@link NumericPrecision precision}, and hence its implementation, based on
 * the precision of function arguments
 * 
 * @since JAccumulator 4.0
 * @author Nicole Tedesco (<a
 *         href="mailto:Nicole@NicoleTedesco.com">Nicole@NicoleTedesco.com</a>)
 */
public final class Variant
    extends
        AbstractPrimitiveWrapper<Variant>
{
    private final static Map<NumericPrecision,Promoter> _thePromoters = new EnumMap<NumericPrecision,Promoter>(
        NumericPrecision.class);

    private static final long serialVersionUID = 5567792842256304953L;
    static {
        _thePromoters.put(NumericPrecision.UNKNOWN, new StringPromoter());
        _thePromoters.put(NumericPrecision.NULL, new NullPromoter());
        _thePromoters.put(NumericPrecision.BIT, new BooleanPromoter());
        _thePromoters.put(NumericPrecision.BYTE, new BytePromoter());
        _thePromoters.put(NumericPrecision.SHORT, new ShortPromoter());
        _thePromoters.put(NumericPrecision.CHARACTER, new CharacterPromoter());
        _thePromoters.put(NumericPrecision.INTEGER, new IntegerPromoter());
        _thePromoters.put(NumericPrecision.LONG, new LongPromoter());
        _thePromoters.put(NumericPrecision.FLOAT, new FloatPromoter());
        _thePromoters.put(NumericPrecision.DOUBLE, new DoublePromoter());
        _thePromoters.put(NumericPrecision.UNLIMITED_INTEGER,
            new UnlimitedIntegerPromoter());
        _thePromoters.put(NumericPrecision.UNLIMITED_DECIMAL,
            new UnlimitedDecimalPromoter());
    };

    private final Factory[] _theFactories = { Creator.INSTANCE,
            Creator.INSTANCE, Creator.INSTANCE, Creator.INSTANCE,
            Creator.INSTANCE, Creator.INSTANCE, Creator.INSTANCE,
            Creator.INSTANCE, Creator.INSTANCE, Creator.INSTANCE,
            Creator.INSTANCE, Creator.INSTANCE, };

    private Promoter _thePromoter;
    private final PrimitiveAction<Primitive<?>> _theRealTranslator;
    private Primitive<?> _theTarget;
    private final Primitive<?>[] _theTargets = new Primitive<?>[NumericPrecision.values().length];

    public Variant( final BigDecimal aValue )
    {
        this(new UnlimitedDecimalPrimitive(aValue));
    }

    public Variant( final BigInteger aValue )
    {
        this(new UnlimitedIntegerPrimitive(aValue));
    }

    public Variant( final boolean aValue )
    {
        this(new BooleanPrimitive(aValue));
    }

    public Variant( final byte aValue )
    {
        this(new BytePrimitive(aValue));
    }

    public Variant( final char aValue )
    {
        this(new CharacterPrimitive(aValue));
    }

    public Variant( final double aValue )
    {
        this(new DoublePrimitive(aValue));
    }

    public <E extends Enum<E>> Variant( final E aValue )
    {
        this(new EnumerationPrimitive(aValue));
    }

    public Variant( final float aValue )
    {
        this(new FloatPrimitive(aValue));
    }

    public Variant( final int aValue )
    {
        this(new IntegerPrimitive(aValue));
    }

    public Variant( final long aValue )
    {
        this(new LongPrimitive(aValue));
    }

    public Variant( final Primitive<?>... targets )
    {
        this(To.REAL, targets);
    }

    public Variant(
        final PrimitiveAction<Primitive<?>> aRealTranslator,
        final Primitive<?>... targets )
    {
        this._theRealTranslator = aRealTranslator;
        for (final Primitive<?> aTarget : targets) {
            final NumericPrecision prec = aTarget.getPrecision();
            final int index = prec.ordinal();
            this._theTargets[index] = aTarget;
            this._theFactories[index] = Getter.INSTANCE;
        }
        if (0 < targets.length) {
            this.setTarget(targets[0]);
            final NumericPrecision prec = this.getTarget().getPrecision();
            this._thePromoter = _thePromoters.get(prec);
        } else {
            this.setTarget(this._theTargets[NumericPrecision.DOUBLE.ordinal()] = toPrimitive(NumericPrecision.DOUBLE));
            this._thePromoter = _thePromoters.get(NumericPrecision.DOUBLE);
        }
    }

    public Variant( final short aValue )
    {
        this(new ShortPrimitive(aValue));
    }

    public Variant( final String aValue )
    {
        this(new TextPrimitive(aValue));
    }

    private final boolean hasModulo()
    {
        if (this._theFactories[NumericPrecision.INTEGER.ordinal()] instanceof Getter) {
            final Factory aFactory = this._theFactories[NumericPrecision.INTEGER.ordinal()];
            final Primitive<?> anInteger = aFactory.get(this,
                NumericPrecision.INTEGER);
            final Domain aDomain = anInteger.getDomain();
            return aDomain == Domain.MODULO;
        }
        return false;
    }

    private final Primitive<?> setPrecision( final NumericPrecision prec )
    {
        this._thePromoter = _thePromoters.get(prec);
        return this.setTarget(this._theFactories[prec.ordinal()].get(this, prec));
    }

    private final Primitive<?> setTarget( final Primitive<?> aTarget )
    {
        return this._theTarget = aTarget;
    }

    @Override
    public final Variant absoluteValue() throws UnsupportedOperationException
    {
        if (this.getDomain() == Domain.TEXT) {
            final ControlIntention ci = this.getRealTranslator().reactToText(
                this.toString(), this);
            if (ci == ControlIntention.REJECT) {
                this.assertPrecision(NumericPrecision.INTEGER);
            }
        }
        this.getTarget().absoluteValue();
        return this;
    }

    @Override
    public final Variant and( final BigInteger aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
        this.getTarget().and(aValue);
        return this;
    }

    @Override
    public final Variant and( final boolean aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().and(aValue);
        return this;
    }

    @Override
    public final Variant and( final byte aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().and(aValue);
        return this;
    }

    @Override
    public final Variant and( final char aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().and(aValue);
        return this;
    }

    @Override
    public final Variant and( final int aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.INTEGER);
        this.getTarget().and(aValue);
        return this;
    }

    @Override
    public final Variant and( final long aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.LONG);
        this.getTarget().and(aValue);
        return this;
    }

    @Override
    public final Variant and( final short aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.SHORT);
        this.getTarget().and(aValue);
        return this;
    }

    @Override
    public final Variant angleWith( final double aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().angleWith(aValue);
        return this;
    }

    @Override
    public final Variant append( final boolean aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(aValue);
        return this;
    }

    @Override
    public final Variant append( final char c )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(c);
        return this;
    }

    @Override
    public final Variant append( final char[] content )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(content);
        return this;
    }

    @Override
    public final Variant append( final char[] content, final int contentIndex )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(content, contentIndex);
        return this;
    }

    @Override
    public final Variant append(
        final char[] content,
        final int contentIndex,
        final int contentLength ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(content, contentIndex,
            contentLength);
        return this;
    }

    @Override
    public final Variant append( final CharSequence s )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(s);
        return this;
    }

    @Override
    public final Variant append(
        final CharSequence content,
        final int contentStartIndex ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(content, contentStartIndex);
        return this;
    }

    @Override
    public final Variant append(
        final CharSequence s,
        final int start,
        final int end ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(s, start, end);
        return this;
    }

    @Override
    public final Variant append( final double aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(aValue);
        return this;
    }

    @Override
    public final Variant append( final float aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(aValue);
        return this;
    }

    @Override
    public final Variant append( final int aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(aValue);
        return this;
    }

    @Override
    public final Variant append( final long aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(aValue);
        return this;
    }

    @Override
    public final Variant append( final Object aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(aValue);
        return this;
    }

    @Override
    public final Variant append( final StringBuffer sb )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).append(sb);
        return this;
    }

    @Override
    public final Variant appendCodePoint( final int codePoint )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).appendCodePoint(codePoint);
        return this;
    }

    @Override
    public final Variant arcCosine()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().arcCosine();
        return this;
    }

    @Override
    public final Variant arcSine()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().arcSine();
        return this;
    }

    @Override
    public final Variant arcTangent()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().arcTangent();
        return this;
    }

    @Override
    public final Variant assertDomain( final Domain aDomain )
    {
        final Domain myDomain = this.getDomain();
        if (myDomain == aDomain) return this;
        final NumericPrecision myPrecision = this.getPrecision();
        switch (aDomain) {
        case EMPTY:
            if (myPrecision != NumericPrecision.NULL)
                return this.assertPrecision(NumericPrecision.NULL);
            break;
        case MODULO:
            if (this.hasModulo()) {
                this.assertPrecision(NumericPrecision.INTEGER);
            } else {
                final Primitive<?> aModulo = new ModuloIntegerPrimitive(
                    this.intValue(), this.intValue());
                this._theTargets[NumericPrecision.INTEGER.ordinal()] = aModulo;
                this._thePromoter = _thePromoters.get(NumericPrecision.INTEGER);
                this._theFactories[NumericPrecision.INTEGER.ordinal()] = Getter.INSTANCE;
                this.setTarget(aModulo);
            }
            break;
        case COMPLEX:
        case IMAGINARY:
        case REAL:
            switch (myDomain) {
            case REAL:
            case MODULO:
                break;
            default:
                if (!myPrecision.isNumeric()) {
                    final ControlIntention ci = this.getRealTranslator().reactToText(
                        this.toString(), this);
                    if (ci == ControlIntention.REJECT) {
                        this.assertPrecision(NumericPrecision.INTEGER);
                    }
                }
                break;
            }
            break;
        default:
            if (myPrecision != NumericPrecision.UNKNOWN)
                return this.assertPrecision(NumericPrecision.UNKNOWN);
            break;
        }
        return this;
    }

    @Override
    public final Variant assertPrecision( final NumericPrecision prec )
    {
        if (this.getPrecision() != prec) {
            final Primitive<?> accOld = this.getTarget();
            this.setPrecision(prec);
            final Primitive<?> accNew = this.getTarget();
            if (accOld != accNew) {
                if (accNew.isMutable()) {
                    accNew.setPrimitive(accOld);
                }
            }
        }
        return this;
    }

    @Override
    public final Variant base10Log()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().base10Log();
        return this;
    }

    @Override
    public final Variant copy()
    {
        final Primitive<?> aTarget = this._theTarget;
        if (aTarget == null) return new Variant();
        return new Variant(aTarget.copy());
    }

    @Override
    public final Variant copyUsing( final BigDecimal aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsing( final BigInteger aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsing( final boolean aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsing( final byte aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsing( final char aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsing( final double aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsing( final float aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsing( final int aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsing( final long aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsing( final short aValue )
    {
        return new Variant(aValue);
    }

    @Override
    public final Variant copyUsingPrimitive( final SealedPrimitive<?> aValue )
    {
        return valueOfPrimitive(aValue);
    }

    @Override
    public final Variant copyUsingReal( final SealedReal<?> aValue )
    {
        return valueOfReal(aValue);
    }

    @Override
    public final Variant copyUsingScalar( final SealedScalar<?> aValue )
    {
        return valueOfScalar(aValue);
    }

    @Override
    public final Variant copyUsingText( final CharSequence aValue )
    {
        return new Variant(aValue.toString());
    }

    @Override
    public final Variant cosine()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().cosine();
        return this;
    }

    @Override
    public final Variant cube()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertDomain(Domain.REAL);
        this.getTarget().cube();
        return this;
    }

    @Override
    public final Variant cubeRoot()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().cubeRoot();
        return this;
    }

    @Override
    public final Variant decrement()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertDomain(Domain.REAL);
        this.getTarget().decrement();
        return this;
    }

    @Override
    public final Variant degrees()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().degrees();
        return this;
    }

    @Override
    public final Variant delete( final int start, final int end )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).delete(start, end);
        return this;
    }

    @Override
    public final Variant deleteCharAt( final int anIndex )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).deleteCharAt(anIndex);
        return this;
    }

    @Override
    public final Variant difference( final BigDecimal aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_DECIMAL);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant difference( final BigInteger aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant difference( final boolean aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant difference( final byte aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant difference( final char aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant difference( final double aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant difference( final float aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.FLOAT);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant difference( final int aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.INTEGER);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant difference( final long aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.LONG);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant difference( final short aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.SHORT);
        this.getTarget().difference(aValue);
        return this;
    }

    @Override
    public final Variant exponential()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().exponential();
        return this;
    }

    @Override
    public final Variant exponentialLessOne()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().exponentialLessOne();
        return this;
    }

    @Override
    public final Variant gcd( final BigInteger aValue )
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
        this.getTarget().gcd(aValue);
        return this;
    }

    @Override
    public final Variant gcd( final byte aValue )
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().gcd(aValue);
        return this;
    }

    @Override
    public final Variant gcd( final char aValue )
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().gcd(aValue);
        return this;
    }

    @Override
    public final Variant gcd( final int aValue )
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertPrecision(NumericPrecision.INTEGER);
        this.getTarget().gcd(aValue);
        return this;
    }

    @Override
    public final Variant gcd( final long aValue )
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertPrecision(NumericPrecision.LONG);
        this.getTarget().gcd(aValue);
        return this;
    }

    @Override
    public final Variant gcd( final short aValue )
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertPrecision(NumericPrecision.SHORT);
        this.getTarget().gcd(aValue);
        return this;
    }

    public final PrimitiveAction<Primitive<?>> getRealTranslator()
    {
        return this._theRealTranslator;
    }

    @Override
    public final Primitive<?> getTarget()
    {
        return this._theTarget;
    }

    @Override
    public final Variant hyperbolicCosine()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().hyperbolicCosine();
        return this;
    }

    @Override
    public final Variant hyperbolicSine()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().hyperbolicSine();
        return this;
    }

    @Override
    public final Variant hyperbolicTangent()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().hyperbolicTangent();
        return this;
    }

    @Override
    public final Variant increment()
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertDomain(Domain.REAL);
        this.getTarget().increment();
        return this;
    }

    @Override
    public final Variant insert( final int anIndex, final boolean aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(anIndex, aValue);
        return this;
    }

    @Override
    public final Variant insert( final int anIndex, final char aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(anIndex, aValue);
        return this;
    }

    @Override
    public final Variant insert( final int anIndex, final char[] content )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(anIndex, content);
        return this;
    }

    @Override
    public final Variant insert(
        final int targetIndex,
        final char[] content,
        final int contentIndex,
        final int contentLength ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(targetIndex, content,
            contentIndex, contentLength);
        return this;
    }

    @Override
    public final Variant insert( final int anIndex, final CharSequence content )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(anIndex, content);
        return this;
    }

    @Override
    public final Variant insert(
        final int targetIndex,
        final CharSequence content,
        final int contentIndex ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(targetIndex, content,
            contentIndex);
        return this;
    }

    @Override
    public final Variant insert(
        final int targetIndex,
        final CharSequence content,
        final int contentStartIndex,
        final int contentEndIndexPlusOne ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(targetIndex, content,
            contentStartIndex, contentEndIndexPlusOne);
        return this;
    }

    @Override
    public final Variant insert( final int anIndex, final double aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(anIndex, aValue);
        return this;
    }

    @Override
    public final Variant insert( final int anIndex, final float aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(anIndex, aValue);
        return this;
    }

    @Override
    public final Variant insert( final int anIndex, final int aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(anIndex, aValue);
        return this;
    }

    @Override
    public final Variant insert( final int anIndex, final long aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(anIndex, aValue);
        return this;
    }

    @Override
    public final Variant insert( final int anIndex, final Object aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).insert(anIndex, aValue);
        return this;
    }

    @Override
    public final Variant invalidate() throws UnsupportedOperationException
    {
        this.setPrecision(NumericPrecision.NULL);
        return this;
    }

    @Override
    public final Variant inverse() throws UnsupportedOperationException
    {
        this.assertPrecision(this.getPrecision().toFloatingPoint());
        this.getTarget().inverse();
        return this;
    }

    @Override
    public boolean isConfigurable()
    {
        return true;
    }

    @Override
    public final Variant lowerCase() throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).lowerCase();
        return this;
    }

    @Override
    public final Variant mod( final BigDecimal aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_DECIMAL);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant mod( final BigInteger aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant mod( final boolean aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant mod( final byte aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant mod( final char aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant mod( final double aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant mod( final float aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.FLOAT);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant mod( final int aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.INTEGER);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant mod( final long aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.LONG);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant mod( final short aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.SHORT);
        this.getTarget().mod(aValue);
        return this;
    }

    @Override
    public final Variant naturalLog()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().naturalLog();
        return this;
    }

    @Override
    public final Variant naturalLogPlusOne()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().naturalLogPlusOne();
        return this;
    }

    @Override
    public final Variant negate() throws UnsupportedOperationException
    {
        this.assertDomain(Domain.REAL);
        switch (this.getPrecision()) {
        case CHARACTER:
            this.assertPrecision(NumericPrecision.INTEGER);
        default:
            this.getTarget().negate();
            break;
        }
        return this;
    }

    @Override
    public final Variant not() throws UnsupportedOperationException
    {
        if (this.getDomain() == Domain.TEXT) {
            this.getRealTranslator().reactToText(this.toString(), this);
            final ControlIntention ci = this.getRealTranslator().reactToText(
                this.toString(), this);
            if (ci == ControlIntention.REJECT) {
                this.assertPrecision(NumericPrecision.INTEGER);
            }
        }
        switch (this.getPrecision()) {
        case NULL:
            this.assertPrecision(NumericPrecision.INTEGER);
            break;
        case FLOAT:
        case DOUBLE:
            this.assertPrecision(NumericPrecision.LONG);
            break;
        case UNLIMITED_DECIMAL:
            this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
            break;
        }
        this.getTarget().not();
        return this;
    }

    @Override
    public final Variant or( final BigInteger aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
        this.getTarget().or(aValue);
        return this;
    }

    @Override
    public final Variant or( final boolean aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().or(aValue);
        return this;
    }

    @Override
    public final Variant or( final byte aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().or(aValue);
        return this;
    }

    @Override
    public final Variant or( final char aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().or(aValue);
        return this;
    }

    @Override
    public final Variant or( final int aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.INTEGER);
        this.getTarget().or(aValue);
        return this;
    }

    @Override
    public final Variant or( final long aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.LONG);
        this.getTarget().or(aValue);
        return this;
    }

    @Override
    public final Variant or( final short aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.SHORT);
        this.getTarget().or(aValue);
        return this;
    }

    @Override
    public final Variant power( final double n )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertDomain(Domain.REAL);
        this.getTarget().power(n);
        return this;
    }

    @Override
    public final Variant power( final int n )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertDomain(Domain.REAL);
        this.getTarget().power(n);
        return this;
    }

    @Override
    public final Variant prepend( final boolean aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(aValue);
        return this;
    }

    @Override
    public final Variant prepend( final char aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(aValue);
        return this;
    }

    @Override
    public final Variant prepend( final char[] content )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(content);
        return this;
    }

    @Override
    public final Variant prepend( final char[] content, final int contentIndex )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(content, contentIndex);
        return this;
    }

    @Override
    public final Variant prepend(
        final char[] content,
        final int contentIndex,
        final int contentLength ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(content, contentIndex,
            contentLength);
        return this;
    }

    @Override
    public final Variant prepend( final CharSequence content )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(content);
        return this;
    }

    @Override
    public final Variant prepend(
        final CharSequence content,
        final int contentIndex ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(content, contentIndex);
        return this;
    }

    @Override
    public final Variant prepend(
        final CharSequence content,
        final int contentStartIndex,
        final int contentEndIndexPlusOne ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(content, contentStartIndex,
            contentEndIndexPlusOne);
        return this;
    }

    @Override
    public final Variant prepend( final double aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(aValue);
        return this;
    }

    @Override
    public final Variant prepend( final float aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(aValue);
        return this;
    }

    @Override
    public final Variant prepend( final int aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(aValue);
        return this;
    }

    @Override
    public final Variant prepend( final long aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(aValue);
        return this;
    }

    @Override
    public final Variant prepend( final Object aValue )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).prepend(aValue);
        return this;
    }

    @Override
    public final Variant product( final BigDecimal aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_DECIMAL);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant product( final BigInteger aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant product( final boolean aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant product( final byte aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant product( final char aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant product( final double aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant product( final float aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.FLOAT);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant product( final int aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.INTEGER);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant product( final long aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.LONG);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant product( final short aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.SHORT);
        this.getTarget().product(aValue);
        return this;
    }

    @Override
    public final Variant promoteTo( final NumericPrecision prec )
    {
        switch (prec) {
        case BIT:
            this._thePromoter.asBoolean(this);
            break;
        case BYTE:
            this._thePromoter.asByte(this);
            break;
        case SHORT:
            this._thePromoter.asShort(this);
            break;
        case CHARACTER:
            this._thePromoter.asCharacter(this);
            break;
        case INTEGER:
            this._thePromoter.asInteger(this);
            break;
        case LONG:
            this._thePromoter.asLong(this);
            break;
        case FLOAT:
            this._thePromoter.asFloat(this);
            break;
        case DOUBLE:
            this._thePromoter.asDouble(this);
            break;
        case UNLIMITED_INTEGER:
            this._thePromoter.asUnlimitedInteger(this);
            break;
        case UNLIMITED_DECIMAL:
            this._thePromoter.asUnlimitedDecimal(this);
            break;
        }
        return this;
    }

    @Override
    public final Variant quotient( final BigDecimal aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_DECIMAL);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant quotient( final BigInteger aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant quotient( final boolean aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant quotient( final byte aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant quotient( final char aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant quotient( final double aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant quotient( final float aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.FLOAT);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant quotient( final int aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.INTEGER);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant quotient( final long aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.LONG);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant quotient( final short aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.SHORT);
        this.getTarget().quotient(aValue);
        return this;
    }

    @Override
    public final Variant radians()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().radians();
        return this;
    }

    @Override
    public final Variant replace(
        final CharSequence target,
        final CharSequence replacement )
    {
        this._thePromoter.asString(this).replace(target, replacement);
        return this;
    }

    @Override
    public final Variant replace(
        final int start,
        final int end,
        final String str ) throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).replace(start, end, str);
        return this;
    }

    @Override
    public final Variant replaceAll(
        final String regex,
        final String replacement )
    {
        this._thePromoter.asString(this).replaceAll(regex, replacement);
        return this;
    }

    @Override
    public final Variant replaceCharacter(
        final char oldChar,
        final char newChar )
    {
        this._thePromoter.asString(this).replaceCharacter(oldChar, newChar);
        return this;
    }

    @Override
    public final Variant replaceFirst(
        final String regex,
        final String replacement )
    {
        this._thePromoter.asString(this).replaceFirst(regex, replacement);
        return this;
    }

    @Override
    public final Variant reverse() throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).reverse();
        return this;
    }

    @Override
    public final Variant round( final RoundingStrategy aRoundingStrategy )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException,
            NullPointerException
    {
        this.assertDomain(Domain.REAL);
        this.getTarget().round(aRoundingStrategy);
        return this;
    }

    @Override
    public final Variant setBoolean( final Boolean aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException,
            NullPointerException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().setBoolean(aValue);
        return this;
    }

    @Override
    public final Variant setCharacter( final Character aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException,
            NullPointerException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().setCharacter(aValue);
        return this;
    }

    @Override
    public final Variant setCharAt( final int index, final char ch )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).setCharAt(index, ch);
        return this;
    }

    @Override
    public final Variant setE()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().setE();
        return this;
    }

    @Override
    public <E extends Enum<E>> Variant setEnumeration( final E aValue )
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException,
            NullPointerException
    {
        if (!this.hasModulo()) {
            final Primitive<?> anEnumeration = new EnumerationPrimitive(aValue);
            this._theTargets[NumericPrecision.INTEGER.ordinal()] = anEnumeration;
            this._thePromoter = _thePromoters.get(NumericPrecision.INTEGER);
            this._theFactories[NumericPrecision.INTEGER.ordinal()] = Getter.INSTANCE;
            this.setTarget(anEnumeration);
        } else {
            this.assertPrecision(NumericPrecision.INTEGER);
            this.getTarget().setEnumeration(aValue);
        }
        return this;
    }

    @Override
    public final Variant setFalse()
        throws UnsupportedOperationException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().setFalse();
        return this;
    }

    @Override
    public final Variant setLength( final int newLength )
        throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).setLength(newLength);
        return this;
    }

    @Override
    public final Variant setMaximum()
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertDomain(Domain.REAL);
        this.getTarget().setMaximum();
        return this;
    }

    @Override
    public final Variant setMinimum()
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertDomain(Domain.REAL);
        this.getTarget().setMinimum();
        return this;
    }

    @Override
    public final Variant setNegativeInfinity()
        throws UnsupportedOperationException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().setNegativeInfinity();
        return this;
    }

    @Override
    public final Variant setPi()
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().setPi();
        return this;
    }

    @Override
    public final Variant setPositiveInfinity()
        throws UnsupportedOperationException,
            ArithmeticException,
            IllegalArgumentException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().setPositiveInfinity();
        return this;
    }

    @Override
    public final Variant setReal( final BigDecimal aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException,
            NullPointerException
    {
        this.setPrecision(NumericPrecision.UNLIMITED_DECIMAL).setReal(aValue);
        return this;
    }

    @Override
    public final Variant setReal( final BigInteger aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException,
            NullPointerException
    {
        this.setPrecision(NumericPrecision.UNLIMITED_INTEGER).setReal(aValue);
        return this;
    }

    @Override
    public final Variant setReal( final SealedReal<?> aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException,
            NullPointerException
    {
        this.assertPrecision(this.getPrecision().maximumOf(
            aValue.getPrecision()));
        this.getTarget().setReal(aValue);
        return this;
    }

    @Override
    public final Variant setScalar( final boolean aValue )
        throws UnsupportedOperationException
    {
        this.setPrecision(NumericPrecision.BIT).setScalar(aValue);
        return this;
    }

    @Override
    public final Variant setScalar( final byte aValue )
        throws UnsupportedOperationException
    {
        this.setPrecision(NumericPrecision.BYTE).setScalar(aValue);
        return this;
    }

    @Override
    public final Variant setScalar( final char aValue )
        throws UnsupportedOperationException
    {
        this.setPrecision(NumericPrecision.CHARACTER).setScalar(aValue);
        return this;
    }

    @Override
    public final Variant setScalar( final double aValue )
        throws UnsupportedOperationException
    {
        this.setPrecision(NumericPrecision.DOUBLE).setScalar(aValue);
        return this;
    }

    @Override
    public final Variant setScalar( final float aValue )
        throws UnsupportedOperationException
    {
        this.setPrecision(NumericPrecision.FLOAT).setScalar(aValue);
        return this;
    }

    @Override
    public final Variant setScalar( final int aValue )
        throws UnsupportedOperationException
    {
        this.setPrecision(NumericPrecision.INTEGER).setScalar(aValue);
        return this;
    }

    @Override
    public final Variant setScalar( final long aValue )
        throws UnsupportedOperationException
    {
        this.setPrecision(NumericPrecision.LONG).setScalar(aValue);
        return this;
    }

    @Override
    public final Variant setScalar( final SealedScalar<?> aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException,
            NullPointerException
    {
        this.assertPrecision(this.getPrecision().maximumOf(
            aValue.getPrecision()));
        this.getTarget().setScalar(aValue);
        return this;
    }

    @Override
    public final Variant setScalar( final short aValue )
        throws UnsupportedOperationException
    {
        this.setPrecision(NumericPrecision.SHORT).setScalar(aValue);
        return this;
    }

    @Override
    public final Variant setText( final CharSequence content )
        throws UnsupportedOperationException,
            NullPointerException,
            IllegalArgumentException
    {
        this._thePromoter.asString(this).setText(content);
        return this;
    }

    @Override
    public final Variant setTrue()
        throws UnsupportedOperationException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().setTrue();
        return this;
    }

    @Override
    public final Variant setUnity()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().setUnity();
        return this;
    }

    @Override
    public final Variant setZero()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().setZero();
        return this;
    }

    @Override
    public final Variant shiftLeft( final int count )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().shiftLeft(count);
        return this;
    }

    @Override
    public final Variant shiftRight( final int count )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().shiftRight(count);
        return this;
    }

    @Override
    public final Variant shiftRightExtendZero( final int count )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().shiftRightExtendZero(count);
        return this;
    }

    @Override
    public final Variant sine()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().sine();
        return this;
    }

    @Override
    public final Variant square()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertDomain(Domain.REAL);
        this.getTarget().square();
        return this;
    }

    @Override
    public final Variant squareRoot()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().squareRoot();
        return this;
    }

    @Override
    public final CharSequence subSequence( final int start, final int end )
    {
        return this._thePromoter.asString(this).subSequence(start, end);
    }

    @Override
    public final String substring( final int beginIndex )
        throws IndexOutOfBoundsException
    {
        return this._thePromoter.asString(this).substring(beginIndex);
    }

    @Override
    public final String substring( final int beginIndex, final int endIndex )
        throws IndexOutOfBoundsException
    {
        return this._thePromoter.asString(this).substring(beginIndex, endIndex);
    }

    @Override
    public final Variant sum( final BigDecimal aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_DECIMAL);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant sum( final BigInteger aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant sum( final boolean aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant sum( final byte aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant sum( final char aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant sum( final double aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant sum( final float aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.FLOAT);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant sum( final int aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.INTEGER);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant sum( final long aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.LONG);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant sum( final short aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.SHORT);
        this.getTarget().sum(aValue);
        return this;
    }

    @Override
    public final Variant swapPrimitives( final Primitive<?> aValue )
        throws UnsupportedOperationException
    {
        final NumericPrecision prec = this.getPrecision().maximumOf(
            aValue.getPrecision());
        this.assertPrecision(prec);
        this.getTarget().swapPrimitives(aValue);
        return this;
    }

    @Override
    public final Variant tangent()
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.DOUBLE);
        this.getTarget().tangent();
        return this;
    }

    @Override
    public final Variant upperCase() throws UnsupportedOperationException
    {
        this._thePromoter.asString(this).upperCase();
        return this;
    }

    @Override
    public final Variant xor( final BigInteger aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.UNLIMITED_INTEGER);
        this.getTarget().xor(aValue);
        return this;
    }

    @Override
    public final Variant xor( final boolean aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BIT);
        this.getTarget().xor(aValue);
        return this;
    }

    @Override
    public final Variant xor( final byte aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.BYTE);
        this.getTarget().xor(aValue);
        return this;
    }

    @Override
    public final Variant xor( final char aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.CHARACTER);
        this.getTarget().xor(aValue);
        return this;
    }

    @Override
    public final Variant xor( final int aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.INTEGER);
        this.getTarget().xor(aValue);
        return this;
    }

    @Override
    public final Variant xor( final long aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.LONG);
        this.getTarget().xor(aValue);
        return this;
    }

    @Override
    public final Variant xor( final short aValue )
        throws UnsupportedOperationException,
            IllegalArgumentException,
            ArithmeticException
    {
        this.assertPrecision(NumericPrecision.SHORT);
        this.getTarget().xor(aValue);
        return this;
    }

    private static final Primitive<?> toPrimitive( final CharSequence aSignal )
    {
        final Primitive<?> aModel = toPrimitive(aSignal, null);
        if (aModel == null) return new TextPrimitive(aSignal.toString());
        return aModel;
    }

    private static final Primitive<?> toPrimitive(
        final CharSequence aSignal,
        final Primitive<?> aDefault )
    {
        final Number aNumber = To.toNumber(aSignal, null);
        if (aNumber != null) {
            final NumericPrecision prec = NumericPrecision.getPrecisionFor(aNumber);
            switch (prec) {
            case UNLIMITED_INTEGER:
                try {
                    final BigInteger ui = (BigInteger)aSignal;
                    return new UnlimitedIntegerPrimitive(ui);
                } catch (final Exception ex) {
                }
                break;
            case UNLIMITED_DECIMAL:
                try {
                    final BigDecimal ud = (BigDecimal)aSignal;
                    return new UnlimitedDecimalPrimitive(ud);
                } catch (final Exception ex) {
                }
                break;
            case BYTE:
                return new BytePrimitive(aNumber.byteValue());
            case SHORT:
                return new ShortPrimitive(aNumber.shortValue());
            case INTEGER:
                return new IntegerPrimitive(aNumber.intValue());
            case LONG:
                return new LongPrimitive(aNumber.longValue());
            case FLOAT:
                return new FloatPrimitive(aNumber.floatValue());
            case DOUBLE:
                return new DoublePrimitive(aNumber.doubleValue());
            }
            return aDefault;
        }
        final Boolean aBoolean = To.getSpecialBooleanIgnoreCase(aSignal);
        if (aBoolean != null) return new BooleanPrimitive(aBoolean);
        return aDefault;
    }

    public static final Primitive<?> toPrimitive( final Number aNumber )
    {
        switch (NumericPrecision.getPrecisionFor(aNumber)) {
        case NULL:
            return Constant.NULL;
        case BIT:
        case BYTE:
            return new BytePrimitive(aNumber.byteValue());
        case SHORT:
            return new ShortPrimitive(aNumber.shortValue());
        case CHARACTER:
            return new CharacterPrimitive((char)aNumber.intValue());
        case INTEGER:
            return new IntegerPrimitive(aNumber.intValue());
        case LONG:
            return new LongPrimitive(aNumber.longValue());
        case FLOAT:
            return new FloatPrimitive(aNumber.floatValue());
        case DOUBLE:
            return new DoublePrimitive(aNumber.doubleValue());
        case UNLIMITED_INTEGER:
            try {
                return new UnlimitedIntegerPrimitive((BigInteger)aNumber);
            } catch (final ClassCastException ex) {
                return new DoublePrimitive(aNumber.doubleValue());
            }
        case UNLIMITED_DECIMAL:
            try {
                return new UnlimitedDecimalPrimitive((BigDecimal)aNumber);
            } catch (final ClassCastException ex) {
                return new DoublePrimitive(aNumber.doubleValue());
            }
        }
        return new TextPrimitive(aNumber.toString());
    }

    public static final Primitive<?> toPrimitive( final NumericPrecision prec )
    {
        switch (prec) {
        case NULL:
            return Constant.NULL;
        case BIT:
            return new BooleanPrimitive();
        case BYTE:
            return new BytePrimitive();
        case SHORT:
            return new ShortPrimitive();
        case CHARACTER:
            return new CharacterPrimitive();
        case INTEGER:
            return new IntegerPrimitive();
        case LONG:
            return new LongPrimitive();
        case FLOAT:
            return new FloatPrimitive();
        case DOUBLE:
            return new DoublePrimitive();
        case UNLIMITED_INTEGER:
            return new UnlimitedIntegerPrimitive();
        case UNLIMITED_DECIMAL:
            return new UnlimitedDecimalPrimitive();
        }
        return new TextPrimitive();
    }

    public static final Primitive<?> toPrimitive( final SealedReal<?> aReal )
    {
        switch (aReal.getPrecision()) {
        case NULL:
            return Constant.NULL;
        case BIT:
            return new BooleanPrimitive(aReal);
        case BYTE:
            return new BytePrimitive(aReal);
        case SHORT:
            return new ShortPrimitive(aReal);
        case CHARACTER:
            return new CharacterPrimitive(aReal);
        case INTEGER:
            return new IntegerPrimitive(aReal);
        case LONG:
            return new LongPrimitive(aReal);
        case FLOAT:
            return new FloatPrimitive(aReal);
        case DOUBLE:
            return new DoublePrimitive(aReal);
        case UNLIMITED_INTEGER:
            return new UnlimitedIntegerPrimitive(aReal);
        case UNLIMITED_DECIMAL:
            return new UnlimitedDecimalPrimitive(aReal);
        }
        return new TextPrimitive(aReal.toString());
    }

    public static final Primitive<?> toPrimitive( final SealedScalar<?> aScalar )
    {
        switch (aScalar.getPrecision()) {
        case NULL:
            return Constant.NULL;
        case BIT:
            return new BooleanPrimitive(aScalar);
        case BYTE:
            return new BytePrimitive(aScalar);
        case SHORT:
            return new ShortPrimitive(aScalar);
        case CHARACTER:
            return new CharacterPrimitive(aScalar);
        case INTEGER:
            return new IntegerPrimitive(aScalar);
        case LONG:
            return new LongPrimitive(aScalar);
        case FLOAT:
            return new FloatPrimitive(aScalar);
        case DOUBLE:
            return new DoublePrimitive(aScalar);
        }
        return new TextPrimitive(aScalar.toString());
    }

    public static final Variant valueOfPrimitive(
        final SealedPrimitive<?> aValue )
    {
        switch (aValue.getPrecision()) {
        case NULL:
            return new Variant();
        case BIT:
            return new Variant(aValue.booleanValue());
        case BYTE:
            return new Variant(aValue.byteValue());
        case SHORT:
            return new Variant(aValue.shortValue());
        case CHARACTER:
            return new Variant(aValue.charValue());
        case INTEGER:
            return new Variant(aValue.intValue());
        case LONG:
            return new Variant(aValue.longValue());
        case FLOAT:
            return new Variant(aValue.floatValue());
        case DOUBLE:
            return new Variant(aValue.doubleValue());
        case UNLIMITED_INTEGER:
            return new Variant(aValue.toUnlimitedInteger());
        case UNLIMITED_DECIMAL:
            return new Variant(aValue.toUnlimitedDecimal());
        }
        return new Variant(aValue.toString());
    }

    public static final Variant valueOfReal( final SealedReal<?> aReal )
    {
        switch (aReal.getPrecision()) {
        case NULL:
            return new Variant();
        case BIT:
            return new Variant(aReal.booleanValue());
        case BYTE:
            return new Variant(aReal.byteValue());
        case SHORT:
            return new Variant(aReal.shortValue());
        case CHARACTER:
            return new Variant(aReal.charValue());
        case INTEGER:
            return new Variant(aReal.intValue());
        case LONG:
            return new Variant(aReal.longValue());
        case FLOAT:
            return new Variant(aReal.floatValue());
        case DOUBLE:
            return new Variant(aReal.doubleValue());
        case UNLIMITED_INTEGER:
            return new Variant(aReal.toUnlimitedInteger());
        case UNLIMITED_DECIMAL:
            return new Variant(aReal.toUnlimitedDecimal());
        }
        return new Variant(aReal.toString());
    }

    public static final Variant valueOfScalar( final SealedScalar<?> aScalar )
    {
        switch (aScalar.getPrecision()) {
        case NULL:
            return new Variant();
        case BIT:
            return new Variant(aScalar.booleanValue());
        case BYTE:
            return new Variant(aScalar.byteValue());
        case SHORT:
            return new Variant(aScalar.shortValue());
        case CHARACTER:
            return new Variant(aScalar.charValue());
        case INTEGER:
            return new Variant(aScalar.intValue());
        case UNLIMITED_INTEGER:
        case LONG:
            return new Variant(aScalar.longValue());
        case FLOAT:
            return new Variant(aScalar.floatValue());
        case UNLIMITED_DECIMAL:
        case DOUBLE:
            return new Variant(aScalar.doubleValue());
        }
        return new Variant(aScalar.toString());
    }

    private static class BooleanPromoter
        extends
            Promoter
    {
        public BooleanPromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.BYTE);
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.CHARACTER);
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.DOUBLE);
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.FLOAT);
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.INTEGER);
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.LONG);
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.SHORT);
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static class BytePromoter
        extends
            Promoter
    {
        public BytePromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.CHARACTER);
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.DOUBLE);
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.FLOAT);
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.INTEGER);
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.LONG);
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.SHORT);
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static class CharacterPromoter
        extends
            Promoter
    {
        public CharacterPromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.INTEGER);
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.DOUBLE);
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.FLOAT);
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.INTEGER);
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.LONG);
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.INTEGER);
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static final class Creator
        extends
            Factory
    {
        public final static Factory INSTANCE = new Creator();

        public Creator()
        {
        }

        @Override
        public final Primitive<?> get(
            final Variant aVariant,
            final NumericPrecision prec )
        {
            final Primitive<?> aTarget = toPrimitive(prec);
            final int index = prec.ordinal();
            aVariant._theTargets[index] = aTarget;
            aVariant._theFactories[index] = Getter.INSTANCE;
            return aTarget;
        }
    }

    private static class DoublePromoter
        extends
            Promoter
    {
        public DoublePromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static abstract class Factory
    {
        public Factory()
        {
        }

        public abstract Primitive<?> get(
            final Variant aVariant,
            final NumericPrecision prec );
    }

    private static class FloatPromoter
        extends
            Promoter
    {
        public FloatPromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.DOUBLE);
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static final class Getter
        extends
            Factory
    {
        public final static Factory INSTANCE = new Getter();

        public Getter()
        {
        }

        @Override
        public final Primitive<?> get(
            final Variant aVariant,
            final NumericPrecision prec )
        {
            return aVariant._theTargets[prec.ordinal()];
        }
    }

    private static class IntegerPromoter
        extends
            Promoter
    {
        public IntegerPromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.DOUBLE);
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.FLOAT);
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.LONG);
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static class LongPromoter
        extends
            Promoter
    {
        public LongPromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.DOUBLE);
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.FLOAT);
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static class NullPromoter
        extends
            Promoter
    {
        public NullPromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.BIT);
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.BYTE);
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.CHARACTER);
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.DOUBLE);
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.FLOAT);
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.INTEGER);
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.LONG);
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.SHORT);
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static abstract class Promoter
    {
        public Promoter()
        {
        }

        public abstract Primitive<?> asBoolean( final Variant aVariant );

        public abstract Primitive<?> asByte( final Variant aVariant );

        public abstract Primitive<?> asCharacter( final Variant aVariant );

        public abstract Primitive<?> asDouble( final Variant aVariant );

        public abstract Primitive<?> asFloat( final Variant aVariant );

        public abstract Primitive<?> asInteger( final Variant aVariant );

        public abstract Primitive<?> asLong( final Variant aVariant );

        public abstract Primitive<?> asShort( final Variant aVariant );

        public abstract Primitive<?> asString( final Variant aVariant );

        public abstract Primitive<?> asUnlimitedDecimal( final Variant aVariant );

        public abstract Primitive<?> asUnlimitedInteger( final Variant aVariant );

        public final Primitive<?> convertTo(
            final Variant aVariant,
            final NumericPrecision prec )
        {
            final Primitive<?> original = aVariant._theTarget;
            final Primitive<?> proposed = aVariant._theFactories[prec.ordinal()].get(
                aVariant, prec);
            if (original != proposed) {
                if (proposed.isMutable()) {
                    proposed.setPrimitive(original);
                }
                aVariant._theTarget = proposed;
                aVariant._thePromoter = _thePromoters.get(prec);
            }
            return proposed;
        }
    }

    private static class ShortPromoter
        extends
            Promoter
    {
        public ShortPromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.CHARACTER);
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.DOUBLE);
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.FLOAT);
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.INTEGER);
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.LONG);
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static class StringPromoter
        extends
            Promoter
    {
        public StringPromoter()
        {
        }

        private final Primitive<?> toScalar(
            final Variant aVariant,
            final NumericPrecision minPrec )
        {
            final Primitive<?> aPrimitive = toPrimitive(aVariant.toString());
            final NumericPrecision prec = aPrimitive.getPrecision();
            final int index = prec.ordinal();
            aVariant._theTarget = aPrimitive;
            aVariant._theTargets[index] = aPrimitive;
            aVariant._theFactories[index] = Getter.INSTANCE;
            aVariant._thePromoter = _thePromoters.get(prec);
            if (prec.isLessPreciseThan(minPrec))
                return aVariant._thePromoter.convertTo(aVariant, minPrec);
            return aPrimitive;
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return this.toScalar(aVariant, NumericPrecision.BIT);
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return this.toScalar(aVariant, NumericPrecision.BYTE);
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return this.toScalar(aVariant, NumericPrecision.DOUBLE);
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return this.toScalar(aVariant, NumericPrecision.FLOAT);
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return this.toScalar(aVariant, NumericPrecision.INTEGER);
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return this.toScalar(aVariant, NumericPrecision.LONG);
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return this.toScalar(aVariant, NumericPrecision.SHORT);
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_INTEGER);
        }
    }

    private static class UnlimitedDecimalPromoter
        extends
            Promoter
    {
        public UnlimitedDecimalPromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return aVariant._theTarget;
        }
    }

    private static class UnlimitedIntegerPromoter
        extends
            Promoter
    {
        public UnlimitedIntegerPromoter()
        {
        }

        @Override
        public final Primitive<?> asBoolean( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asByte( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asCharacter( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asDouble( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asFloat( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asInteger( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asLong( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asShort( final Variant aVariant )
        {
            return aVariant._theTarget;
        }

        @Override
        public final Primitive<?> asString( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNKNOWN);
        }

        @Override
        public final Primitive<?> asUnlimitedDecimal( final Variant aVariant )
        {
            return this.convertTo(aVariant, NumericPrecision.UNLIMITED_DECIMAL);
        }

        @Override
        public final Primitive<?> asUnlimitedInteger( final Variant aVariant )
        {
            return aVariant._theTarget;
        }
    }
}