accessResult.setAccessResultData(null);
                try {
                    final Transformer transformer = ComponentUtil.getComponent(accessResultData.getTransformerName());
                    if (transformer == null) {
                        // no transformer
                        logger.warn("No transformer: {}", accessResultData.getTransformerName());
                        continue;
                    }

   * List<A extends String>}, we need to compare that {@code <A extends B>} is unequal to {@code <A
   * extends String>} in order to decide to use the transformed type instead of the original type.
   */
  static final class TypeVariableKey {
    private final TypeVariable<?> var;

    TypeVariableKey(TypeVariable<?> var) {
      this.var = checkNotNull(var);
    }

   * List<A extends String>}, we need to compare that {@code <A extends B>} is unequal to {@code <A
   * extends String>} in order to decide to use the transformed type instead of the original type.
   */
  static final class TypeVariableKey {
    private final TypeVariable<?> var;

    TypeVariableKey(TypeVariable<?> var) {
      this.var = checkNotNull(var);
    }

        TestTransformer transformer1 = new TestTransformer();
        NameTrackingTransformer transformer2 = new NameTrackingTransformer();

        transformer1.setName("transformer1");
        transformer2.setName("transformer2");

        assertEquals("transformer1", transformer1.getName());
        assertEquals("transformer2", transformer2.getName());

        TestTransformer transformer3 = new TestTransformer("transformer3");

        ResponseData responseData = new ResponseData();
        responseData.setUrl("http://example.com");

        ResultData result1 = transformer1.transform(responseData);
        ResultData result2 = transformer2.transform(responseData);
        ResultData result3 = transformer3.transform(responseData);

crawler.crawlerContext.setMaxDepth(5);               // Limit crawl depth

// Use streaming for large files
container.singleton("fileTransformer", FileTransformer.class, transformer -> {
    transformer.setMaxContentSize(10 * 1024 * 1024); // 10MB limit
});
```

## Troubleshooting

### Common Issues

#### Connection Timeouts
```java
// Increase timeout values

    // Transform count and reserved fields
    private int transformCount = 1; // Number of transforms (always 1 for SMBDirect)
    private int reserved1 = 0;
    private int reserved2 = 0;

    // SMB_DIRECT_RDMA_TRANSFORM_V1
    private int rdmaTransformId = 0x0001; // SMB_DIRECT_RDMA_TRANSFORM_V1

    /**
     * Create RDMA Transform Capabilities context
     */

        public XmlReaderRequestBuilder reader(Reader reader) {
            this.reader = reader;
            return this;
        }

        public XmlReaderRequestBuilder transformer(Transformer transformer) {
            this.transformer = transformer;
            return this;
        }

        public XmlReaderRequestBuilder strict(boolean strict) {
            this.strict = strict;
            return this;
        }

- Ensured objects are transformed prior to storage in `SharedInformers` if a transformer is provided and `WatchList` is activated. ([#131799](https://github.com/kubernetes/kubernetes/pull/131799), [@valerian-roche](https://github.com/valerian-roche))

        // Create SMB2_RDMA_TRANSFORM structure
        this.transform = new Smb2RdmaTransform(address, remoteKey, length);
    }

    /**
     * Create from SMB2 RDMA Transform
     *
     * @param transform the RDMA transform structure
     */
    public RdmaChannelInfo(Smb2RdmaTransform transform) {
        this.transform = transform;
    }

    /**
     * Get remote memory key
     *