import org.jdeferred.DonePipe; //导入依赖的package包/类
private <D> DonePipe<D, BluetoothGattCharacteristic, BletiaException, Void> i2cSendConditionPipe(final int condition) {
    return new DonePipe<D, BluetoothGattCharacteristic, BletiaException, Void>() {
        @Override
        public Promise<BluetoothGattCharacteristic, BletiaException, Void> pipeDone(D result) {
            return execute(new I2cSendConditionAction(getKonashiService(), condition, mI2cStore));
        }
    };
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
/**
 * I2Cで指定したアドレスにデータを書き込む
 * @param length 書き込むデータ(byte)の長さ。最大 Konashi.I2C_DATA_MAX_LENGTH (19)byteまで
 * @param data 書き込むデータの配列
 * @param address 書き込み先アドレス
 */
public <D> DonePipe<D, BluetoothGattCharacteristic, BletiaException, Void> i2cWritePipe(final int length, final byte[] data, final byte address) {
    return new DonePipe<D, BluetoothGattCharacteristic, BletiaException, Void>() {
        @Override
        public Promise<BluetoothGattCharacteristic, BletiaException, Void> pipeDone(D result) {
            return i2cWrite(length, data, address);
        }
    };
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
/**
 * I2Cで指定したアドレスからデータを読み込むリクエストを行う
 * @param length 読み込むデータの長さ。最大 Konashi.I2C_DATA_MAX_LENGTHs (19)
 * @param address 読み込み先のアドレス
 */
public Promise<byte[], BletiaException, Void> i2cRead(int length, byte address) {
    return execute(new I2cSetReadParamAction(getKonashiService(), length, address, mI2cStore))
            .then(mI2cDispatcher)
            .then(new DonePipe<BluetoothGattCharacteristic, BluetoothGattCharacteristic, BletiaException, Void>() {
                @Override
                public Promise<BluetoothGattCharacteristic, BletiaException, Void> pipeDone(BluetoothGattCharacteristic result) {
                    return execute(new I2cReadAction(getKonashiService()));
                }
            })
            .then(new I2cReadFilter());
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
/**
 * I2Cで指定したアドレスからデータを読み込むリクエストを行う
 * @param length 読み込むデータの長さ。最大 Konashi.I2C_DATA_MAX_LENGTHs (19)
 * @param address 読み込み先のアドレス
 */
public <D> DonePipe<D, byte[], BletiaException, Void> i2cReadPipe(final int length, final byte address) {
    return new DonePipe<D, byte[], BletiaException, Void>() {
        @Override
        public Promise<byte[], BletiaException, Void> pipeDone(D result) {
            return i2cRead(length, address);
        }
    };
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
public Promise pushMethod(final ApiMethod method, final DelayedParams params) {
    // With this clear all references to previous onDone, onFail and onAlways callbacks, avoiding possible
    // memory leaks
    if (! masterPromise.isPending())
        masterPromise = new DeferredObject().resolve(model);

    if ( ! modelCacheEnable ) {
        method.setCacheDuration(DurationInMillis.ALWAYS_EXPIRED);
    }

    if ( forceNextCacheEnable != null ) {
        method.setCacheDuration(forceNextCacheEnable ? ApiMethod.globalCacheDuration.get() : DurationInMillis.ALWAYS_EXPIRED);
        forceNextCacheEnable = null;
    }

    if ( serially ){
        serially = false;
        return pushPipe(new DonePipe() {
                            @Override
                            public Deferred pipeDone(Object result) {
                                return method.run(params.buildParams(), params.buildUrlExtraSegments());
                            }
                        }, new FailPipe() {
                            @Override
                            public Deferred pipeFail(Object o) {
                                return new DeferredObject().reject(o);
                            }
                        });
    }
    else{
        return pushDeferred(method.run(params.buildParams(), params.buildUrlExtraSegments()));
    }
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
public Promise pushDeferred(final Deferred deferred){
    masterPromise = (Deferred) masterPromise.then(new DonePipe() {
        @Override
        public Deferred pipeDone(Object result) {
            return deferred;
        }
    }, new FailPipe() {
        @Override
        public Deferred pipeFail(Object result) {
            return new DeferredObject().reject(result);
        }
    });

    return masterPromise;
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
@Override
public <D_OUT, F_OUT, P_OUT> Promise<D_OUT, F_OUT, P_OUT> then(
		DonePipe<D, D_OUT, F_OUT, P_OUT> doneFilter,
		FailPipe<F, D_OUT, F_OUT, P_OUT> failFilter,
		ProgressPipe<P, D_OUT, F_OUT, P_OUT> progressFilter) {
	return new PipedPromise<D, F, P, D_OUT, F_OUT, P_OUT>(this, doneFilter, failFilter, progressFilter);
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
@Override
public <D_OUT, F_OUT, P_OUT> Promise<D_OUT, F_OUT, P_OUT> then(
		DonePipe<D, D_OUT, F_OUT, P_OUT> doneFilter,
		FailPipe<F, D_OUT, F_OUT, P_OUT> failFilter,
		ProgressPipe<P, D_OUT, F_OUT, P_OUT> progressFilter) {
	return promise.then(doneFilter, failFilter, progressFilter);
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
@Test
public void testDoneRewireFilter() {
	final ValueHolder<Integer> preRewireValue = new ValueHolder<Integer>();
	final ValueHolder<Integer> postRewireValue = new ValueHolder<Integer>();
	
	Callable<Integer> task = new Callable<Integer>() {
		public Integer call() {
			return 100;
		}
	};
	
	deferredManager.when(task).then(new DonePipe<Integer, Integer, Void, Void>() {
		@Override
		public Promise<Integer, Void, Void> pipeDone(Integer result) {
			preRewireValue.set(result);
			return new DeferredObject<Integer, Void, Void>().resolve(1000);
		}
	}).done(new DoneCallback<Integer>() {
		@Override
		public void onDone(Integer value) {
			postRewireValue.set(value);
		}
	});
	
	waitForCompletion();
	preRewireValue.assertEquals(100);
	postRewireValue.assertEquals(1000);
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
@Override
public <D_OUT, F_OUT, P_OUT> Promise<D_OUT, F_OUT, P_OUT> then(DonePipe<D, D_OUT, F_OUT, P_OUT> donePipe) {
    return getDelegate().then(donePipe);
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
/**
 * I2Cのスタートコンディションを発行する
 */
public <D> DonePipe<D, BluetoothGattCharacteristic, BletiaException, Void> i2cStartConditionPipe() {
    return i2cSendConditionPipe(Konashi.I2C_START_CONDITION);
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
/**
 * I2Cのリスタートコンディションを発行する
 */
public <D> DonePipe<D, BluetoothGattCharacteristic, BletiaException, Void> i2cRestartConditionPipe() {
    return i2cSendConditionPipe(Konashi.I2C_RESTART_CONDITION);
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
/**
 * I2Cのストップコンディションを発行する
 */
public <D> DonePipe<D, BluetoothGattCharacteristic, BletiaException, Void> i2cStopConditionPipe() {
    return i2cSendConditionPipe(Konashi.I2C_STOP_CONDITION);
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
public Promise pushPipe(DonePipe donePipe, FailPipe failPipe) {
    return apiMethodCtrl.pushPipe(donePipe, failPipe);
}
 

import org.jdeferred.DonePipe; //导入依赖的package包/类
public Promise pushPipe(DonePipe donePipe, FailPipe failPipe){
    masterPromise = (Deferred) masterPromise.then(donePipe,failPipe);
    return masterPromise;
}