code: public boolean parse(ClassFile cf) throws ConstantPoolException {
          List<Integer> cprefs = new ArrayList<>();
          int index = 1;
          for (ConstantPool.CPInfo cpInfo : cf.constant_pool.entries()) {
              if (cpInfo.accept(cpVisitor, cf.constant_pool)) {
                  cprefs.add(index);
              }
              index += cpInfo.size();
          }
  
          if (cprefs.isEmpty()) {
              return false;
          }
  
          for (Method m : cf.methods) {
              Set<Integer> ids = new HashSet<>();
              Code_attribute c_attr = (Code_attribute) m.attributes.get(Attribute.Code);
              if (c_attr != null) {
                  for (Instruction instr : c_attr.getInstructions()) {
                      int idx = instr.accept(codeVisitor, cprefs);
                      if (idx > 0) {
                          ids.add(idx);
                      }
                  }
              }
              if (ids.size() > 0) {
                  List<CPRefInfo> refInfos = new ArrayList<>(ids.size());
                  for (int id : ids) {
                      refInfos.add(CPRefInfo.class.cast(cf.constant_pool.get(id)));
                  }
                  visitor.visit(cf, m, refInfos);
              }
          }
          return true;
      }
docs: Parses a given ClassFile and invoke the visitor if there is any reference
  to the constant pool entries referencing field, method, or
  interface method that are accepted. This method will return
  {@code true} if there is one or more accepted constant pool entries
  to lookup; otherwise, it will return {@code false}.
  
  @param  cf  ClassFile
  @return {@code true} if the given class file is processed to lookup
  references
  @throws ConstantPoolException if an error of the constant pool