return documentList;
    }

    public long getAllRecordCount() {
        return allRecordCount;
    }

    public String getAllRecordCountRelation() {
        return allRecordCountRelation;
    }

    public long getQueryTime() {
        return queryTime;
    }

    public boolean isPartialResults() {
        return partialResults;
    }

      return super.get();
    }

    @CanIgnoreReturnValue
    @Override
    public final V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
      return super.get(timeout, unit);
    }

    @Override
    public final boolean isDone() {
      return super.isDone();
    }

    @Override

      return standardContainsAll(collection);
    }

    @Override
    public boolean remove(Object object) {
      return standardRemove(object);
    }

    @Override
    public boolean removeAll(Collection<?> collection) {
      return standardRemoveAll(collection);
    }

    @Override
    public boolean retainAll(Collection<?> collection) {
      return standardRetainAll(collection);
    }

	}
	return prefix
}

func colorSuffix(colorize bool) string {
	if !colorize {
		return ""
	}
	return "\033[0m"
}

func IstioctlColorDefault(writer io.Writer) bool {
	if strings.EqualFold(termEnvVar.Get(), "dumb") {
		return false
	}

	file, ok := writer.(*os.File)
	if ok {
		if !isatty.IsTerminal(file.Fd()) {
			return false
		}
	}

	return true

    }

    public long getAccessCount() {
        return accessCount.get();
    }

    public long incrementAndGetAccessCount() {
        return accessCount.incrementAndGet();
    }

    public long decrementAndGetAccessCount() {
        return accessCount.decrementAndGet();
    }

    public CrawlerStatus getStatus() {
        return status;
    }

        this.dialect = dialectId;
    }


    /**
     * @return the smb2
     */
    public final boolean isSMB2 () {
        return this.smb2;
    }


    /**
     * @return the dialect
     */
    public final int getDialect () {
        if ( !this.smb2 ) {
            throw new UnsupportedOperationException();
        }
        return this.dialect;
    }


    /**
     * 

        return queryBuilder.isFragment();
    }

    @Override
    public QueryBuilder queryName(final String queryName) {
        return queryBuilder.queryName(queryName);
    }

    @Override
    public String queryName() {
        return queryBuilder.queryName();
    }

    @Override
    public float boost() {
        return queryBuilder.boost();
    }

    @Override

    }
    return result;
  }

  @WeakOuter
  class EntrySet extends Multisets.EntrySet<E> {
    @Override
    Multiset<E> multiset() {
      return AbstractMultiset.this;
    }

    @Override
    public Iterator<Entry<E>> iterator() {
      return entryIterator();
    }

    @Override
    public int size() {
      return distinctElements();
    }
  }

			port, err := parsePort(portStr)
			if err != nil {
				return nil, err
			}
			ports = append(ports, int(port))
		}
	}
	return ports, nil
}

func validatePortList(ports string) error {
	if _, err := parsePorts(ports); err != nil {
		return fmt.Errorf("portList %q invalid: %v", ports, err)
	}
	return nil
}

func validatePortListWithWildcard(ports string) error {

      return SECONDS;
    }
    if (MILLISECONDS.convert(nanos, NANOSECONDS) > 0) {
      return MILLISECONDS;
    }
    if (MICROSECONDS.convert(nanos, NANOSECONDS) > 0) {
      return MICROSECONDS;
    }
    return NANOSECONDS;
  }

  private static String abbreviate(TimeUnit unit) {
    switch (unit) {
      case NANOSECONDS:
        return "ns";
      case MICROSECONDS:
        return "\u03bcs"; // μs