}
        }

        @Throws(IOException::class)
        private
        fun processClassFile(zipEntry: ZipEntry, builder: Trie.Builder) {
            val endIndex = zipEntry.name.lastIndexOf("/")
            if (endIndex > 0) {
                val packageName = zipEntry.name.substring(0, endIndex)
                if (shouldInclude(packageName, excludes, includes)) {

      return forwardList.contains(object);
    }

    @Override
    public int indexOf(@Nullable Object object) {
      int index = forwardList.lastIndexOf(object);
      return (index >= 0) ? reverseIndex(index) : -1;
    }

    @Override
    public int lastIndexOf(@Nullable Object object) {
      int index = forwardList.indexOf(object);
      return (index >= 0) ? reverseIndex(index) : -1;
    }

    @Override

            return parent.remove(index);
        }

        public int indexOf(final Object o) {
            return parent.indexOf(o);
        }

        public int lastIndexOf(final Object o) {
            return parent.lastIndexOf(o);
        }

        public ListIterator<E> listIterator() {
            return parent.listIterator();
        }

    private static boolean pathNamesPossiblyEqual(final String path1, final String path2) {
        int p1, p2, l1, l2;

        // if unsure return this method returns true

        p1 = path1.lastIndexOf('/');
        p2 = path2.lastIndexOf('/');
        l1 = path1.length() - p1;
        l2 = path2.length() - p2;

        // anything with dots voids comparison

        assertArgumentNotNull("jarUrl", jarUrl);

        final URL nestedUrl = URLUtil.create(jarUrl.getPath());
        final String nestedUrlPath = nestedUrl.getPath();
        final int pos = nestedUrlPath.lastIndexOf('!');
        final String jarFilePath = nestedUrlPath.substring(0, pos);
        final File jarFile = new File(URLUtil.decode(jarFilePath, "UTF8"));
        return FileUtil.getCanonicalPath(jarFile);
    }

     */
    public static String getPackageName(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        final String fqcn = clazz.getName();
        final int pos = fqcn.lastIndexOf('.');
        if (pos > 0) {
            return fqcn.substring(0, pos);
        }
        return null;
    }

    /**

            return parent.remove(index);
        }

        public int indexOf(final Object o) {
            return parent.indexOf(o);
        }

        public int lastIndexOf(final Object o) {
            return parent.lastIndexOf(o);
        }

        public ListIterator<E> listIterator() {
            return parent.listIterator();
        }

        }

        @Override
        public String getParent() {
            if (path == null || path.isEmpty() || path.equals("/")) {
                return "smb://";
            }
            int lastSlash = path.lastIndexOf('/');
            if (lastSlash <= 0) {
                return "smb://";
            }
            return "smb://" + host + path.substring(0, lastSlash + 1);
        }

        @Override

     */
    public static String substringFromLast(final String str, final String separator) {
        if (isEmpty(str) || isEmpty(separator)) {
            return str;
        }
        final int pos = str.lastIndexOf(separator);
        if (pos == -1) {
            return str;
        }
        return str.substring(0, pos);
    }

    /**

    }

    // Check that asterisk did not match across domain name labels.
    val suffixStartIndexInHostname = hostname.length - suffix.length
    if (suffixStartIndexInHostname > 0 &&
      hostname.lastIndexOf('.', suffixStartIndexInHostname - 1) != -1
    ) {
      return false // Asterisk is matching across domain name labels -- not permitted.
    }

    // Hostname matches pattern.
    return true
  }