}
            data = serializer.apply(rawData);
        }
        return data;
    }

    /**
     * Set the data.
     * @param data the byte array data to set
     */
    public void setData(final byte[] data) {
        this.data = data;
    }

    /**
     * Add a child URL.
     * @param url the request data to add to the child URL set
     */
    public void addUrl(final RequestData url) {

     *
     * @param data the data buffer to write
     * @param offset the offset in the data buffer
     * @param length the number of bytes to write
     */
    public void setData(final byte[] data, final int offset, final int length) {
        this.data = data;
        this.dataOffset = offset;
        this.dataLength = length;
    }

    /**

            try {
                resultData.setData(data.getBytes(charsetName));
            } catch (final UnsupportedEncodingException e) {
                if (logger.isInfoEnabled()) {
                    logger.info("Invalid charsetName: " + charsetName + ". Changed to " + Constants.UTF_8, e);
                }
                charsetName = Constants.UTF_8_CHARSET.name();
                resultData.setData(data.getBytes(Constants.UTF_8_CHARSET));

                if (this.smb2) {
                    final Smb2WriteRequest wr = new Smb2WriteRequest(th.getConfig(), fh.getFileId());
                    wr.setOffset(this.fp);
                    wr.setData(b, off, w);

                    final Smb2WriteResponse resp = th.send(wr, RequestParam.NO_RETRY);
                    final long cnt = resp.getCount();
                    this.fp += cnt;

            
            // Create response with data from RDMA buffer
            Smb2ReadResponse response = new Smb2ReadResponse();
            response.setData(readBuffer.array(), 0, request.getLength());
            
            // Notify waiting thread
            request.setResponse(response);
            
        } finally {
            readRegion.close();

			Offset: frameSize,
			// Argsize set below.
		},
	}
	nameAddr.Sym.Func().Text = prog
	prog.To.Val = int32(argSize)
	p.append(prog, "", true)
}

// asmData assembles a DATA pseudo-op.
// DATA masks<>+0x00(SB)/4, $0x00000000
func (p *Parser) asmData(operands [][]lex.Token) {
	if len(operands) != 2 {
		p.errorf("expect two operands for DATA")
		return
	}

	// Operand 0 has the general form foo<>+0x04(SB)/4.

            }

            @Override
            public String getDataAsString() {
                return new String(data);
            }

            @Override
            public void setData(byte[] data) {
                this.data = data;
            }

            @Override
            public String getEncoding() {
                return encoding;
            }

            @Override

                    request.setOffset(this.fp);
                    request.setRemainingBytes(len - w - off);
                    request.setData(b, off, w);
                    final Smb2WriteResponse resp = th.send(request, RequestParam.NO_RETRY);
                    cnt = resp.getCount();
                } else {
                    final SmbComWriteAndX request =

            if (responseData != null) {
                dataMap.put("url", responseData.getUrl());
            }
            dataMap.put("content", "test content");
            resultData.setData(dataMap.toString().getBytes());
            return resultData;
        }

        @Override
        public String getName() {
            return "TestTransformer";
        }
    }

        try (final InputStream is = responseData.getResponseBody()) {
            final byte[] data = InputStreamUtil.getBytes(is);
            resultData.setData(data);
            resultData.setEncoding(responseData.getCharSet());
        } catch (final CrawlerSystemException e) {
            throw e;
        } catch (final Exception e) {