*/
    public abstract void encode(NdrBuffer dst) throws NdrException;

    /**
     * Decodes this NDR object from the specified buffer
     * @param src the source buffer for decoding
     * @throws NdrException if decoding fails
     */
    public abstract void decode(NdrBuffer src) throws NdrException;

	for _, rule := range lc.Rules {
		if !rule.Expiration.IsNull() || !rule.NoncurrentVersionExpiration.IsNull() {
			return true
		}
	}
	return false
}

// UnmarshalXML - decodes XML data.
func (lc *Lifecycle) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
	switch start.Name.Local {
	case "LifecycleConfiguration", "BucketLifecycleConfiguration":
	default:

	if (s == SourceSelectionCriteria{}) {
		return nil
	}
	if !s.IsValid() {
		return errInvalidSourceSelectionCriteria
	}
	return nil
}

// UnmarshalXML - decodes XML data.
func (s *SourceSelectionCriteria) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) (err error) {
	// Make subtype to avoid recursive UnmarshalXML().
	type sourceSelectionCriteria SourceSelectionCriteria
	ssc := sourceSelectionCriteria{}

}

// MarshalXML - encodes to XML data.
func (arn ARN) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	return e.EncodeElement(arn.String(), start)
}

// UnmarshalXML - decodes XML data.
func (arn *ARN) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	var s string
	if err := d.DecodeElement(&s, &start); err != nil {
		return err
	}

	parsedARN, err := parseARN(s)
	if err != nil {
		return err
	}

    class IntegrationTests {

        @Test
        @DisplayName("Should maintain state after multiple decodes")
        void testMultipleDecodes() throws SMBProtocolDecodingException {
            // First decode
            byte[] buffer1 = createValidCopyChunkResponse(1, 1024, 1024);
            response.decode(buffer1, 0, buffer1.length);
            assertEquals(1, response.getChunksWritten());

	errDuplicatedXMLTag = Errorf("duplicated XML Tag")
	errUnknownXMLTag    = Errorf("unknown XML Tag")
)

// UnmarshalXML - decodes XML data.
func (tag *Tag) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
	var keyAlreadyParsed, valueAlreadyParsed bool
	for {
		// Read tokens from the XML document in a stream.
		t, err := d.Token()
		if err != nil {

		case []byte:
			bytesValue = v
		default:
			return fmt.Errorf("failed to unmarshal gob value: %#v", dbValue)
		}
		if len(bytesValue) > 0 {
			decoder := gob.NewDecoder(bytes.NewBuffer(bytesValue))
			err = decoder.Decode(fieldValue.Interface())
		}
	}
	field.ReflectValueOf(ctx, dst).Set(fieldValue.Elem())
	return
}

// Value implements serializer interface

        originalContext.encode(buffer, 0);

        // Create a new context and decode
        DirectoryLeaseContext decodedContext = new DirectoryLeaseContext(new Smb2LeaseKey(), 0, DirectoryCacheScope.IMMEDIATE_CHILDREN);
        decodedContext.decode(buffer, 0, buffer.length);

        // Verify decoded values
        assertArrayEquals(originalKey.getKey(), decodedContext.getLeaseKey().getKey());

		Result bool `json:"result"`
	}

	respBody := bytes.NewReader(opaRespBytes)

	var result opaResult
	if err = json.NewDecoder(respBody).Decode(&result); err != nil {
		respBody.Seek(0, 0)
		var resultAllow opaResultAllow
		if err = json.NewDecoder(respBody).Decode(&resultAllow); err != nil {
			return false, err
		}
		return resultAllow.Result.Allow, nil
	}

	return result.Result, nil

    }

    @ParameterizedTest
    @MethodSource("int32Provider")
    @DisplayName("readParameterWordsWireFormat correctly decodes 32-bit offset")
    void testReadParameterWords(int expectedInt, byte[] bytes) {
        // The implementation reads via SMBUtil.readInt4 which returns an int
        // When assigned to a long field, it gets sign-extended