modules/tool-classfile/src/main/java/net/multiphasicapps/classfile/MethodHandle.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.lang.ref.Reference;
  13 import java.lang.ref.SoftReference;
  14 import java.lang.ref.WeakReference;
  15
  16 /**
  17  * This represents a method's class, name, and type.
  18  *
  19  * @since 2017/09/16
  20  */
  21 public final class MethodHandle
  22         implements Comparable<MethodHandle>
  23 {
  24         /** The class the method is in. */
  25         protected final ClassName outerclass;
  26
  27         /** The name of the method. */
  28         protected final MethodName name;
  29
  30         /** The descriptor of the method. */
  31         protected final MethodDescriptor descriptor;
  32
  33         /** Method name and type. */
  34         private Reference<MethodNameAndType> _nat;
  35
  36         /** String representation. */
  37         private Reference<String> _string;
  38
  39         /**
  40          * Initializes the method handle.
  41          *
  42          * @param __cl The class the method is in.
  43          * @param __n The name of the method.
  44          * @param __d The descriptor of the method.
  45          * @throws NullPointerException On null arguments.
  46          * @since 2017/09/16
  47          */
  48         public MethodHandle(ClassName __cl, MethodName __n, MethodDescriptor __d)
  49                 throws NullPointerException
  50         {
  51                 // Check
  52                 if (__cl == null || __n == null || __d == null)
  53                         throw new NullPointerException("NARG");
  54
  55                 this.outerclass = __cl;
  56                 this.name = __n;
  57                 this.descriptor = __d;
  58         }
  59
  60         /**
  61          * {@inheritDoc}
  62          * @since 2017/10/14
  63          */
  64         @Override
  65         public int compareTo(MethodHandle __o)
  66         {
  67                 int rv;
  68                 if ((rv = this.outerclass.compareTo(__o.outerclass)) != 0)
  69                         return rv;
  70                 if ((rv = this.name.compareTo(__o.name)) != 0)
  71                         return rv;
  72                 return this.descriptor.toString().compareTo(__o.descriptor.toString());
  73         }
  74
  75         /**
  76          * Returns the descriptor of the method.
  77          *
  78          * @return The method descriptor.
  79          * @since 2017/09/16
  80          */
  81         public MethodDescriptor descriptor()
  82         {
  83                 return this.descriptor;
  84         }
  85
  86         /**
  87          * {@inheritDoc}
  88          * @since 2017/09/16
  89          */
  90         @Override
  91         public boolean equals(Object __o)
  92         {
  93                 if (this == __o)
  94                         return true;
  95
  96                 if (!(__o instanceof MethodHandle))
  97                         return false;
  98
  99                 MethodHandle o = (MethodHandle)__o;
 100                 return this.outerclass.equals(o.outerclass) &&
 101                         this.name.equals(o.name) &&
 102                         this.descriptor.equals(o.descriptor);
 103         }
 104
 105         /**
 106          * {@inheritDoc}
 107          * @since 2017/09/16
 108          */
 109         @Override
 110         public int hashCode()
 111         {
 112                 return this.outerclass.hashCode() ^
 113                         this.name.hashCode() ^
 114                         this.descriptor.hashCode();
 115         }
 116
 117         /**
 118          * Returns {@code true} if this represents the instance initializer.
 119          *
 120          * @return {@code true} if this is the instance initializer.
 121          * @since 2017/09/18
 122          */
 123         public boolean isInstanceInitializer()
 124         {
 125                 return this.name.isInstanceInitializer();
 126         }
 127
 128         /**
 129          * Returns the Java type stack for this handle.
 130          *
 131          * @param __i If {@code true} then this is an instance invocation.
 132          * @return The handle as it appears on the Java Stack.
 133          * @since 2017/09/16
 134          */
 135         public JavaType[] javaStack(boolean __i)
 136         {
 137                 // No need to add current class type
 138                 JavaType[] djs = this.descriptor.javaStack();
 139                 if (!__i)
 140                         return djs;
 141
 142                 // Just copy over
 143                 int dn = djs.length;
 144                 JavaType[] rv = new JavaType[dn + 1];
 145                 rv[0] = new JavaType(this.outerclass);
 146                 for (int i = 0, o = 1; i < dn; i++, o++)
 147                         rv[o] = djs[i];
 148
 149                 return rv;
 150         }
 151
 152         /**
 153          * Returns the name of the method.
 154          *
 155          * @return The method name.
 156          * @since 2017/09/16
 157          */
 158         public MethodName name()
 159         {
 160                 return this.name;
 161         }
 162
 163         /**
 164          * Returns the name and type of the method.
 165          *
 166          * @return The method name and type.
 167          * @since 2019/04/17
 168          */
 169         public final MethodNameAndType nameAndType()
 170         {
 171                 Reference<MethodNameAndType> ref = this._nat;
 172                 MethodNameAndType rv;
 173
 174                 if (ref == null || null == (rv = ref.get()))
 175                         this._nat = new SoftReference<>((rv = new MethodNameAndType(
 176                                 this.name, this.descriptor)));
 177
 178                 return rv;
 179         }
 180
 181         /**
 182          * Returns the class this is contained within.
 183          *
 184          * @return The outer class.
 185          * @since 2017/09/16
 186          */
 187         public ClassName outerClass()
 188         {
 189                 return this.outerclass;
 190         }
 191
 192         /**
 193          * {@inheritDoc}
 194          * @since 2017/09/16
 195          */
 196         @Override
 197         public String toString()
 198         {
 199                 Reference<String> ref = this._string;
 200                 String rv;
 201
 202                 if (ref == null || null == (rv = ref.get()))
 203                         this._string = new WeakReference<>((rv = String.format("%s::%s%s",
 204                                 this.outerclass, this.name, this.descriptor)));
 205
 206                 return rv;
 207         }
 208 }
 209