Split uint factory methods
[yangtools.git] / yang / yang-common / src / main / java / org / opendaylight / yangtools / yang / common / Uint64.java
1 /*
2  * Copyright (c) 2015 Pantheon Technologies s.r.o. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.yangtools.yang.common;
9
10 import static com.google.common.base.Preconditions.checkArgument;
11
12 import com.google.common.annotations.Beta;
13 import com.google.common.cache.CacheBuilder;
14 import com.google.common.cache.CacheLoader;
15 import com.google.common.cache.LoadingCache;
16 import com.google.common.primitives.UnsignedLong;
17 import java.math.BigInteger;
18 import org.eclipse.jdt.annotation.NonNullByDefault;
19 import org.eclipse.jdt.annotation.Nullable;
20 import org.kohsuke.MetaInfServices;
21 import org.opendaylight.yangtools.concepts.Variant;
22
23 /**
24  * Dedicated type for YANG's 'type uint64' type.
25  *
26  * @author Robert Varga
27  */
28 @Beta
29 @NonNullByDefault
30 public class Uint64 extends Number implements CanonicalValue<Uint64> {
31     @MetaInfServices(value = CanonicalValueSupport.class)
32     public static final class Support extends AbstractCanonicalValueSupport<Uint64> {
33         public Support() {
34             super(Uint64.class);
35         }
36
37         @Override
38         public Variant<Uint64, CanonicalValueViolation> fromString(final String str) {
39             try {
40                 return Variant.ofFirst(Uint64.valueOf(str));
41             } catch (IllegalArgumentException e) {
42                 return CanonicalValueViolation.variantOf(e);
43             }
44         }
45     }
46
47     private static final CanonicalValueSupport<Uint64> SUPPORT = new Support();
48     private static final long serialVersionUID = 1L;
49     private static final long MIN_VALUE = 0;
50
51     /**
52      * Cache of first 256 values.
53      */
54     private static final Uint64[] CACHE = new Uint64[Uint8.MAX_VALUE];
55     /**
56      * Commonly encountered values.
57      */
58     private static final Uint64[] COMMON = {
59         new Uint64(Short.MAX_VALUE + 1L),
60         new Uint64(32768),
61         new Uint64(65535),
62         new Uint64(65536),
63         new Uint64(Integer.MAX_VALUE),
64         new Uint64(Integer.MAX_VALUE + 1L),
65         new Uint64(Long.MAX_VALUE),
66     };
67
68     /**
69      * Tunable weak LRU cache for other values. By default it holds {@value #DEFAULT_LRU_SIZE} entries. This can be
70      * changed via {@value #LRU_SIZE_PROPERTY} system property.
71      */
72     private static final int DEFAULT_LRU_SIZE = 1024;
73     private static final String LRU_SIZE_PROPERTY = "org.opendaylight.yangtools.yang.common.Uint64.LRU.size";
74     private static final int MAX_LRU_SIZE = 0xffffff;
75     private static final int LRU_SIZE;
76
77     static {
78         final int p = Integer.getInteger(LRU_SIZE_PROPERTY, DEFAULT_LRU_SIZE);
79         LRU_SIZE = p >= 0 ? Math.min(p, MAX_LRU_SIZE) : DEFAULT_LRU_SIZE;
80     }
81
82     private static final LoadingCache<Long, Uint64> LRU = CacheBuilder.newBuilder().weakValues().maximumSize(LRU_SIZE)
83             .build(new CacheLoader<Long, Uint64>() {
84                 @Override
85                 public Uint64 load(final Long key) {
86                     return new Uint64(key);
87                 }
88             });
89
90     private final long value;
91
92     Uint64(final long value) {
93         this.value = value;
94     }
95
96     protected Uint64(final Uint64 other) {
97         this.value = other.value;
98     }
99
100     private static Uint64 instanceFor(final long value) {
101         final int slot = (int)value;
102         return slot >= 0 && slot < CACHE.length ? fromCache(slot, value) : fromCommon(value);
103     }
104
105     private static Uint64 fromCommon(final long value) {
106         for (Uint64 c : COMMON) {
107             if (c.value == value) {
108                 return c;
109             }
110         }
111         return LRU.getUnchecked(value);
112     }
113
114     private static Uint64 fromCache(final int slot, final long value) {
115         // FIXME: 4.0.0: use VarHandles here
116         Uint64 ret = CACHE[slot];
117         if (ret == null) {
118             synchronized (CACHE) {
119                 ret = CACHE[slot];
120                 if (ret == null) {
121                     ret = new Uint64(value);
122                     CACHE[slot] = ret;
123                 }
124             }
125         }
126         return ret;
127     }
128
129     public static Uint64 fromLongBits(final long bits) {
130         return instanceFor(bits);
131     }
132
133     public static Uint64 fromUnsignedLong(final UnsignedLong ulong) {
134         return instanceFor(ulong.longValue());
135     }
136
137     public static Uint64 valueOf(final byte byteVal) {
138         checkArgument(byteVal >= MIN_VALUE, "Negative values are not allowed");
139         return instanceFor(byteVal);
140     }
141
142     public static Uint64 valueOf(final short shortVal) {
143         checkArgument(shortVal >= MIN_VALUE, "Negative values are not allowed");
144         return instanceFor(shortVal);
145     }
146
147     public static Uint64 valueOf(final int intVal) {
148         checkArgument(intVal >= MIN_VALUE, "Value %s is outside of allowed range", intVal);
149         return instanceFor(intVal);
150     }
151
152     public static Uint64 valueOf(final long longVal) {
153         checkArgument(longVal >= MIN_VALUE, "Value %s is outside of allowed range", longVal);
154         return instanceFor(longVal);
155     }
156
157     public static Uint64 valueOf(final Uint8 uint) {
158         return instanceFor(uint.shortValue());
159     }
160
161     public static Uint64 valueOf(final Uint16 uint) {
162         return instanceFor(uint.intValue());
163     }
164
165     public static Uint64 valueOf(final Uint32 uint) {
166         return instanceFor(uint.longValue());
167     }
168
169     public static Uint64 valueOf(final String string) {
170         return valueOf(string, 10);
171     }
172
173     public static Uint64 valueOf(final String string, final int radix) {
174         return instanceFor(Long.parseUnsignedLong(string, radix));
175     }
176
177     public static Uint64 valueOf(final BigInteger bigInt) {
178         checkArgument(bigInt.signum() >= 0, "Negative values not allowed");
179         checkArgument(bigInt.bitLength() <= Long.SIZE, "Value %s is outside of allowed range", bigInt);
180
181         return instanceFor(bigInt.longValue());
182     }
183
184     @Override
185     public final int intValue() {
186         return (int)value;
187     }
188
189     @Override
190     public final long longValue() {
191         return value;
192     }
193
194     @Override
195     public final float floatValue() {
196         // TODO: ditch Guava
197         return UnsignedLong.fromLongBits(value).floatValue();
198     }
199
200     @Override
201     public final double doubleValue() {
202         // TODO: ditch Guava
203         return UnsignedLong.fromLongBits(value).doubleValue();
204     }
205
206     public final UnsignedLong toUnsignedLong() {
207         return UnsignedLong.fromLongBits(value);
208     }
209
210     @Override
211     @SuppressWarnings("checkstyle:parameterName")
212     public final int compareTo(final Uint64 o) {
213         return Long.compareUnsigned(value, o.value);
214     }
215
216     @Override
217     public final String toCanonicalString() {
218         return Long.toUnsignedString(value);
219     }
220
221     @Override
222     public final CanonicalValueSupport<Uint64> support() {
223         return SUPPORT;
224     }
225
226     @Override
227     public final int hashCode() {
228         return Long.hashCode(value);
229     }
230
231     @Override
232     public final boolean equals(final @Nullable Object obj) {
233         return this == obj || obj instanceof Uint64 && value == ((Uint64)obj).value;
234     }
235
236     @Override
237     public final String toString() {
238         return toCanonicalString();
239     }
240
241     private Object readResolve() {
242         return instanceFor(value);
243     }
244 }