Changeset 4d2c227


Ignore:
Timestamp:
Apr 20, 2016 12:40:28 PM (4 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
0d19fe4
Parents:
1a8847d
Message:

Blockfile: Add generics, part 1

Location:
core/java/src/net
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • core/java/src/net/i2p/client/naming/BlockfileNamingService.java

    r1a8847d r4d2c227  
    106106    private boolean _needsUpgrade;
    107107
    108     private static final Serializer _infoSerializer = new PropertiesSerializer();
    109     private static final Serializer _stringSerializer = new UTF8StringBytes();
    110     private static final Serializer _destSerializerV1 = new DestEntrySerializer();
    111     private static final Serializer _destSerializerV4 = new DestEntrySerializerV4();
     108    private static final Serializer<Properties> _infoSerializer = new PropertiesSerializer();
     109    private static final Serializer<String> _stringSerializer = new UTF8StringBytes();
     110    private static final Serializer<DestEntry> _destSerializerV1 = new DestEntrySerializer();
     111    private static final Serializer<DestEntry> _destSerializerV4 = new DestEntrySerializerV4();
    112112    // upgrade(), initExisting(), and initNew() will change this to _destSerializerV4
    113     private volatile Serializer _destSerializer = _destSerializerV1;
    114     private static final Serializer _hashIndexSerializer = new IntBytes();
     113    private volatile Serializer<DestEntry> _destSerializer = _destSerializerV1;
     114    private static final Serializer<Integer> _hashIndexSerializer = new IntBytes();
    115115
    116116    private static final String HOSTS_DB = "hostsdb.blockfile";
     
    14031403     *  the SkipSpan.
    14041404     */
    1405     private static class DestEntrySerializer implements Serializer {
     1405    private static class DestEntrySerializer implements Serializer<DestEntry> {
    14061406
    14071407        /**
     
    14091409         *  A format error on the destination is fatal
    14101410         */
    1411         public byte[] getBytes(Object o) {
    1412             DestEntry de = (DestEntry) o;
     1411        public byte[] getBytes(DestEntry de) {
    14131412            ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
    14141413            try {
     
    14301429
    14311430        /** returns null on error */
    1432         public Object construct(byte[] b) {
     1431        public DestEntry construct(byte[] b) {
    14331432            DestEntry rv = new DestEntry();
    14341433            ByteArrayInputStream bais = new ByteArrayInputStream(b);
     
    14531452     *  @since 0.9.26
    14541453     */
    1455     private static class DestEntrySerializerV4 implements Serializer {
    1456 
    1457         public byte[] getBytes(Object o) {
    1458             DestEntry de = (DestEntry) o;
     1454    private static class DestEntrySerializerV4 implements Serializer<DestEntry> {
     1455
     1456        public byte[] getBytes(DestEntry de) {
    14591457            ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
    14601458            int sz = de.destList != null ? de.destList.size() : 1;
     
    14881486
    14891487        /** returns null on error */
    1490         public Object construct(byte[] b) {
     1488        public DestEntry construct(byte[] b) {
    14911489            DestEntry rv = new DestEntry();
    14921490            ByteArrayInputStream bais = new ByteArrayInputStream(b);
  • core/java/src/net/metanotion/io/Serializer.java

    r1a8847d r4d2c227  
    2929package net.metanotion.io;
    3030
    31 public interface Serializer {
    32         public byte[] getBytes(Object o);
    33         public Object construct(byte[] b);
     31public interface Serializer<T> {
     32        public byte[] getBytes(T o);
     33        public T construct(byte[] b);
    3434}
  • core/java/src/net/metanotion/io/block/BlockFile.java

    r1a8847d r4d2c227  
    9797        private final boolean _wasMounted;
    9898
    99         private final BSkipList metaIndex;
     99        private final BSkipList<String, Integer> metaIndex;
    100100        private boolean _isClosed;
    101101        /** cached list of free pages, only valid if freListStart > 0 */
     
    323323                        mount();
    324324
    325                 metaIndex = new BSkipList(spanSize, this, METAINDEX_PAGE, new StringBytes(), new IntBytes());
     325                metaIndex = new BSkipList<String, Integer>(spanSize, this, METAINDEX_PAGE, new StringBytes(), new IntBytes());
    326326        }
    327327
     
    443443         *  @return null if not found
    444444         */
    445         public BSkipList getIndex(String name, Serializer key, Serializer val) throws IOException {
     445        public <K extends Comparable<? super K>, V> BSkipList<K, V> getIndex(String name, Serializer<K> key, Serializer<V> val) throws IOException {
    446446                // added I2P
    447                 BSkipList bsl = openIndices.get(name);
     447                BSkipList<K, V> bsl = (BSkipList<K, V>) openIndices.get(name);
    448448                if (bsl != null)
    449449                        return bsl;
    450450
    451                 Integer page = (Integer) metaIndex.get(name);
     451                Integer page = metaIndex.get(name);
    452452                if (page == null) { return null; }
    453                 bsl = new BSkipList(spanSize, this, page.intValue(), key, val, true);
     453                bsl = new BSkipList<K, V>(spanSize, this, page.intValue(), key, val, true);
    454454                if (file.canWrite()) {
    455455                        log.info("Checking skiplist " + name + " in blockfile " + file);
     
    469469         *  @throws IOException if already exists or other errors
    470470         */
    471         public BSkipList makeIndex(String name, Serializer key, Serializer val) throws IOException {
     471        public <K extends Comparable<? super K>, V> BSkipList<K, V> makeIndex(String name, Serializer<K> key, Serializer<V> val) throws IOException {
    472472                if(metaIndex.get(name) != null) { throw new IOException("Index already exists"); }
    473473                int page = allocPage();
    474474                metaIndex.put(name, Integer.valueOf(page));
    475475                BSkipList.init(this, page, spanSize);
    476                 BSkipList bsl = new BSkipList(spanSize, this, page, key, val, true);
     476                BSkipList<K, V> bsl = new BSkipList<K, V>(spanSize, this, page, key, val, true);
    477477                openIndices.put(name, bsl);
    478478                return bsl;
     
    517517         *  @since 0.9.26
    518518         */
    519         public void reformatIndex(String name, Serializer oldKey, Serializer oldVal,
    520                                   Serializer newKey, Serializer newVal) throws IOException {
     519        public <K extends Comparable<? super K>, V> void reformatIndex(String name, Serializer<K> oldKey, Serializer<V> oldVal,
     520                                  Serializer<K> newKey, Serializer<V> newVal) throws IOException {
    521521                if (openIndices.containsKey(name))
    522522                        throw new IOException("Cannot reformat open skiplist " + name);
    523                 BSkipList old = getIndex(name, oldKey, oldVal);
     523                BSkipList<K, V> old = getIndex(name, oldKey, oldVal);
    524524                if (old == null)
    525525                        return;
    526526                long start = System.currentTimeMillis();
    527527                String tmpName = "---tmp---" + name + "---tmp---";
    528                 BSkipList tmp = makeIndex(tmpName, newKey, newVal);
     528                BSkipList<K, V> tmp = makeIndex(tmpName, newKey, newVal);
    529529
    530530                // It could be much more efficient to do this at the
    531531                // SkipSpan layer but that's way too hard.
    532532                final int loop = 32;
    533                 List<Comparable> keys = new ArrayList<Comparable>(loop);
    534                 List<Object> vals = new ArrayList<Object>(loop);
     533                List<K> keys = new ArrayList<K>(loop);
     534                List<V> vals = new ArrayList<V>(loop);
    535535                while (true) {
    536                         SkipIterator iter = old.iterator();
     536                        SkipIterator<K, V> iter = old.iterator();
    537537                        for (int i = 0; iter.hasNext() && i < loop; i++) {
    538538                                keys.add(iter.nextKey());
     
    556556                closeIndex(name);
    557557                closeIndex(tmpName);
    558                 Integer page = (Integer) metaIndex.get(tmpName);
     558                Integer page = metaIndex.get(tmpName);
    559559                metaIndex.put(name, page);
    560560                metaIndex.remove(tmpName);
     
    624624                                // This uses IdentityBytes, so the value class won't be right, but at least
    625625                                // it won't fail the out-of-order check
    626                                 Serializer keyser = slname.equals("%%__REVERSE__%%") ? new IntBytes() : new UTF8StringBytes();
    627                                 BSkipList bsl = getIndex(slname, keyser, new IdentityBytes());
    628                                 if (bsl == null) {
     626                                boolean fail;
     627                                if (slname.equals("%%__REVERSE__%%")) {
     628                                        Serializer<Integer> keyser = new IntBytes();
     629                                        fail = getIndex(slname, keyser, new IdentityBytes()) == null;
     630                                } else {
     631                                        Serializer<String> keyser = new UTF8StringBytes();
     632                                        fail = getIndex(slname, keyser, new IdentityBytes()) == null;
     633                                }
     634                                if (fail) {
    629635                                        log.error("Can't find list? " + slname);
    630636                                        continue;
  • core/java/src/net/metanotion/io/block/index/BSkipLevels.java

    r1a8847d r4d2c227  
    5656 * Always fits on one page.
    5757 */
    58 public class BSkipLevels extends SkipLevels {
     58public class BSkipLevels<K extends Comparable<? super K>, V> extends SkipLevels<K, V> {
    5959        private static final long MAGIC = 0x42534c6576656c73l;  // "BSLevels"
    6060        static final int HEADER_LEN = 16;
     
    6262        public final int spanPage;
    6363        public final BlockFile bf;
    64         private final BSkipList bsl;
     64        private final BSkipList<K, V> bsl;
    6565        private boolean isKilled;
    6666        // the level pages, passed from the constructor to initializeLevels(),
     
    7474         *  level and init() was previously called.
    7575         */
    76         public BSkipLevels(BlockFile bf, int levelPage, BSkipList bsl) throws IOException {
     76        public BSkipLevels(BlockFile bf, int levelPage, BSkipList<K, V> bsl) throws IOException {
    7777                this.levelPage = levelPage;
    7878                this.bf = bf;
     
    9898                }
    9999
    100                 this.levels = new BSkipLevels[maxLen];
     100                this.levels = (BSkipLevels<K, V>[]) new BSkipLevels[maxLen];
    101101                if (bf.log.shouldLog(Log.DEBUG))
    102102                        bf.log.debug("Reading New BSkipLevels with " + nonNull + " / " + maxLen + " valid levels page " + levelPage +
     
    119119         */
    120120        public void initializeLevels() {
    121                 List<BSkipLevels> toInit = new ArrayList<BSkipLevels>(32);
    122                 List<BSkipLevels> nextInit = new ArrayList<BSkipLevels>(32);
     121                List<BSkipLevels<K, V>> toInit = new ArrayList<BSkipLevels<K, V>>(32);
     122                List<BSkipLevels<K, V>> nextInit = new ArrayList<BSkipLevels<K, V>>(32);
    123123                initializeLevels(toInit);
    124124                while (!toInit.isEmpty()) {
    125                         for (BSkipLevels bsl : toInit) {
     125                        for (BSkipLevels<K, V> bsl : toInit) {
    126126                                bsl.initializeLevels(nextInit);
    127127                        }
    128                         List<BSkipLevels> tmp = toInit;
     128                        List<BSkipLevels<K, V>> tmp = toInit;
    129129                        toInit = nextInit;
    130130                        nextInit = tmp;
     
    140140         *  @since 0.9.20
    141141         */
    142         private void initializeLevels(List<BSkipLevels> nextInit) {
     142        private void initializeLevels(List<BSkipLevels<K, V>> nextInit) {
    143143                boolean fail = false;
    144144                for(int i = 0; i < lps.length; i++) {
     
    148148                                if(levels[i] == null) {
    149149                                        try {
    150                                                 BSkipLevels lev = new BSkipLevels(bf, lp, bsl);
     150                                                BSkipLevels<K, V> lev = new BSkipLevels<K, V>(bf, lp, bsl);
    151151                                                levels[i] = lev;
    152152                                                nextInit.add(lev);
     
    159159                                        }
    160160                                }
    161                                 Comparable ourKey = key();
    162                                 Comparable nextKey = levels[i].key();
     161                                K ourKey = key();
     162                                K nextKey = levels[i].key();
    163163                                if (ourKey != null && nextKey != null &&
    164164                                    ourKey.compareTo(nextKey) >= 0) {
     
    216216                        }
    217217                        bf.file.writeShort(i);
    218                         bf.file.writeInt(((BSkipSpan) bottom).page);
     218                        bf.file.writeInt(((BSkipSpan<K, V>) bottom).page);
    219219                        for(int j = 0; j < i; j++) {
    220                                 bf.file.writeInt(((BSkipLevels) levels[j]).levelPage);
     220                                bf.file.writeInt(((BSkipLevels<K, V>) levels[j]).levelPage);
    221221                        }
    222222                } catch (IOException ioe) { throw new RuntimeException("Error writing to database", ioe); }
     
    237237
    238238        @Override
    239         public SkipLevels newInstance(int levels, SkipSpan ss, SkipList sl) {
     239        public SkipLevels<K, V> newInstance(int levels, SkipSpan<K, V> ss, SkipList<K, V> sl) {
    240240                try {
    241                         BSkipSpan bss = (BSkipSpan) ss;
    242                         BSkipList bsl = (BSkipList) sl;
     241                        BSkipSpan<K, V> bss = (BSkipSpan<K, V>) ss;
     242                        BSkipList<K, V> bsl = (BSkipList<K, V>) sl;
    243243                        int page = bf.allocPage();
    244244                        BSkipLevels.init(bf, page, bss.page, levels);
    245245                        if (bf.log.shouldLog(Log.DEBUG))
    246246                                bf.log.debug("New BSkipLevels height " + levels + " page " + page);
    247                         return new BSkipLevels(bf, page, bsl);
     247                        return new BSkipLevels<K, V>(bf, page, bsl);
    248248                        // do not need to call initLevels() here
    249249                } catch (IOException ioe) { throw new RuntimeException("Error creating database page", ioe); }
     
    274274         */
    275275        private boolean blvlfix() {
    276                 TreeSet<SkipLevels> lvls = new TreeSet<SkipLevels>(new LevelComparator());
     276                TreeSet<SkipLevels<K, V>> lvls = new TreeSet<SkipLevels<K, V>>(new LevelComparator<K, V>());
    277277                if (bf.log.shouldLog(Log.DEBUG))
    278278                        bf.log.debug("Starting level search");
     
    286286                // traverse the levels, back-to-front
    287287                boolean rv = false;
    288                 SkipLevels after = null;
    289                 for (SkipLevels lv : lvls) {
     288                SkipLevels<K, V> after = null;
     289                for (SkipLevels<K, V> lv : lvls) {
    290290                        boolean modified = false;
    291291                        if (bf.log.shouldLog(Log.DEBUG))
     
    294294                                int min = Math.min(after.levels.length, lv.levels.length);
    295295                                for (int i = 0; i < min; i++) {
    296                                         SkipLevels cur = lv.levels[i];
     296                                        SkipLevels<K, V> cur = lv.levels[i];
    297297                                        if (cur != after) {
    298298                                                if (cur != null)
     
    332332         *  @since 0.8.8
    333333         */
    334         private void getAllLevels(SkipLevels l, Set<SkipLevels> lvlSet) {
     334        private void getAllLevels(SkipLevels<K, V> l, Set<SkipLevels<K, V>> lvlSet) {
    335335                if (bf.log.shouldLog(Log.DEBUG))
    336336                        bf.log.debug("GAL " + l.print());
    337337                // Do level 0 without recursion, on the assumption everything is findable
    338338                // from the root
    339                 SkipLevels cur = l;
     339                SkipLevels<K, V> cur = l;
    340340                while (cur != null && lvlSet.add(cur)) {
    341341                        if (bf.log.shouldLog(Log.DEBUG))
     
    348348                // i.e. there are no problems, this won't find anything
    349349                for (int i = 1; i < l.levels.length; i++) {
    350                         SkipLevels lv = l.levels[i];
     350                        SkipLevels<K, V> lv = l.levels[i];
    351351                        if (lv != null && !lvlSet.contains(lv))
    352352                                getAllLevels(lv, lvlSet);
     
    359359         *  @since 0.8.8
    360360         */
    361         private static class LevelComparator implements Comparator<SkipLevels>, Serializable {
    362                 public int compare(SkipLevels l, SkipLevels r) {
    363                         Comparable lk = l.key();
    364                         Comparable rk = r.key();
     361        private static class LevelComparator<K extends Comparable<? super K>, V> implements Comparator<SkipLevels<K, V>>, Serializable {
     362                public int compare(SkipLevels<K, V> l, SkipLevels<K, V> r) {
     363                        K lk = l.key();
     364                        K rk = r.key();
    365365                        if (lk == null && rk == null)
    366366                                return 0;
     
    379379         */
    380380        @Override
    381         public boolean blvlck(boolean fix, int width, SkipLevels[] prevLevels) {
     381        public boolean blvlck(boolean fix, int width, SkipLevels<K, V>[] prevLevels) {
    382382                bf.log.warn("    Skip level at width " + width);
    383383                bf.log.warn("        levels " + this.levels.length);
     
    385385                bf.log.warn("        spanPage " + this.spanPage);
    386386                bf.log.warn("        levelPage " + this.levelPage);
    387                 SkipLevels higher = null;
     387                SkipLevels<K, V> higher = null;
    388388                for (int i = levels.length - 1; i >= 0; i--) {
    389389                        if (levels[i] != null) {
     
    419419                        }
    420420                } else {
    421                         prevLevels = new SkipLevels[levels.length];
     421                        prevLevels = (SkipLevels<K, V>[]) new SkipLevels[levels.length];
    422422                        System.arraycopy(levels, 0, prevLevels, 0, levels.length);
    423423                }
  • core/java/src/net/metanotion/io/block/index/BSkipList.java

    r1a8847d r4d2c227  
    5252 * Always fits on one page.
    5353 */
    54 public class BSkipList extends SkipList implements Closeable {
     54public class BSkipList<K extends Comparable<? super K>, V> extends SkipList<K, V> implements Closeable {
    5555        private static final long MAGIC = 0x536b69704c697374l;  // "SkipList"
    5656        public int firstSpanPage = 0;
     
    6060        private boolean isClosed;
    6161
    62         final HashMap<Integer, BSkipSpan> spanHash = new HashMap<Integer, BSkipSpan>();
    63         final HashMap<Integer, SkipLevels> levelHash = new HashMap<Integer, SkipLevels>();
     62        final HashMap<Integer, BSkipSpan<K, V>> spanHash = new HashMap<Integer, BSkipSpan<K, V>>();
     63        final HashMap<Integer, SkipLevels<K, V>> levelHash = new HashMap<Integer, SkipLevels<K, V>>();
    6464
    6565        private final boolean fileOnly;
    6666
    67         public BSkipList(int spanSize, BlockFile bf, int skipPage, Serializer key, Serializer val) throws IOException {
     67        public BSkipList(int spanSize, BlockFile bf, int skipPage, Serializer<K> key, Serializer<V> val) throws IOException {
    6868                this(spanSize, bf, skipPage, key, val, false);
    6969        }
    7070
    71         public BSkipList(int spanSize, BlockFile bf, int skipPage, Serializer key, Serializer val, boolean fileOnly) throws IOException {
     71        public BSkipList(int spanSize, BlockFile bf, int skipPage, Serializer<K> key, Serializer<V> val, boolean fileOnly) throws IOException {
    7272                if(spanSize < 1) { throw new RuntimeException("Span size too small"); }
    7373
     
    9090                this.fileOnly = fileOnly;
    9191                if (fileOnly)
    92                         first = new IBSkipSpan(bf, this, firstSpanPage, key, val);
     92                        first = new IBSkipSpan<K, V>(bf, this, firstSpanPage, key, val);
    9393                else
    94                         first = new BSkipSpan(bf, this, firstSpanPage, key, val);
    95                 BSkipLevels bstack = new BSkipLevels(bf, firstLevelPage, this);
     94                        first = new BSkipSpan<K, V>(bf, this, firstSpanPage, key, val);
     95                BSkipLevels<K, V> bstack = new BSkipLevels<K, V>(bf, firstLevelPage, this);
    9696                bstack.initializeLevels();
    9797                stack = bstack;
     
    200200
    201201        @Override
    202         public SkipIterator iterator() {
     202        public SkipIterator<K, V> iterator() {
    203203                if (!this.fileOnly)
    204204                        return super.iterator();
    205                 return new IBSkipIterator(first, 0);
    206         }
    207 
    208         @Override
    209         public SkipIterator min() {
     205                return new IBSkipIterator<K, V>(first, 0);
     206        }
     207
     208        @Override
     209        public SkipIterator<K, V> min() {
    210210                return iterator();
    211211        }
    212212
    213213        @Override
    214         public SkipIterator max() {
     214        public SkipIterator<K, V> max() {
    215215                if (!this.fileOnly)
    216216                        return super.max();
    217                 SkipSpan ss = stack.getEnd();
    218                 return new IBSkipIterator(ss, ss.nKeys - 1);
    219         }
    220 
    221         @Override
    222         public SkipIterator find(Comparable key) {
     217                SkipSpan<K, V> ss = stack.getEnd();
     218                return new IBSkipIterator<K, V>(ss, ss.nKeys - 1);
     219        }
     220
     221        @Override
     222        public SkipIterator<K, V> find(K key) {
    223223                if (!this.fileOnly)
    224224                        return super.find(key);
    225225                int[] search = new int[1];
    226                 SkipSpan ss = stack.getSpan(stack.levels.length - 1, key, search);
     226                SkipSpan<K, V> ss = stack.getSpan(stack.levels.length - 1, key, search);
    227227                if(search[0] < 0) { search[0] = -1 * (search[0] + 1); }
    228                 return new IBSkipIterator(ss, search[0]);
     228                return new IBSkipIterator<K, V>(ss, search[0]);
    229229        }
    230230
  • core/java/src/net/metanotion/io/block/index/BSkipSpan.java

    r1a8847d r4d2c227  
    6060 *</pre>
    6161 */
    62 public class BSkipSpan extends SkipSpan {
     62public class BSkipSpan<K extends Comparable<? super K>, V> extends SkipSpan<K, V> {
    6363        protected static final int MAGIC = 0x5370616e;  // "Span"
    6464        protected static final int HEADER_LEN = 20;
    6565        public static final int CONT_HEADER_LEN = 8;
    6666        protected final BlockFile bf;
    67         private final BSkipList bsl;
     67        private final BSkipList<K, V> bsl;
    6868        protected int page;
    6969        protected int overflowPage;
     
    7171        protected int prevPage;
    7272        protected int nextPage = 0;
    73         protected Serializer keySer;
    74         protected Serializer valSer;
     73        protected Serializer<K> keySer;
     74        protected Serializer<V> valSer;
    7575
    7676        // I2P
     
    8989
    9090        @Override
    91         public SkipSpan newInstance(SkipList sl) {
     91        public SkipSpan<K, V> newInstance(SkipList<K, V> sl) {
    9292                try {
    9393                        int newPage = bf.allocPage();
    9494                        init(bf, newPage, bf.spanSize);
    95                         return new BSkipSpan(bf, (BSkipList) sl, newPage, keySer, valSer);
     95                        return new BSkipSpan<K, V>(bf, (BSkipList<K, V>) sl, newPage, keySer, valSer);
    9696                } catch (IOException ioe) { throw new RuntimeException("Error creating database page", ioe); }
    9797        }
     
    238238        }
    239239
    240         private static void load(BSkipSpan bss, BlockFile bf, BSkipList bsl, int spanPage, Serializer key, Serializer val) throws IOException {
     240        private static <X extends Comparable<? super X>, Y> void load(BSkipSpan<X, Y> bss, BlockFile bf, BSkipList<X, Y> bsl,
     241                                                           int spanPage, Serializer<X> key, Serializer<Y> val) throws IOException {
    241242                loadInit(bss, bf, bsl, spanPage, key, val);
    242243                bss.loadData();
     
    247248         * Only read the span headers
    248249         */
    249         protected static void loadInit(BSkipSpan bss, BlockFile bf, BSkipList bsl, int spanPage, Serializer key, Serializer val) throws IOException {
     250        protected static <X extends Comparable<? super X>, Y> void loadInit(BSkipSpan<X, Y> bss, BlockFile bf, BSkipList<X, Y> bsl,
     251                                                                 int spanPage, Serializer<X> key, Serializer<Y> val) throws IOException {
    250252                if (bss.isKilled)
    251253                        throw new IOException("Already killed!! " + bss);
     
    289291                if (isKilled)
    290292                        throw new IOException("Already killed!! " + this);
    291                 this.keys = new Comparable[this.spanSize];
    292                 this.vals = new Object[this.spanSize];
     293                this.keys = (K[]) new Comparable[this.spanSize];
     294                this.vals = (V[]) new Object[this.spanSize];
    293295
    294296                int ksz, vsz;
     
    328330                        }
    329331//                      System.out.println("i=" + i + ", Page " + curPage + ", offset " + pageCounter[0] + " ksz " + ksz + " vsz " + vsz);
    330                         this.keys[i] = (Comparable) this.keySer.construct(k);
     332                        this.keys[i] = this.keySer.construct(k);
    331333                        this.vals[i] = this.valSer.construct(v);
    332334                        // Drop bad entry without throwing exception
     
    378380        }
    379381
    380         protected BSkipSpan(BlockFile bf, BSkipList bsl) {
     382        protected BSkipSpan(BlockFile bf, BSkipList<K, V> bsl) {
    381383                this.bf = bf;
    382384                this.bsl = bsl;
    383385        }
    384386
    385         public BSkipSpan(BlockFile bf, BSkipList bsl, int spanPage, Serializer key, Serializer val) throws IOException {
     387        public BSkipSpan(BlockFile bf, BSkipList<K, V> bsl, int spanPage, Serializer<K> key, Serializer<V> val) throws IOException {
    386388                this.bf = bf;
    387389                this.bsl = bsl;
     
    390392                this.prev = null;
    391393
    392                 BSkipSpan bss = this;
     394                BSkipSpan<K, V> bss = this;
    393395                // findbugs ok (set in load() above)
    394396                int np = nextPage;
    395397                while(np != 0) {
    396                         BSkipSpan temp = bsl.spanHash.get(Integer.valueOf(np));
     398                        BSkipSpan<K, V> temp = bsl.spanHash.get(Integer.valueOf(np));
    397399                        if(temp != null) {
    398400                                bss.next = temp;
    399401                                break;
    400402                        }
    401                         bss.next = new BSkipSpan(bf, bsl);
     403                        bss.next = new BSkipSpan<K, V>(bf, bsl);
    402404                        bss.next.next = null;
    403405                        bss.next.prev = bss;
    404                         bss = (BSkipSpan) bss.next;
     406                        bss = (BSkipSpan<K, V>) bss.next;
    405407                       
    406408                        BSkipSpan.load(bss, bf, bsl, np, key, val);
     
    412414                np = prevPage;
    413415                while(np != 0) {
    414                         BSkipSpan temp = bsl.spanHash.get(Integer.valueOf(np));
     416                        BSkipSpan<K, V> temp = bsl.spanHash.get(Integer.valueOf(np));
    415417                        if(temp != null) {
    416418                                bss.prev = temp;
    417419                                break;
    418420                        }
    419                         bss.prev = new BSkipSpan(bf, bsl);
     421                        bss.prev = new BSkipSpan<K, V>(bf, bsl);
    420422                        bss.prev.next = bss;
    421423                        bss.prev.prev = null;
    422                         bss = (BSkipSpan) bss.prev;
     424                        bss = (BSkipSpan<K, V>) bss.prev;
    423425                       
    424426                        BSkipSpan.load(bss, bf, bsl, np, key, val);
  • core/java/src/net/metanotion/io/block/index/IBSkipIterator.java

    r1a8847d r4d2c227  
    4242        will remain in memory.
    4343*/
    44 public class IBSkipIterator extends SkipIterator {
     44public class IBSkipIterator<K extends Comparable<? super K>, V> extends SkipIterator<K, V> {
    4545
    46         public IBSkipIterator(SkipSpan ss, int index) {
     46        public IBSkipIterator(SkipSpan<K, V> ss, int index) {
    4747                super(ss, index);
    4848        }
     
    5454         */
    5555        @Override
    56         public Object next() {
    57                 Object o;
     56        public V next() {
     57                V o;
    5858                if(index < ss.nKeys) {
    5959                        if (ss.vals == null) {
     
    9191         */
    9292        @Override
    93         public Comparable nextKey() {
     93        public K nextKey() {
    9494                if(index < ss.nKeys) {
    9595                        if (ss.keys == null) {
     
    111111         */
    112112        @Override
    113         public Object previous() {
     113        public V previous() {
    114114                if(index > 0) {
    115115                        index--;
  • core/java/src/net/metanotion/io/block/index/IBSkipSpan.java

    r1a8847d r4d2c227  
    5555 * @author zzz
    5656 */
    57 public class IBSkipSpan extends BSkipSpan {
    58 
    59         private Comparable firstKey;
    60 
    61         @Override
    62         public SkipSpan newInstance(SkipList sl) {
     57public class IBSkipSpan<K extends Comparable<? super K>, V> extends BSkipSpan<K, V> {
     58
     59        private K firstKey;
     60
     61        @Override
     62        public SkipSpan<K, V> newInstance(SkipList<K, V> sl) {
    6363                if (bf.log.shouldLog(Log.DEBUG))
    6464                        bf.log.debug("Splitting page " + this.page + " containing " + this.nKeys + '/' + this.spanSize);
     
    6666                        int newPage = bf.allocPage();
    6767                        init(bf, newPage, bf.spanSize);
    68                         SkipSpan rv = new IBSkipSpan(bf, (BSkipList) sl, newPage, keySer, valSer);
     68                        SkipSpan<K, V> rv = new IBSkipSpan<K, V>(bf, (BSkipList<K, V>) sl, newPage, keySer, valSer);
    6969                        // this is called after a split, so we need the data arrays initialized
    70                         rv.keys = new Comparable[bf.spanSize];
    71                         rv.vals = new Object[bf.spanSize];
     70                        rv.keys = (K[]) new Comparable[bf.spanSize];
     71                        rv.vals = (V[]) new Object[bf.spanSize];
    7272                        return rv;
    7373                } catch (IOException ioe) { throw new RuntimeException("Error creating database page", ioe); }
     
    126126                byte[] k = new byte[ksz];
    127127                curPage = this.bf.readMultiPageData(k, curPage, pageCounter, curNextPage);
    128                 this.firstKey = (Comparable) this.keySer.construct(k);
     128                this.firstKey = this.keySer.construct(k);
    129129                if (this.firstKey == null) {
    130130                        bf.log.error("Null deserialized first key in page " + curPage);
     
    161161         * Linear search through the span in the file for the value.
    162162         */
    163         private Object getData(Comparable key) throws IOException {
     163        private V getData(K key) throws IOException {
    164164                seekData();
    165165                int curPage = this.page;
     
    195195                        }
    196196                        //System.out.println("i=" + i + ", Page " + curPage + ", offset " + pageCounter[0] + " ksz " + ksz + " vsz " + vsz);
    197                         Comparable ckey = (Comparable) this.keySer.construct(k);
     197                        K ckey = this.keySer.construct(k);
    198198                        if (ckey == null) {
    199199                                // skip the value and keep going
     
    214214                                        break;
    215215                                }
    216                                 Object rv = this.valSer.construct(v);
     216                                V rv = this.valSer.construct(v);
    217217                                if (rv == null) {
    218218                                        bf.log.error("Null deserialized value in entry " + i + " page " + curPage +
     
    253253        }
    254254
    255         private IBSkipSpan(BlockFile bf, BSkipList bsl) {
     255        private IBSkipSpan(BlockFile bf, BSkipList<K, V> bsl) {
    256256                super(bf, bsl);
    257257        }
    258258
    259         public IBSkipSpan(BlockFile bf, BSkipList bsl, int spanPage, Serializer key, Serializer val) throws IOException {
     259        public IBSkipSpan(BlockFile bf, BSkipList<K, V> bsl, int spanPage, Serializer<K> key, Serializer<V> val) throws IOException {
    260260                super(bf, bsl);
    261261                if (bf.log.shouldLog(Log.DEBUG))
     
    266266                this.prev = null;
    267267
    268                 IBSkipSpan bss = this;
    269                 IBSkipSpan temp;
     268                IBSkipSpan<K, V> bss = this;
     269                IBSkipSpan<K, V> temp;
    270270                int np = nextPage;
    271271                while(np != 0) {
    272                         temp = (IBSkipSpan) bsl.spanHash.get(Integer.valueOf(np));
     272                        temp = (IBSkipSpan<K, V>) bsl.spanHash.get(Integer.valueOf(np));
    273273                        if(temp != null) {
    274274                                bss.next = temp;
    275275                                break;
    276276                        }
    277                         bss.next = new IBSkipSpan(bf, bsl);
     277                        bss.next = new IBSkipSpan<K, V>(bf, bsl);
    278278                        bss.next.next = null;
    279279                        bss.next.prev = bss;
    280                         Comparable previousFirstKey = bss.firstKey;
    281                         bss = (IBSkipSpan) bss.next;
     280                        K previousFirstKey = bss.firstKey;
     281                        bss = (IBSkipSpan<K, V>) bss.next;
    282282                       
    283283                        BSkipSpan.loadInit(bss, bf, bsl, np, key, val);
    284284                        bss.loadFirstKey();
    285                         Comparable nextFirstKey = bss.firstKey;
     285                        K nextFirstKey = bss.firstKey;
    286286                        if (previousFirstKey == null || nextFirstKey == null ||
    287287                            previousFirstKey.compareTo(nextFirstKey) >= 0) {
     
    300300                np = prevPage;
    301301                while(np != 0) {
    302                         temp = (IBSkipSpan) bsl.spanHash.get(Integer.valueOf(np));
     302                        temp = (IBSkipSpan<K, V>) bsl.spanHash.get(Integer.valueOf(np));
    303303                        if(temp != null) {
    304304                                bss.prev = temp;
    305305                                break;
    306306                        }
    307                         bss.prev = new IBSkipSpan(bf, bsl);
     307                        bss.prev = new IBSkipSpan<K, V>(bf, bsl);
    308308                        bss.prev.next = bss;
    309309                        bss.prev.prev = null;
    310                         Comparable nextFirstKey = bss.firstKey;
    311                         bss = (IBSkipSpan) bss.prev;
     310                        K nextFirstKey = bss.firstKey;
     311                        bss = (IBSkipSpan<K, V>) bss.prev;
    312312                       
    313313                        BSkipSpan.loadInit(bss, bf, bsl, np, key, val);
    314314                        bss.loadFirstKey();
    315                         Comparable previousFirstKey = bss.firstKey;
     315                        K previousFirstKey = bss.firstKey;
    316316                        if (previousFirstKey == null || nextFirstKey == null ||
    317317                            previousFirstKey.compareTo(nextFirstKey) >= 0) {
     
    331331         */
    332332        @Override
    333         public Comparable firstKey() {
     333        public K firstKey() {
    334334                return this.firstKey;
    335335        }
     
    340340         */
    341341        @Override
    342         public SkipSpan getSpan(Comparable key, int[] search) {
     342        public SkipSpan<K, V> getSpan(K key, int[] search) {
    343343                try {
    344344                        seekAndLoadData();
     
    346346                        throw new RuntimeException("Error reading database", ioe);
    347347                }
    348                 SkipSpan rv = super.getSpan(key, search);
     348                SkipSpan<K, V> rv = super.getSpan(key, search);
    349349                this.keys = null;
    350350                this.vals = null;
     
    356356         */
    357357        @Override
    358         public Object get(Comparable key) {
     358        public V get(K key) {
    359359                try {
    360360                        if (nKeys == 0) { return null; }
     
    371371         */
    372372        @Override
    373         public SkipSpan put(Comparable key, Object val, SkipList sl)    {
     373        public SkipSpan<K, V> put(K key, V val, SkipList<K, V> sl)      {
    374374                try {
    375375                        seekAndLoadData();
     
    377377                        throw new RuntimeException("Error reading database", ioe);
    378378                }
    379                 SkipSpan rv = super.put(key, val, sl);
     379                SkipSpan<K, V> rv = super.put(key, val, sl);
    380380                // flush() nulls out the data
    381381                return rv;
     
    386386         */
    387387        @Override
    388         public Object[] remove(Comparable key, SkipList sl) {
     388        public Object[] remove(K key, SkipList<K, V> sl) {
    389389                if (bf.log.shouldLog(Log.DEBUG))
    390390                        bf.log.debug("Remove " + key + " in " + this);
  • core/java/src/net/metanotion/io/data/IdentityBytes.java

    r1a8847d r4d2c227  
    3636 * Added by I2P.
    3737 */
    38 public class IdentityBytes implements Serializer {
     38public class IdentityBytes implements Serializer<byte[]> {
    3939
    4040        /** @return byte[] */
    41         public byte[] getBytes(Object o) { return (byte[])o; }
     41        public byte[] getBytes(byte[] o) { return o; }
    4242
    4343        /** @return b */
    44         public Object construct(byte[] b) { return b; }
     44        public byte[] construct(byte[] b) { return b; }
    4545}
  • core/java/src/net/metanotion/io/data/IntBytes.java

    r1a8847d r4d2c227  
    3131import net.metanotion.io.Serializer;
    3232
    33 public class IntBytes implements Serializer {
    34         public byte[] getBytes(Object o) {
     33public class IntBytes implements Serializer<Integer> {
     34        public byte[] getBytes(Integer o) {
    3535                byte[] b = new byte[4];
    36                 int v = ((Integer) o).intValue();
     36                int v = o.intValue();
    3737                b[0] = (byte)(0xff & (v >> 24));
    3838                b[1] = (byte)(0xff & (v >> 16));
     
    4242        }
    4343
    44         public Object construct(byte[] b) {
     44        public Integer construct(byte[] b) {
    4545                int v = (((b[0] & 0xff) << 24) |
    4646                                 ((b[1] & 0xff) << 16) |
  • core/java/src/net/metanotion/io/data/LongBytes.java

    r1a8847d r4d2c227  
    3131import net.metanotion.io.Serializer;
    3232
    33 public class LongBytes implements Serializer {
    34         public byte[] getBytes(Object o) {
     33public class LongBytes implements Serializer<Long> {
     34        public byte[] getBytes(Long o) {
    3535                byte[] b = new byte[8];
    36                 long v = ((Long) o).longValue();
     36                long v = o.longValue();
    3737                b[0] = (byte)(0xff & (v >> 56));
    3838                b[1] = (byte)(0xff & (v >> 48));
     
    4646        }
    4747
    48         public Object construct(byte[] b) {
     48        public Long construct(byte[] b) {
    4949                long v =(((long)(b[0] & 0xff) << 56) |
    5050                                 ((long)(b[1] & 0xff) << 48) |
  • core/java/src/net/metanotion/io/data/NullBytes.java

    r1a8847d r4d2c227  
    3131import net.metanotion.io.Serializer;
    3232
    33 public class NullBytes implements Serializer {
     33public class NullBytes implements Serializer<Object> {
    3434        public byte[] getBytes(Object o) { return null; }
    3535        public Object construct(byte[] b) { return null; }
  • core/java/src/net/metanotion/io/data/StringBytes.java

    r1a8847d r4d2c227  
    3333import net.metanotion.io.Serializer;
    3434
    35 public class StringBytes implements Serializer {
    36         public byte[] getBytes(Object o) {
     35public class StringBytes implements Serializer<String> {
     36        public byte[] getBytes(String o) {
    3737                try {
    38                         return ((String) o).getBytes("US-ASCII");
     38                        return o.getBytes("US-ASCII");
    3939                } catch (UnsupportedEncodingException uee) { throw new Error("Unsupported Encoding"); }
    4040        }
    4141
    42         public Object construct(byte[] b) {
     42        public String construct(byte[] b) {
    4343                try {
    4444                        return new String(b, "US-ASCII");
  • core/java/src/net/metanotion/io/data/UTF8StringBytes.java

    r1a8847d r4d2c227  
    3636 * Added by I2P
    3737 */
    38 public class UTF8StringBytes implements Serializer {
    39         public byte[] getBytes(Object o) {
     38public class UTF8StringBytes implements Serializer<String> {
     39        public byte[] getBytes(String o) {
    4040                try {
    41                         return ((String) o).getBytes("UTF-8");
     41                        return o.getBytes("UTF-8");
    4242                } catch (UnsupportedEncodingException uee) { throw new Error("Unsupported Encoding"); }
    4343        }
    4444
    45         public Object construct(byte[] b) {
     45        public String construct(byte[] b) {
    4646                try {
    4747                        return new String(b, "UTF-8");
  • core/java/src/net/metanotion/util/skiplist/SkipIterator.java

    r1a8847d r4d2c227  
    4040        To get the key, call nextKey() BEFORE calling next().
    4141*/
    42 public class SkipIterator implements ListIterator {
    43         protected SkipSpan ss;
     42public class SkipIterator<K extends Comparable<? super K>, V> implements ListIterator<V> {
     43        protected SkipSpan<K, V> ss;
    4444        protected int index;
    4545
    4646        protected SkipIterator() { }
    47         public SkipIterator(SkipSpan ss, int index) {
     47
     48        public SkipIterator(SkipSpan<K, V> ss, int index) {
    4849                if(ss==null) { throw new NullPointerException(); }
    4950                this.ss = ss;
     
    6061         * @throws NoSuchElementException
    6162         */
    62         public Object next() {
    63                 Object o;
     63        public V next() {
     64                V o;
    6465                if(index < ss.nKeys) {
    6566                        o = ss.vals[index];
     
    8485         * @throws NoSuchElementException
    8586         */
    86         public Comparable nextKey() {
     87        public K nextKey() {
    8788                if(index < ss.nKeys) { return ss.keys[index]; }
    8889                throw new NoSuchElementException();
     
    99100         * @throws NoSuchElementException
    100101         */
    101         public Object previous() {
     102        public V previous() {
    102103                if(index > 0) {
    103104                        index--;
     
    112113
    113114        // Optional methods
    114         public void add(Object o)       { throw new UnsupportedOperationException(); }
     115        public void add(V o)    { throw new UnsupportedOperationException(); }
    115116        public void remove()            { throw new UnsupportedOperationException(); }
    116         public void set(Object o)       { throw new UnsupportedOperationException(); }
     117        public void set(V o)    { throw new UnsupportedOperationException(); }
    117118        public int nextIndex()          { throw new UnsupportedOperationException(); }
    118119        public int previousIndex()      { throw new UnsupportedOperationException(); }
  • core/java/src/net/metanotion/util/skiplist/SkipLevels.java

    r1a8847d r4d2c227  
    3636import net.i2p.util.Log;
    3737
    38 public class SkipLevels implements Flushable {
     38public class SkipLevels<K extends Comparable<? super K>, V> implements Flushable {
    3939        /** We can't have more than 2**32 pages */
    4040        public static final int MAX_SIZE = 32;
     
    4646         */
    4747        // levels is almost final
    48         public SkipLevels[] levels;
     48        public SkipLevels<K, V>[] levels;
    4949        // bottom is final
    50         public SkipSpan bottom;
     50        public SkipSpan<K, V> bottom;
    5151        private final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(BlockFile.class);
    5252
    53         public SkipLevels newInstance(int levels, SkipSpan ss, SkipList sl) { return new SkipLevels(levels, ss); }
     53        public SkipLevels<K, V> newInstance(int levels, SkipSpan<K, V> ss, SkipList<K, V> sl) {
     54                return new SkipLevels<K, V>(levels, ss);
     55        }
     56
    5457        public void killInstance() { }
    5558        public void flush() { }
     
    6063         *  @throws IllegalArgumentException if size too big or too small
    6164         */
    62         public SkipLevels(int size, SkipSpan span) {
     65        public SkipLevels(int size, SkipSpan<K, V> span) {
    6366                if(size < 1 || size > MAX_SIZE)
    6467                        throw new IllegalArgumentException("Invalid Level Skip size");
    65                 levels = new SkipLevels[size];
     68                levels = (SkipLevels<K, V>[]) new SkipLevels[size];
    6669                bottom = span;
    6770        }
     
    9396        }
    9497
    95         public SkipSpan getEnd() {
     98        public SkipSpan<K, V> getEnd() {
    9699                for(int i=(levels.length - 1);i>=0;i--) {
    97100                        if(levels[i] != null) { return levels[i].getEnd(); }
     
    100103        }
    101104
    102         public SkipSpan getSpan(int start, Comparable key, int[] search) {
     105        public SkipSpan<K, V> getSpan(int start, K key, int[] search) {
    103106                for(int i=Math.min(start, levels.length - 1);i>=0;i--) {
    104107                        if((levels[i] != null) && (levels[i].key().compareTo(key) <= 0)) {
     
    109112        }
    110113
    111         public Comparable key() { return bottom.firstKey(); }
    112 
    113         public Object get(int start, Comparable key) {
     114        public K key() { return bottom.firstKey(); }
     115
     116        public V get(int start, K key) {
    114117                for(int i=Math.min(start, levels.length - 1);i>=0;i--) {
    115118                        if((levels[i] != null) && (levels[i].key().compareTo(key) <= 0)) {
     
    127130         *          rv is null if no object was removed.
    128131         */
    129         public Object[] remove(int start, Comparable key, SkipList sl) {
     132        public Object[] remove(int start, K key, SkipList<K, V> sl) {
    130133                Object[] res = null;
    131                 SkipLevels slvls = null;
     134                SkipLevels<K, V> slvls = null;
    132135                for(int i = Math.min(start, levels.length - 1); i >= 0; i--) {
    133136                        if(levels[i] != null) {
     
    136139                                        res = levels[i].remove(i, key, sl);
    137140                                        if((res != null) && (res[1] != null)) {
    138                                                 slvls = (SkipLevels) res[1];
     141                                                slvls = (SkipLevels<K, V>) res[1];
    139142                                                if(levels.length >= slvls.levels.length) {
    140143                                                        res[1] = null;
     
    160163                                boolean isFirst = sl.first == bottom;
    161164                                if (isFirst && levels[0] != null) {
    162                                         SkipSpan ssres = (SkipSpan)res[1];
     165                                        SkipSpan<K, V> ssres = (SkipSpan<K, V>)res[1];
    163166                                        if (bottom.firstKey().equals(ssres.firstKey())) {
    164167                                                // bottom copied the next span to itself
     
    172175                                                }
    173176                                               
    174                                                 SkipLevels replace = levels[0];
     177                                                SkipLevels<K, V> replace = levels[0];
    175178                                                for (int i = 0; i < levels.length; i++) {
    176179                                                        if (levels[i] == null)
     
    214217         *          else null if it went in an existing level or the new level is our height or less.
    215218         */
    216         public SkipLevels put(int start, Comparable key, Object val, SkipList sl) {
     219        public SkipLevels<K, V> put(int start, K key, V val, SkipList<K, V> sl) {
    217220                boolean modified = false;
    218221                for(int i = Math.min(start, levels.length - 1); i >= 0; i--) {
    219222                        // is key equal to or after the start of the level?
    220223                        if((levels[i] != null) && (levels[i].key().compareTo(key) <= 0)) {
    221                                 SkipLevels slvls = levels[i].put(i, key, val, sl);
     224                                SkipLevels<K, V> slvls = levels[i].put(i, key, val, sl);
    222225                                if(slvls != null) {
    223226                                        for (int j = i + 1; j < Math.min(slvls.levels.length, levels.length); j++) {
     
    244247                        }
    245248                }
    246                 SkipSpan ss = bottom.put(key,val,sl);
     249                SkipSpan<K, V> ss = bottom.put(key,val,sl);
    247250                if(ss!=null) {
    248251                        int height = sl.generateColHeight();
    249252                        if(height != 0) {
    250                                 SkipLevels slvls = this.newInstance(height, ss, sl);
     253                                SkipLevels<K, V> slvls = this.newInstance(height, ss, sl);
    251254                                for(int i=0;i<(Math.min(height,levels.length));i++) {
    252255                                        // he points to where we used to point
     
    268271
    269272        public boolean blvlck(boolean fix) { return false; }
    270         public boolean blvlck(boolean fix, int width, SkipLevels[] prevLevels) { return false; }
     273        public boolean blvlck(boolean fix, int width, SkipLevels<K, V>[] prevLevels) { return false; }
    271274}
    272275
  • core/java/src/net/metanotion/util/skiplist/SkipList.java

    r1a8847d r4d2c227  
    3636//import net.metanotion.io.block.BlockFile;
    3737
    38 public class SkipList implements Flushable {
     38public class SkipList<K extends Comparable<? super K>, V> implements Flushable {
    3939        /** the probability of each next higher level */
    4040        protected static final int P = 2;
    4141        private static final int MIN_SLOTS = 4;
    4242        // these two are really final
    43         protected SkipSpan first;
    44         protected SkipLevels stack;
     43        protected SkipSpan<K, V> first;
     44        protected SkipLevels<K, V> stack;
    4545        // I2P mod
    4646        public static final Random rng = RandomSource.getInstance();
     
    5858                if(span < 1 || span > SkipSpan.MAX_SIZE)
    5959                        throw new IllegalArgumentException("Invalid span size");
    60                 first = new SkipSpan(span);
    61                 stack = new SkipLevels(1, first);
     60                first = new SkipSpan<K, V>(span);
     61                stack = new SkipLevels<K, V>(1, first);
    6262                //rng = new Random(System.currentTimeMillis());
    6363        }
     
    9696        }
    9797
    98         public void put(Comparable key, Object val)     {
     98        public void put(K key, V val)   {
    9999                if(key == null) { throw new NullPointerException(); }
    100100                if(val == null) { throw new NullPointerException(); }
    101                 SkipLevels slvls = stack.put(stack.levels.length - 1, key, val, this);
     101                SkipLevels<K, V> slvls = stack.put(stack.levels.length - 1, key, val, this);
    102102                if(slvls != null) {
    103103                        // grow our stack
    104104                        //BlockFile.log.info("Top level old hgt " + stack.levels.length +  " new hgt " + slvls.levels.length);
    105                         SkipLevels[] levels = new SkipLevels[slvls.levels.length];
     105                        SkipLevels<K, V>[] levels = (SkipLevels<K, V>[]) new SkipLevels[slvls.levels.length];
    106106                        for(int i=0;i < slvls.levels.length; i++) {
    107107                                if(i < stack.levels.length) {
     
    117117        }
    118118
    119         public Object remove(Comparable key) {
     119        public Object remove(K key) {
    120120                if(key == null) { throw new NullPointerException(); }
    121121                Object[] res = stack.remove(stack.levels.length - 1, key, this);
    122122                if(res != null) {
    123123                        if(res[1] != null) {
    124                                 SkipLevels slvls = (SkipLevels) res[1];
     124                                SkipLevels<K, V> slvls = (SkipLevels<K, V>) res[1];
    125125                                for(int i=0;i < slvls.levels.length; i++) {
    126126                                        if(stack.levels[i] == slvls) {
     
    155155        }
    156156
    157         public Object get(Comparable key) {
     157        public V get(K key) {
    158158                if(key == null) { throw new NullPointerException(); }
    159159                return stack.get(stack.levels.length - 1, key);
    160160        }
    161161
    162         public SkipIterator iterator() { return new SkipIterator(first, 0); }
    163 
    164         public SkipIterator min() { return new SkipIterator(first, 0); }
    165 
    166         public SkipIterator max() {
    167                 SkipSpan ss = stack.getEnd();
    168                 return new SkipIterator(ss, ss.nKeys - 1);
     162        public SkipIterator<K, V> iterator() { return new SkipIterator<K, V>(first, 0); }
     163
     164        public SkipIterator<K, V> min() { return new SkipIterator<K, V>(first, 0); }
     165
     166        public SkipIterator<K, V> max() {
     167                SkipSpan<K, V> ss = stack.getEnd();
     168                return new SkipIterator<K, V>(ss, ss.nKeys - 1);
    169169        }
    170170
    171171        /** @return an iterator where nextKey() is the first one greater than or equal to 'key' */
    172         public SkipIterator find(Comparable key) {
     172        public SkipIterator<K, V> find(K key) {
    173173                int[] search = new int[1];
    174                 SkipSpan ss = stack.getSpan(stack.levels.length - 1, key, search);
     174                SkipSpan<K, V> ss = stack.getSpan(stack.levels.length - 1, key, search);
    175175                if(search[0] < 0) { search[0] = -1 * (search[0] + 1); }
    176                 return new SkipIterator(ss, search[0]);
     176                return new SkipIterator<K, V>(ss, search[0]);
    177177        }
    178178
  • core/java/src/net/metanotion/util/skiplist/SkipSpan.java

    r1a8847d r4d2c227  
    3333//import net.metanotion.io.block.BlockFile;
    3434
    35 public class SkipSpan implements Flushable {
     35public class SkipSpan<K extends Comparable<? super K>, V> implements Flushable {
    3636        /** This is actually limited by BlockFile.spanSize which is much smaller */
    3737        public static final int MAX_SIZE = 256;
    3838
    3939        public int nKeys = 0;
    40         public Comparable[] keys;
    41         public Object[] vals;
    42         public SkipSpan next, prev;
    43 
    44         public SkipSpan newInstance(SkipList sl) { return new SkipSpan(keys.length); }
     40        public K[] keys;
     41        public V[] vals;
     42        public SkipSpan<K, V> next, prev;
     43
     44        public SkipSpan<K, V> newInstance(SkipList<K, V> sl) { return new SkipSpan<K, V>(keys.length); }
    4545        public void killInstance() { }
    4646        public void flush() { }
     
    5454                if(size < 1 || size > MAX_SIZE)
    5555                        throw new IllegalArgumentException("Invalid span size " + size);
    56                 keys = new Comparable[size];
    57                 vals = new Object[size];
     56                keys = (K[]) new Comparable[size];
     57                vals = (V[]) new Object[size];
    5858        }
    5959
     
    7171        }
    7272
    73         private int binarySearch(Comparable key) {
     73        private int binarySearch(K key) {
    7474                int high = nKeys - 1;
    7575                int low = 0;
     
    9090        }
    9191
    92         public SkipSpan getEnd() {
     92        public SkipSpan<K, V> getEnd() {
    9393                if(next == null) { return this; }
    9494                return next.getEnd();
    9595        }
    9696
    97         public SkipSpan getSpan(Comparable key, int[] search) {
     97        public SkipSpan<K, V> getSpan(K key, int[] search) {
    9898                if(nKeys == 0) {
    9999                        search[0] = -1;
     
    112112        }
    113113
    114         public Object get(Comparable key) {
     114        public V get(K key) {
    115115                if(nKeys == 0) { return null; }
    116116                if(keys[nKeys - 1].compareTo(key) < 0) {
     
    139139        }
    140140
    141         private void split(int loc, Comparable key, Object val, SkipList sl) {
    142                 SkipSpan right = newInstance(sl);
     141        private void split(int loc, K key, V val, SkipList<K, V> sl) {
     142                SkipSpan<K, V> right = newInstance(sl);
    143143
    144144                if(this.next != null) { this.next.prev = right; }
     
    176176         *  @return the new span if it caused a split, else null if it went in this span
    177177         */
    178         private SkipSpan insert(int loc, Comparable key, Object val, SkipList sl) {
     178        private SkipSpan<K, V> insert(int loc, K key, V val, SkipList<K, V> sl) {
    179179                sl.addItem();
    180180                if(nKeys == keys.length) {
     
    194194         *  @return the new span if it caused a split, else null if it went in an existing span
    195195         */
    196         public SkipSpan put(Comparable key, Object val, SkipList sl)    {
     196        public SkipSpan<K, V> put(K key, V val, SkipList<K, V> sl)      {
    197197                if(nKeys == 0) {
    198198                        sl.addItem();
     
    247247         *          rv is null if no object was removed.
    248248         */
    249         public Object[] remove(Comparable key, SkipList sl) {
     249        public Object[] remove(K key, SkipList<K, V> sl) {
    250250                if(nKeys == 0) { return null; }
    251251                if(keys[nKeys - 1].compareTo(key) < 0) {
     
    271271                                //BlockFile.log.error("Killing next span " + next + ") and copying to this span " + this + " in remove of " + key);
    272272                                // Make us point to next.next and him point back to us
    273                                 SkipSpan nn = next.next;
     273                                SkipSpan<K, V> nn = next.next;
    274274                                next.killInstance();
    275275                                if (nn != null) {
     
    312312
    313313        /** I2P */
    314         public Comparable firstKey() {
     314        public K firstKey() {
    315315                return keys[0];
    316316        }
Note: See TracChangeset for help on using the changeset viewer.