*/
    public String getCurrentPageNumber() {
        return pageNumber;
    }

    /**
     * Initializes the form with default null values.
     * This method resets all fields to their default state for creating a new entry.
     */
    public void initialize() {
        id = null;
        url = null;
        threadName = null;
        errorName = null;
        errorLog = null;

	timeout 15m /tmp/mc ready myminio || fail

	# Wait for all drives to be online and formatted
	while [ $(/tmp/mc admin info --json myminio | jq '.info.servers[].drives[].state | select(. != "ok")' | wc -l) -gt 0 ]; do sleep 1; done
	# Wait for all drives to be healed

 * operations. A partially-reclaimed entry is never exposed to the user. Any {@link Map.Entry}
 * instance retrieved from the map's {@linkplain Map#entrySet entry set} is a snapshot of that
 * entry's state at the time of retrieval; such entries do, however, support {@link
 * Map.Entry#setValue}, which simply calls {@link Map#put} on the entry's key.
 *

      completed.assertCompletionExpected();
      assertEquals(Thread.State.TERMINATED, thread.getState());
    }

    void joinSuccessfully(long timeoutMillis) {
      Uninterruptibles.joinUninterruptibly(thread, timeoutMillis, MILLISECONDS);
      completed.assertCompletionExpected();
      assertEquals(Thread.State.TERMINATED, thread.getState());
    }

    void joinUnsuccessfully(long timeoutMillis) {

  interface ConcurrentlyMutatedList<E> extends List<E> {
    /**
     * The elements of a {@link ConcurrentlyMutatedList} are added and removed over time. This
     * method returns every state that the list has passed through at some point.
     */
    Set<List<E>> getAllStates();
  }

  /**
   * Returns a {@link ConcurrentlyMutatedList} that performs the given operations as its concurrent

                    // there still is some kind of race condition, where?
                    // this used to trigger "invalid operation..."
                    throw new SmbException("Service is null in state " + this.connectionState.get());
                }
                checkRequest(transport, req, svc);

            }

			if err != nil {
				internalLogIf(ctx, err, logger.WarningKind)
				break
			}

			// Handle if we have some buckets in-memory those are stale.
			// first delete them and then replace the newer state()
			// from disk.
			diskBuckets := set.CreateStringSet()
			for _, bucket := range buckets {
				diskBuckets.Add(bucket.Name)
			}
			sys.RemoveStaleBuckets(diskBuckets)

			for i := range buckets {

   * first decrementing to zero, and then removing. putIfAbsent or replace could observe the
   * intermediate zero-state. Ways we could deal with this are:
   *
   * - Don't define any of the ConcurrentMap operations. This is the current state of affairs.
   *
   * - Define putIfAbsent and replace as treating zero and absent identically (as currently

     */
    public String createdTime;

    /**
     * Version number of the role type.
     */
    public String versionNo;

    /**
     * Clears the pager's state.
     */
    public void clear() {
        allRecordCount = 0;
        allPageCount = 0;
        existPrePage = false;
        existNextPage = false;
        pageSize = getDefaultPageSize();

            doColumn("roles");
        }

        public void columnRoomNumber() {
            doColumn("roomNumber");
        }

        public void columnState() {
            doColumn("state");
        }

        public void columnStreet() {
            doColumn("street");
        }

        public void columnSurname() {
            doColumn("surname");
        }