All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.wandoulabs.nedis.PromiseConverter Maven / Gradle / Ivy

    /**
 * Copyright (c) 2015 Wandoujia Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.wandoulabs.nedis;

import static com.wandoulabs.nedis.util.NedisUtils.bytesToDouble;
import static com.wandoulabs.nedis.util.NedisUtils.newBytesKeyMap;
import static com.wandoulabs.nedis.util.NedisUtils.newBytesSet;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.FutureListener;
import io.netty.util.concurrent.Promise;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.wandoulabs.nedis.exception.RedisResponseException;
import com.wandoulabs.nedis.handler.RedisResponseDecoder;
import com.wandoulabs.nedis.protocol.HashEntry;
import com.wandoulabs.nedis.protocol.ScanResult;
import com.wandoulabs.nedis.protocol.SortedSetEntry;

/**
 * Convert redis response to give type.
 * 
 * @author Apache9
 */
abstract class PromiseConverter {

    private final EventExecutor executor;

    public PromiseConverter(EventExecutor executor) {
        this.executor = executor;
    }

    public abstract FutureListener newListener(Promise promise);

    public Promise newPromise() {
        return executor.newPromise();
    }

    public static PromiseConverter> toList(EventExecutor executor) {
        return new PromiseConverter>(executor) {

            @Override
            public FutureListener newListener(final Promise> promise) {
                return new FutureListener() {

                    @SuppressWarnings("unchecked")
                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(null);
                            } else {
                                promise.trySuccess((List) resp);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter toBoolean(EventExecutor executor) {
        return new PromiseConverter(executor) {

            @Override
            public FutureListener newListener(final Promise promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(false);
                            } else if (resp instanceof String) {
                                promise.trySuccess(true);
                            } else {
                                promise.trySuccess(((Long) resp).intValue() != 0);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter toBytes(EventExecutor executor) {
        return new PromiseConverter(executor) {

            @Override
            public FutureListener newListener(final Promise promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(null);
                            } else {
                                promise.trySuccess((byte[]) resp);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter toDouble(EventExecutor executor) {
        return new PromiseConverter(executor) {

            @Override
            public FutureListener newListener(final Promise promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(null);
                            } else {
                                promise.trySuccess(bytesToDouble((byte[]) resp));
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter toLong(EventExecutor executor) {
        return new PromiseConverter(executor) {

            @Override
            public FutureListener newListener(final Promise promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(null);
                            } else {
                                promise.trySuccess((Long) resp);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter toObject(EventExecutor executor) {
        return new PromiseConverter(executor) {

            @Override
            public FutureListener newListener(final Promise promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(null);
                            } else {
                                promise.trySuccess(resp);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter toString(EventExecutor executor) {
        return new PromiseConverter(executor) {

            @Override
            public FutureListener newListener(final Promise promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(null);
                            } else {
                                promise.trySuccess(resp.toString());
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter toVoid(EventExecutor executor) {
        return new PromiseConverter(executor) {

            @Override
            public FutureListener newListener(final Promise promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else {
                                promise.trySuccess(null);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter> toArrayScanResult(EventExecutor executor) {
        return new PromiseConverter>(executor) {

            @Override
            public FutureListener newListener(final Promise> promise) {
                return new FutureListener() {

                    @SuppressWarnings("unchecked")
                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else {
                                List list = (List) resp;
                                promise.trySuccess(new ScanResult((byte[]) list.get(0),
                                        (List) list.get(1)));
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter> toHashScanResult(EventExecutor executor) {
        return new PromiseConverter>(executor) {

            @Override
            public FutureListener newListener(final Promise> promise) {
                return new FutureListener() {

                    @SuppressWarnings("unchecked")
                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else {
                                List list = (List) resp;
                                byte[] cursor = (byte[]) list.get(0);
                                List rawValueList = (List) list.get(1);
                                List values = new ArrayList<>(rawValueList.size() / 2);
                                for (Iterator iter = rawValueList.iterator(); iter
                                        .hasNext();) {
                                    values.add(new HashEntry(iter.next(), iter.next()));
                                }
                                promise.trySuccess(new ScanResult(cursor, values));
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter> toSortedSetScanResult(
            EventExecutor executor) {
        return new PromiseConverter>(executor) {

            @Override
            public FutureListener newListener(
                    final Promise> promise) {
                return new FutureListener() {

                    @SuppressWarnings("unchecked")
                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else {
                                List list = (List) resp;
                                byte[] cursor = (byte[]) list.get(0);
                                List rawValueList = (List) list.get(1);
                                List values = new ArrayList<>(
                                        rawValueList.size() / 2);
                                for (Iterator iter = rawValueList.iterator(); iter
                                        .hasNext();) {
                                    values.add(new SortedSetEntry(iter.next(), bytesToDouble(iter
                                            .next())));
                                }
                                promise.trySuccess(new ScanResult(cursor, values));
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter> toMap(EventExecutor executor) {
        return new PromiseConverter>(executor) {

            @Override
            public FutureListener newListener(final Promise> promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else {
                                @SuppressWarnings("unchecked")
                                List rawValueList = (List) resp;
                                Map values = newBytesKeyMap();
                                for (Iterator iter = rawValueList.iterator(); iter
                                        .hasNext();) {
                                    values.put(iter.next(), iter.next());
                                }
                                promise.trySuccess(values);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter> toSet(EventExecutor executor) {
        return new PromiseConverter>(executor) {

            @Override
            public FutureListener newListener(final Promise> promise) {
                return new FutureListener() {

                    @SuppressWarnings("unchecked")
                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(null);
                            } else {
                                Set values = newBytesSet();
                                values.addAll((List) resp);
                                promise.trySuccess(values);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter> toSortedSetEntryList(EventExecutor executor) {
        return new PromiseConverter>(executor) {

            @Override
            public FutureListener newListener(final Promise> promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else {
                                @SuppressWarnings("unchecked")
                                List rawValueList = (List) resp;
                                List values = new ArrayList<>(
                                        rawValueList.size() / 2);
                                for (Iterator iter = rawValueList.iterator(); iter
                                        .hasNext();) {
                                    values.add(new SortedSetEntry(iter.next(), bytesToDouble(iter
                                            .next())));
                                }
                                promise.trySuccess(values);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter> toBooleanList(EventExecutor executor) {
        return new PromiseConverter>(executor) {

            @Override
            public FutureListener newListener(final Promise> promise) {
                return new FutureListener() {

                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(null);
                            } else {
                                @SuppressWarnings("unchecked")
                                List rawValueList = (List) resp;
                                List values = new ArrayList<>(rawValueList.size());
                                for (long l: rawValueList) {
                                    values.add(l != 0L);
                                }
                                promise.trySuccess(values);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }

    public static PromiseConverter> toObjectList(EventExecutor executor) {
        return new PromiseConverter>(executor) {

            @Override
            public FutureListener newListener(final Promise> promise) {
                return new FutureListener() {

                    @SuppressWarnings("unchecked")
                    @Override
                    public void operationComplete(Future future) throws Exception {
                        if (future.isSuccess()) {
                            Object resp = future.getNow();
                            if (resp instanceof RedisResponseException) {
                                promise.tryFailure((RedisResponseException) resp);
                            } else if (resp == RedisResponseDecoder.NULL_REPLY) {
                                promise.trySuccess(null);
                            } else {
                                promise.trySuccess((List) resp);
                            }
                        } else {
                            promise.tryFailure(future.cause());
                        }
                    }
                };
            }
        };
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy