Extracts the pre-operation attributes.
@param xdr
@return The attributes.
963742
private static NfsPreOpAttributes makePreOpAttributes(Xdr xdr) {
        NfsPreOpAttributes preOpAttributes = null;
        if ((xdr != null) && xdr.getBoolean()) {
            preOpAttributes = new NfsPreOpAttributes(xdr);
        }
        return preOpAttributes;
    }
515543
public void marshalling(Xdr xdr) {
        if ( !isBareTime() ) {
            xdr.putInt(_timeSettingType);
        }
        if ( captureTime() ) {
            xdr.putUnsignedInt(seconds);
            xdr.putUnsignedInt(nanoseconds);
        }
    }
63758
def to_xdr_object(self):
        

        def assert_option_array(x):
            if x is None:
                return []
            if not isinstance(x, list):
                return [x]
            return x

        if self.inflation_dest is not None:
            inflation_dest = [account_xdr_object(self.inflation_dest)]
        else:
            inflation_dest = []

        self.clear_flags = assert_option_array(self.clear_flags)
        self.set_flags = assert_option_array(self.set_flags)
        self.master_weight = assert_option_array(self.master_weight)
        self.low_threshold = assert_option_array(self.low_threshold)
        self.med_threshold = assert_option_array(self.med_threshold)
        self.high_threshold = assert_option_array(self.high_threshold)
        self.home_domain = assert_option_array(self.home_domain)

        req_signer_fields = (self.signer_address, self.signer_type,
                             self.signer_weight)

        if all(signer_field is not None for signer_field in req_signer_fields):
            signer = [
                Xdr.types.Signer(
                    signer_key_xdr_object(self.signer_type,
                                          self.signer_address),
                    self.signer_weight)
            ]
        else:
            signer = []

        set_options_op = Xdr.types.SetOptionsOp(
            inflation_dest, self.clear_flags, self.set_flags,
            self.master_weight, self.low_threshold, self.med_threshold,
            self.high_threshold, self.home_domain, signer)
        self.body.type = Xdr.const.SET_OPTIONS
        self.body.setOptionsOp = set_options_op
        return super(SetOptions, self).to_xdr_object()
1323010
public void unmarshalling(Xdr xdr) throws RpcException {
        super.unmarshalling(xdr);
        _mountStatus = xdr.getInt();
        if (_mountStatus == MountStatus.MNT3_OK.getValue()) {
            _rootFileHandle = xdr.getByteArray();
            int numsec = xdr.getInt();
            _authenticationFlavors = new int[numsec];
            for (int i = 0; i < numsec; ++i) {
                _authenticationFlavors[i] = xdr.getInt();
            }
        }
    }
93271
public void marshalling(Xdr xdr) {
        xdr.putInt(getCredentialFlavor()); // credential flavor
        xdr.putByteArray(getCredential()); // bytes of credentials
        xdr.putInt(getVerifierFlavor()); // verifier flavor
        xdr.putByteArray(getVerifier()); // bytes of verifier
    }
588338
def to_xdr_object(self):
        """"""
        return Xdr.types.Memo(
            type=Xdr.const.MEMO_RETURN, retHash=self.memo_return)
1027329
protected void unmarshallingFileHandle(Xdr xdr, boolean force) {
        if (force || xdr.getBoolean()) {
            _fileHandle = xdr.getByteArray();
        }
    }
122966
public Map<String, String> extractDrivers(XEvent event) {
		return XCostDriver.instance().extractValues(event);
	}
105153
private void xdr_int(int i) {
    buffer[offset++] = (byte)((i >> 24) & 0xff);
    buffer[offset++] = (byte)((i >> 16) & 0xff);
    buffer[offset++] = (byte)((i >> 8) & 0xff);
    buffer[offset++] = (byte)(i & 0xff);
  }
8352
public void unmarshalling(Xdr xdr) throws RpcException {
        super.unmarshalling(xdr);
        if (stateIsOk()) {
            unmarshallingFileHandle(xdr);
            unmarshallingAttributes(xdr);
        }
        _directoryWccData = new NfsWccData(xdr);
    }
163855
public String extractInstance(XEvent event) {
		XAttribute attribute = event.getAttributes().get(KEY_INSTANCE);
		if (attribute == null) {
			return null;
		} else {
			return ((XAttributeLiteral) attribute).getValue();
		}
	}
321409
def to_xdr_object(self):
        """"""
        return Xdr.types.Memo(type=Xdr.const.MEMO_HASH, hash=self.memo_hash)
828665
def from_xdr_object(cls, op_xdr_object):
        
        if not op_xdr_object.sourceAccount:
            source = None
        else:
            source = encode_check(
                'account', op_xdr_object.sourceAccount[0].ed25519).decode()

        line = Asset.from_xdr_object(op_xdr_object.body.changeTrustOp.line)
        limit = Operation.from_xdr_amount(
            op_xdr_object.body.changeTrustOp.limit)

        return cls(source=source, asset=line, limit=limit)
89088
@SuppressWarnings("unchecked")
    public static <T> Expression<T> extract(Expression<T> expr) {
        if (expr != null) {
            final Class<?> clazz = expr.getClass();
            if (clazz == PathImpl.class || clazz == PredicateOperation.class || clazz == ConstantImpl.class) {
                return expr;
            } else {
                return (Expression<T>) expr.accept(ExtractorVisitor.DEFAULT, null);
            }
        } else {
            return null;
        }
    }
1316728
def to_xdr_object(self):
        """"""
        return Xdr.types.Memo(type=Xdr.const.MEMO_TEXT, text=self.text)
357007
def xdr(self):
        
        kp = Xdr.StellarXDRPacker()
        kp.pack_PublicKey(self.account_xdr_object())
        return base64.b64encode(kp.get_buffer())
1028593
public void unmarshalling(Xdr xdr) throws RpcException {
        super.unmarshalling(xdr);
        if (stateIsOk()) {
            unmarshallingFileHandle(xdr, true);
            unmarshallingAttributes(xdr);
        }
        _directoryAttributes = makeNfsGetAttributes(xdr);
    }