Index.java

Go to the documentation of this file.

/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.util;
 
import java.io.IOException;
import java.io.ObjectStreamException;
 
import javolution.lang.Configurable;
import javolution.lang.MathLib;
import javolution.lang.Realtime;
import javolution.lang.ValueType;
import javolution.text.Cursor;
import javolution.text.DefaultTextFormat;
import javolution.text.TextContext;
import javolution.text.TextFormat;
import javolution.text.TypeFormat;
 
@Realtime
@DefaultTextFormat(Index.Decimal.class)
public final class Index extends Number implements Comparable<Index>,
        ValueType<Index> {
 
    public static class Decimal extends TextFormat<Index> {
 
        @Override
        public Appendable format(Index obj, Appendable dest) throws IOException {
            return TypeFormat.format(obj.intValue(), dest);
        }
 
        @Override
        public Index parse(CharSequence csq, Cursor cursor)
                throws IllegalArgumentException {
            return Index.valueOf(TypeFormat.parseInt(csq, cursor));
        }
 
    }
 
    public static final Configurable<Integer> UNIQUE = new Configurable<Integer>() {
 
        @Override
        protected Integer getDefault() {
            return 1024;
        }        
     
        @Override
        protected Integer initialized(Integer value) {
            return MathLib.min(value, 65536); // Hard-limiting
        }
 
        @Override
        protected Integer reconfigured(Integer oldCount, Integer newCount) {
             throw new UnsupportedOperationException(
                     "Unicity reconfiguration not supported."); 
        }
    };
 
    public static final Index ZERO = new Index(0);
 
    private static final long serialVersionUID = 0x600L; // Version.
    private static final Index[] INSTANCES = new Index[UNIQUE.get()];
    static {
        INSTANCES[0] = ZERO;
        for (int i = 1; i < INSTANCES.length; i++) {
            INSTANCES[i] = new Index(i);
        }
    }
 
    public static Index valueOf(int value) {
        return (value < INSTANCES.length) ? INSTANCES[value] : new Index(value);
    }
 
    private final int value;
 
    private Index(int value) {
        this.value = value;
    }
 
    public int compareTo(Index that) {
        return this.value - that.value;
    }
 
    public int compareTo(int value) {
        return this.value - value;
    }
 
    public Index copy() {
        return value < INSTANCES.length ? this : new Index(value);
    }
 
    public double doubleValue() {
        return (double) value;
    }
 
    @Override
    public boolean equals(Object obj) {
        return (this.value < INSTANCES.length) ? (this == obj)
                : ((obj instanceof Index) ? (((Index) obj).value == value)
                        : false);
    }
 
    public float floatValue() {
        return (float) value;
    }
 
    @Override
    public int hashCode() {
        return value;
    }
 
    public int intValue() {
        return value;
    }
 
    public boolean isZero() {
        return this == ZERO;
    }
 
    public long longValue() {
        return value;
    }
 
    public Index next() {
        return Index.valueOf(value + 1);
    }
 
    public Index previous() {
        return Index.valueOf(value - 1);
    }
 
    protected final Object readResolve() throws ObjectStreamException {
        return Index.valueOf(value);
    }
 
    @Override
    public String toString() {
        return TextContext.getFormat(Index.class).format(this);
    }
 
    @Override
    public Index value() {
        return this;
    }
}