}

        /*
         * Subtract the server and share from the pathConsumed so that
         * it reflects the part of the relative path consumed and not
         * the entire path.
         */

        DfsReferralDataInternal next = dri;
        do {
            next.stripPathConsumed(1 + server.length() + 1 + share.length());
            next = next.next();
        } while (next != dri);

import com.google.errorprone.annotations.Immutable;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

/** A {@code RegularImmutableTable} optimized for sparse data. */
@GwtCompatible
@Immutable(containerOf = {"R", "C", "V"})
final class SparseImmutableTable<R, C, V> extends RegularImmutableTable<R, C, V> {
  static final ImmutableTable<Object, Object, Object> EMPTY =

which is designed to persist between app restarts.

```kotlin
cache.delete()
```

## Pruning the Cache

Pruning the entire Cache to clear space temporarily can be done using evictAll.

```kotlin
cache.evictAll()
```

Removing individual items can be done using the urls iterator.

import okio.ByteString

/** An HTTP request that came into the mock web server. */
public class RecordedRequest(
  /**
   * The index of the socket connection that carried this request. If two recorded requests share a
   * connection index, they also shared a socket connection.
   */
  public val connectionIndex: Int,
  /**
   * The index of this exchange on its HTTP connection. A request is uniquely identified by the

            p++;
        }
        while (p < len && pathInfo.charAt(p) == '/') {
            p++;
        }
        if (p < len) { /* then there must be a share */
            out[i] = '/';
            i++;
            do { /* collect the share name */
                out[i++] = ch = pathInfo.charAt(p++);
            } while (p < len && ch != '/');
        }
        return new String(out, 0, i);
    }

     * @return the buffer capacity
     */
    public int getCapacity() {
        return this.buf.length - this.start;
    }

    /**
     * Returns the available space at the tail of the buffer.
     *
     * @return the available tail space
     */
    public int getTailSpace() {
        return this.buf.length - this.index;
    }

    /**
     * Returns the underlying byte buffer.
     *

        String url = "http://example.com/large-dataset";
        String message = "Crawling failed due to memory exhaustion";
        OutOfMemoryError error = new OutOfMemoryError("Heap space exhausted");

        DataStoreCrawlingException exception = new DataStoreCrawlingException(url, message, error);

        assertEquals(url, exception.getUrl());
        assertEquals(message, exception.getMessage());

cooperation with the community in the case of network server software.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
our General Public Licenses are intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.

  When we speak of free software, we are referring to freedom, not

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.smb1;

import jcifs.smb1.util.Hexdump;

class SmbComNTCreateAndX extends AndXServerMessageBlock {

    // share access specified in SmbFile

    // create disposition

    /* Creates a new file or supersedes the existing one
     */

    static final int FILE_SUPERSEDE = 0x0;

oriunde
până
pe
pentru
peste
pînă
poate
pot
prea
prima
primul
prin
printr
sa
să
săi
sale
sau
său
se
şi
sînt
sîntem
sînteţi
spre
sub
sunt
suntem
sunteţi
ta
tăi
tale
tău
te
ţi
ţie
tine
toată
toate
tot
toţi
totuşi
tu
un
una
unde
undeva
unei
unele