modules/tool-classfile/src/main/java/net/multiphasicapps/classfile/Flags.java

   1 // -*- Mode: Java; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the GNU General Public License v3+, or later.
   7 // See license.mkd for licensing and copyright information.
   8 // ---------------------------------------------------------------------------
   9
  10 package net.multiphasicapps.classfile;
  11
  12 import java.util.AbstractSet;
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15 import java.util.HashSet;
  16 import java.util.Iterator;
  17 import java.util.List;
  18 import java.util.Set;
  19
  20 /**
  21  * This is the base class for all flag collections.
  22  *
  23  * @param <F> The flag type.
  24  * @since 2016/04/23
  25  */
  26 public abstract class Flags<F extends Flag>
  27         extends AbstractSet<F>
  28 {
  29         /** The class type to use. */
  30         protected final Class<F> cast;
  31
  32         /** The set ordinals. */
  33         protected final int setbits;
  34
  35         /** The slower access set. */
  36         private final Set<F> _flags;
  37
  38         /**
  39          * Initializes the flag set.
  40          *
  41          * @param __cl The class type of the flag.
  42          * @param __fl The input flags.
  43          * @throws NullPointerException On null arguments.
  44          * @since 2016/04/23
  45          */
  46         Flags(Class<F> __cl, F[] __fl)
  47                 throws NullPointerException
  48         {
  49                 this(__cl, Arrays.<F>asList(__fl));
  50         }
  51
  52         /**
  53          * Initializes the flag set.
  54          *
  55          * @param __cl The class type of the flag.
  56          * @param __fl The input flags.
  57          * @throws NullPointerException On null arguments.
  58          * @since 2016/04/23
  59          */
  60         Flags(Class<F> __cl, Iterable<F> __fl)
  61         {
  62                 // Check
  63                 if (__cl == null || __fl == null)
  64                         throw new NullPointerException("NARG");
  65
  66                 // Set
  67                 this.cast = __cl;
  68
  69                 // Go through all input flags
  70                 Set<F> to = new HashSet<>();
  71                 int bits = 0;
  72                 for (F f : __fl)
  73                 {
  74                         // Get ordinal
  75                         int o = f.ordinal();
  76
  77                         // Set it
  78                         bits |= (1 << o);
  79
  80                         // Add to flag set
  81                         to.add(f);
  82                 }
  83
  84                 // Lock in
  85                 this.setbits = bits;
  86                 this._flags = to;
  87         }
  88
  89         /**
  90          * {@inheritDoc}
  91          * @since 2016/04/23
  92          */
  93         @Override
  94         public final boolean contains(Object __o)
  95         {
  96                 if (!(__o instanceof Flag))
  97                         return false;
  98
  99                 // Quick bit check?
 100                 if (this.cast.isInstance(__o))
 101                         return 0 != (this.setbits & (1 << (((Flag)__o).ordinal())));
 102
 103                 // Fallback
 104                 return this._flags.contains(__o);
 105         }
 106
 107         /**
 108          * {@inheritDoc}
 109          * @since 2016/04/23
 110          */
 111         @Override
 112         public final Iterator<F> iterator()
 113         {
 114                 return new __Iterator__<F>(this._flags.iterator());
 115         }
 116
 117         /**
 118          * {@inheritDoc}
 119          * @since 2016/04/23
 120          */
 121         @Override
 122         public final int size()
 123         {
 124                 return this._flags.size();
 125         }
 126
 127         /**
 128          * Converts the flags to Java bits.
 129          *
 130          * @return The Java bits.
 131          * @since 2018/12/04
 132          */
 133         public final int toJavaBits()
 134         {
 135                 int rv = 0;
 136
 137                 for (Flag f : this)
 138                         rv |= f.javaBitMask();
 139
 140                 return rv;
 141         }
 142
 143         /**
 144          * Decodes the specified bitfield and returns the used flags.
 145          *
 146          * @param <F> The type of flags to decode.
 147          * @param __i The input bitfield.
 148          * @param __f The flag values to decode.
 149          * @return The flags specified in the bitfield.
 150          * @throws InvalidClassFormatException If extra flags were specified.
 151          * @throws NullPointerException On null arguments.
 152          * @since 2017/06/13
 153          */
 154         static <F extends Flag> Iterable<F> __decode(int __i, F[] __f)
 155                 throws InvalidClassFormatException, NullPointerException
 156         {
 157                 // Find all matching flags in the bitfield
 158                 List<F> fl = new ArrayList<>(__f.length);
 159                 for (F f : __f)
 160                 {
 161                         int v = f.javaBitMask();
 162                         if (0 != (__i & v))
 163                         {
 164                                 fl.add(f);
 165                                 __i ^= v;
 166                         }
 167                 }
 168
 169                 // {@squirreljme.error JC2w An undefined flag has been specified.
 170                 // (The extra bitfield flags)}
 171                 if (__i != 0)
 172                         throw new InvalidClassFormatException(
 173                                 String.format("JC2w %02x", __i));
 174
 175                 return fl;
 176         }
 177
 178         /**
 179          * Iterates over flags.
 180          *
 181          * @since 2017/01/28
 182          */
 183         private static final class __Iterator__<F>
 184                 implements Iterator<F>
 185         {
 186                 /** The iterator used. */
 187                 protected final Iterator<F> iterator;
 188
 189                 /**
 190                  * Wraps the iterator.
 191                  *
 192                  * @param __it The iterator to wrap.
 193                  * @since 2017/01/28
 194                  */
 195                 private __Iterator__(Iterator<F> __it)
 196                 {
 197                         this.iterator = __it;
 198                 }
 199
 200                 /**
 201                  * {@inheritDoc}
 202                  * @since 2017/01/28
 203                  */
 204                 @Override
 205                 public boolean hasNext()
 206                 {
 207                         return this.iterator.hasNext();
 208                 }
 209
 210                 /**
 211                  * {@inheritDoc}
 212                  * @since 2017/01/28
 213                  */
 214                 @Override
 215                 public F next()
 216                 {
 217                         return this.iterator.next();
 218                 }
 219
 220                 /**
 221                  * {@inheritDoc}
 222                  * @since 2017/01/28
 223                  */
 224                 @Override
 225                 public void remove()
 226                 {
 227                         throw new UnsupportedOperationException("RORO");
 228                 }
 229         }
 230 }
 231