@urvish-procare/react-native-charts-wrapper 0.6.0

package/android/src/main/java/com/github/wuxudong/rncharts/data/BarDataExtract.java

@@ -0,0 +1,106 @@
+package com.github.wuxudong.rncharts.data;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.data.BarData;
+import com.github.mikephil.charting.data.BarDataSet;
+import com.github.mikephil.charting.data.BarEntry;
+import com.github.mikephil.charting.interfaces.datasets.IDataSet;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+import com.github.wuxudong.rncharts.utils.ChartDataSetConfigUtils;
+import com.github.wuxudong.rncharts.utils.ConversionUtil;
+
+import java.util.ArrayList;
+
+/**
+ * Created by xudong on 02/03/2017.
+ */
+public class BarDataExtract extends DataExtract<BarData, BarEntry> {
+    @Override
+    BarData createData() {
+        return new BarData();
+    }
+
+    @Override
+    IDataSet<BarEntry> createDataSet(ArrayList<BarEntry> entries, String label) {
+        return new BarDataSet(entries, label);
+    }
+
+    @Override
+    BarEntry createEntry(ReadableArray values, int index) {
+        BarEntry entry;
+
+        float x = index;
+        if (ReadableType.Map.equals(values.getType(index))) {
+            ReadableMap map = values.getMap(index);
+
+            if (map.hasKey("x")) {
+                x = (float) map.getDouble("x");
+            }
+
+            if (ReadableType.Array.equals(map.getType("y"))) {
+                entry = new BarEntry(x, BridgeUtils.convertToFloatArray(map.getArray("y")));
+            } else if (ReadableType.Number.equals(map.getType("y"))) {
+                entry = new BarEntry(x, (float) map.getDouble("y"));
+            } else {
+                throw new IllegalArgumentException("Unexpected entry type: " + values.getType(index));
+            }
+
+            entry.setData(ConversionUtil.toMap(map));
+
+        } else if (ReadableType.Array.equals(values.getType(index))) {
+            entry = new BarEntry(x, BridgeUtils.convertToFloatArray(values.getArray(index)));
+        } else if (ReadableType.Number.equals(values.getType(index))) {
+            entry = new BarEntry(x, (float) values.getDouble(index));
+        } else {
+            throw new IllegalArgumentException("Unexpected entry type: " + values.getType(index));
+        }
+
+        return entry;
+    }
+
+    @Override
+    void dataSetConfig(Chart chart, IDataSet<BarEntry> dataSet, ReadableMap config) {
+        BarDataSet barDataSet = (BarDataSet) dataSet;
+
+        ChartDataSetConfigUtils.commonConfig(chart, barDataSet, config);
+        ChartDataSetConfigUtils.commonBarLineScatterCandleBubbleConfig(barDataSet, config);
+
+        if (BridgeUtils.validate(config, ReadableType.Number, "barShadowColor")) {
+            barDataSet.setBarShadowColor(config.getInt("barShadowColor"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "highlightAlpha")) {
+            barDataSet.setHighLightAlpha(config.getInt("highlightAlpha"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Array, "stackLabels")) {
+            barDataSet.setStackLabels(BridgeUtils.convertToStringArray(config.getArray("stackLabels")));
+        }
+    }
+
+    @Override
+    void dataConfig(BarData data, ReadableMap config) {
+        super.dataConfig(data, config);
+
+        if (BridgeUtils.validate(config, ReadableType.Number, "barWidth")) {
+            data.setBarWidth((float) config.getDouble("barWidth"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Map, "group")) {
+            ReadableMap propMap = config.getMap("group");
+            if (BridgeUtils.validate(propMap, ReadableType.Number, "fromX") &&
+                    BridgeUtils.validate(propMap, ReadableType.Number, "groupSpace") &&
+                    BridgeUtils.validate(propMap, ReadableType.Number, "barSpace")
+                    ) {
+                float fromX = (float) propMap.getDouble("fromX");
+                float groupSpace = (float) propMap.getDouble("groupSpace");
+                float barSpace = (float) propMap.getDouble("barSpace");
+
+                data.groupBars(fromX, groupSpace, barSpace);
+            }
+        }
+
+
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/data/BubbleDataExtract.java

@@ -0,0 +1,74 @@
+package com.github.wuxudong.rncharts.data;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.data.BubbleData;
+import com.github.mikephil.charting.data.BubbleDataSet;
+import com.github.mikephil.charting.data.BubbleEntry;
+import com.github.mikephil.charting.interfaces.datasets.IDataSet;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+import com.github.wuxudong.rncharts.utils.ChartDataSetConfigUtils;
+import com.github.wuxudong.rncharts.utils.ConversionUtil;
+
+import java.util.ArrayList;
+
+/**
+ * Created by xudong on 02/03/2017.
+ */
+public class BubbleDataExtract extends DataExtract<BubbleData, BubbleEntry> {
+    @Override
+    BubbleData createData() {
+        return new BubbleData();
+    }
+
+
+    @Override
+    IDataSet<BubbleEntry> createDataSet(ArrayList<BubbleEntry> entries, String label) {
+        return new BubbleDataSet(entries, label);
+    }
+
+    @Override
+    void dataSetConfig(Chart chart, IDataSet<BubbleEntry> dataSet, ReadableMap config) {
+        BubbleDataSet bubbleDataSet = (BubbleDataSet) dataSet;
+
+        ChartDataSetConfigUtils.commonConfig(chart, bubbleDataSet, config);
+        ChartDataSetConfigUtils.commonBarLineScatterCandleBubbleConfig(bubbleDataSet, config);
+
+        // BubbleDataSet only config
+        if (BridgeUtils.validate(config, ReadableType.Number, "highlightCircleWidth")) {
+            bubbleDataSet.setHighlightCircleWidth((float) config.getDouble("highlightCircleWidth"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "normalizeSizeEnabled")) {
+            bubbleDataSet.setNormalizeSizeEnabled(config.getBoolean("normalizeSizeEnabled"));
+        }
+    }
+
+    @Override
+    BubbleEntry createEntry(ReadableArray values, int index) {
+        if (!ReadableType.Map.equals(values.getType(index))) {
+            throw new IllegalArgumentException("Invalid BubbleEntry data");
+        }
+
+        ReadableMap map = values.getMap(index);
+
+        float x = index;
+        if (map.hasKey("x")) {
+            x = (float) map.getDouble("x");
+        }
+
+        if (!BridgeUtils.validate(map, ReadableType.Number, "y") ||
+                !BridgeUtils.validate(map, ReadableType.Number, "size")) {
+            throw new IllegalArgumentException("Invalid BubbleEntry data");
+        }
+
+
+        float y = (float) map.getDouble("y");
+        float size = (float) map.getDouble("size");
+
+        BubbleEntry bubbleEntry = new BubbleEntry(x, y, size, ConversionUtil.toMap(map));
+
+        return bubbleEntry;
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/data/CandleDataExtract.java

@@ -0,0 +1,102 @@
+package com.github.wuxudong.rncharts.data;
+
+import android.graphics.Paint;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.data.CandleData;
+import com.github.mikephil.charting.data.CandleDataSet;
+import com.github.mikephil.charting.data.CandleEntry;
+import com.github.mikephil.charting.interfaces.datasets.IDataSet;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+import com.github.wuxudong.rncharts.utils.ChartDataSetConfigUtils;
+import com.github.wuxudong.rncharts.utils.ConversionUtil;
+
+import java.util.ArrayList;
+import java.util.Locale;
+
+/**
+ * Created by xudong on 02/03/2017.
+ */
+public class CandleDataExtract extends DataExtract<CandleData, CandleEntry> {
+    @Override
+    CandleData createData() {
+        return new CandleData();
+    }
+
+    @Override
+    IDataSet<CandleEntry> createDataSet(ArrayList<CandleEntry> entries, String label) {
+        return new CandleDataSet(entries, label);
+    }
+
+    @Override
+    void dataSetConfig(Chart chart, IDataSet<CandleEntry> dataSet, ReadableMap config) {
+        CandleDataSet candleDataSet = (CandleDataSet) dataSet;
+
+        ChartDataSetConfigUtils.commonConfig(chart, candleDataSet, config);
+        ChartDataSetConfigUtils.commonBarLineScatterCandleBubbleConfig(candleDataSet, config);
+        ChartDataSetConfigUtils.commonLineScatterCandleRadarConfig(candleDataSet, config);
+
+        // CandleDataSet only config
+        if (BridgeUtils.validate(config, ReadableType.Number, "barSpace")) {
+            candleDataSet.setBarSpace((float) config.getDouble("barSpace"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "shadowWidth")) {
+            candleDataSet.setShadowWidth((float) config.getDouble("shadowWidth"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "shadowColor")) {
+            candleDataSet.setShadowColor(config.getInt("shadowColor"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "shadowColorSameAsCandle")) {
+            candleDataSet.setShadowColorSameAsCandle(config.getBoolean("shadowColorSameAsCandle"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "neutralColor")) {
+            candleDataSet.setNeutralColor(config.getInt("neutralColor"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "decreasingColor")) {
+            candleDataSet.setDecreasingColor(config.getInt("decreasingColor"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.String, "decreasingPaintStyle")) {
+            candleDataSet.setDecreasingPaintStyle(Paint.Style.valueOf(config.getString("decreasingPaintStyle").toUpperCase(Locale.ENGLISH)));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "increasingColor")) {
+            candleDataSet.setIncreasingColor(config.getInt("increasingColor"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.String, "increasingPaintStyle")) {
+            candleDataSet.setIncreasingPaintStyle(Paint.Style.valueOf(config.getString("increasingPaintStyle").toUpperCase(Locale.ENGLISH)));
+        }
+    }
+
+    @Override
+    CandleEntry createEntry(ReadableArray values, int index) {
+        if (!ReadableType.Map.equals(values.getType(index))) {
+            throw new IllegalArgumentException();
+        }
+
+        ReadableMap map = values.getMap(index);
+
+        float x = index;
+        if (map.hasKey("x")) {
+            x = (float) map.getDouble("x");
+        }
+
+        if (
+                !BridgeUtils.validate(map, ReadableType.Number, "shadowH") ||
+                        !BridgeUtils.validate(map, ReadableType.Number, "shadowL") ||
+                        !BridgeUtils.validate(map, ReadableType.Number, "open") ||
+                        !BridgeUtils.validate(map, ReadableType.Number, "close")) {
+            throw new IllegalArgumentException("CandleStick data must contain: shadowH, shadowL, open and close values");
+        }
+
+        float shadowH = (float) map.getDouble("shadowH");
+        float shadowL = (float) map.getDouble("shadowL");
+        float open = (float) map.getDouble("open");
+        float close = (float) map.getDouble("close");
+
+        CandleEntry candleEntry = new CandleEntry(x, shadowH, shadowL, open, close, ConversionUtil.toMap(map));
+
+        return candleEntry;
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/data/CombinedDataExtract.java

@@ -0,0 +1,70 @@
+package com.github.wuxudong.rncharts.data;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.data.CombinedData;
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.interfaces.datasets.IDataSet;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+
+import java.util.ArrayList;
+
+/**
+ * Created by xudong on 02/03/2017.
+ */
+public class CombinedDataExtract extends DataExtract<CombinedData, Entry> {
+    private LineDataExtract lineDataExtract = new LineDataExtract();
+    private BarDataExtract barDataExtract = new BarDataExtract();
+    private ScatterDataExtract scatterDataExtract = new ScatterDataExtract();
+    private CandleDataExtract candleDataExtract = new CandleDataExtract();
+    private BubbleDataExtract bubbleDataExtract = new BubbleDataExtract();
+
+    @Override
+    public CombinedData extract(Chart chart, ReadableMap propMap) {
+        CombinedData chartData = new CombinedData();
+
+        if (BridgeUtils.validate(propMap, ReadableType.Map, "lineData")) {
+            chartData.setData(lineDataExtract.extract(chart, propMap.getMap("lineData")));
+        }
+
+        if (BridgeUtils.validate(propMap, ReadableType.Map, "barData")) {
+            chartData.setData(barDataExtract.extract(chart, propMap.getMap("barData")));
+        }
+
+        if (BridgeUtils.validate(propMap, ReadableType.Map, "scatterData")) {
+            chartData.setData(scatterDataExtract.extract(chart, propMap.getMap("scatterData")));
+        }
+
+        if (BridgeUtils.validate(propMap, ReadableType.Map, "candleData")) {
+            chartData.setData(candleDataExtract.extract(chart, propMap.getMap("candleData")));
+        }
+
+        if (BridgeUtils.validate(propMap, ReadableType.Map, "bubbleData")) {
+            chartData.setData(bubbleDataExtract.extract(chart, propMap.getMap("bubbleData")));
+        }
+
+        return chartData;
+    }
+
+    @Override
+    CombinedData createData() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    IDataSet<Entry> createDataSet(ArrayList<Entry> entries, String label) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    void dataSetConfig(Chart chart, IDataSet<Entry> dataSet, ReadableMap config) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    Entry createEntry(ReadableArray values, int index) {
+        throw new UnsupportedOperationException();
+    }
+}

package/android/src/main/java/com/github/wuxudong/rncharts/data/DataExtract.java

@@ -0,0 +1,77 @@
+package com.github.wuxudong.rncharts.data;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.data.ChartData;
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.interfaces.datasets.IDataSet;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+
+import java.util.ArrayList;
+
+/**
+ * Created by xudong on 02/03/2017.
+ */
+
+public abstract class DataExtract<D extends ChartData, U extends Entry> {
+
+    public D extract(Chart chart, ReadableMap propMap) {
+        if (!BridgeUtils.validate(propMap, ReadableType.Array, "dataSets")) {
+            return null;
+        }
+
+        D chartData = createData();
+
+
+        ReadableArray dataSets = propMap.getArray("dataSets");
+        for (int i = 0; i < dataSets.size(); i++) {
+            ReadableMap dataSetReadableMap = dataSets.getMap(i);
+
+            // TODO validation
+            ReadableArray values = dataSetReadableMap.getArray("values");
+            String label = dataSetReadableMap.getString("label");
+
+            ArrayList<U> entries = createEntries(values);
+
+            IDataSet<U> dataSet = createDataSet(entries, label);
+
+            if (BridgeUtils.validate(dataSetReadableMap, ReadableType.Map, "config")) {
+                dataSetConfig(chart, dataSet, dataSetReadableMap.getMap("config"));
+            }
+
+            chartData.addDataSet(dataSet);
+        }
+
+        if (BridgeUtils.validate(propMap, ReadableType.Map, "config")) {
+            dataConfig(chartData, propMap.getMap("config"));
+        }
+
+
+        return chartData;
+    }
+
+    abstract D createData();
+
+    void dataConfig(D data, ReadableMap config) {
+    }
+
+    abstract IDataSet<U> createDataSet(ArrayList<U> entries, String label);
+
+    abstract void dataSetConfig(Chart chart, IDataSet<U> dataSet, ReadableMap config);
+
+    ArrayList<U> createEntries(ReadableArray yValues) {
+        ArrayList<U> entries = new ArrayList<>(yValues.size());
+        for (int j = 0; j < yValues.size(); j++) {
+            if (!yValues.isNull(j)) {
+                entries.add(createEntry(yValues, j));
+            }
+        }
+        return entries;
+    }
+
+    abstract U createEntry(ReadableArray values, int index);
+
+
+}

package/android/src/main/java/com/github/wuxudong/rncharts/data/LineDataExtract.java

@@ -0,0 +1,130 @@
+package com.github.wuxudong.rncharts.data;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.data.Entry;
+import com.github.mikephil.charting.data.LineData;
+import com.github.mikephil.charting.data.LineDataSet;
+import com.github.mikephil.charting.interfaces.datasets.IDataSet;
+import com.github.wuxudong.rncharts.charts.ConfigurableMinimumLinePositionFillFormatter;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+import com.github.wuxudong.rncharts.utils.ChartDataSetConfigUtils;
+import com.github.wuxudong.rncharts.utils.ConversionUtil;
+import com.github.wuxudong.rncharts.utils.DrawableUtils;
+
+import java.lang.Exception;
+import java.util.ArrayList;
+
+
+/**
+ * Created by xudong on 02/03/2017.
+ */
+public class LineDataExtract extends DataExtract<LineData, Entry> {
+    @Override
+    LineData createData() {
+        return new LineData();
+    }
+
+
+    @Override
+    IDataSet<Entry> createDataSet(ArrayList<Entry> entries, String label) {
+        return new LineDataSet(entries, label);
+    }
+
+    @Override
+    void dataSetConfig(Chart chart, IDataSet<Entry> dataSet, ReadableMap config) {
+        LineDataSet lineDataSet = (LineDataSet) dataSet;
+
+        ChartDataSetConfigUtils.commonConfig(chart, lineDataSet, config);
+        ChartDataSetConfigUtils.commonBarLineScatterCandleBubbleConfig(lineDataSet, config);
+        ChartDataSetConfigUtils.commonLineScatterCandleRadarConfig(lineDataSet, config);
+        ChartDataSetConfigUtils.commonLineRadarConfig(lineDataSet, config);
+
+        // LineDataSet only config
+        if (BridgeUtils.validate(config, ReadableType.Number, "circleRadius")) {
+            lineDataSet.setCircleRadius((float) config.getDouble("circleRadius"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "drawCircles")) {
+            lineDataSet.setDrawCircles(config.getBoolean("drawCircles"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.String, "mode")) {
+            lineDataSet.setMode(LineDataSet.Mode.valueOf(config.getString("mode")));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "drawCubicIntensity")) {
+            lineDataSet.setCubicIntensity((float) config.getDouble("drawCubicIntensity"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "circleColor")) {
+            lineDataSet.setCircleColor(config.getInt("circleColor"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Array, "circleColors")) {
+            lineDataSet.setCircleColors(BridgeUtils.convertToIntArray(config.getArray("circleColors")));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "circleHoleColor")) {
+            lineDataSet.setCircleHoleColor(config.getInt("circleHoleColor"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "drawCircleHole")) {
+            lineDataSet.setDrawCircleHole(config.getBoolean("drawCircleHole"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Map, "dashedLine")) {
+            ReadableMap dashedLine = config.getMap("dashedLine");
+            float lineLength = 0;
+            float spaceLength = 0;
+            float phase = 0;
+
+            if (BridgeUtils.validate(dashedLine, ReadableType.Number, "lineLength")) {
+                lineLength = (float) dashedLine.getDouble("lineLength");
+            }
+            if (BridgeUtils.validate(dashedLine, ReadableType.Number, "spaceLength")) {
+                spaceLength = (float) dashedLine.getDouble("spaceLength");
+            }
+            if (BridgeUtils.validate(dashedLine, ReadableType.Number, "phase")) {
+                phase = (float) dashedLine.getDouble("phase");
+            }
+
+            lineDataSet.enableDashedLine(lineLength, spaceLength, phase);
+        }
+        if (BridgeUtils.validate(config, ReadableType.Map, "fillFormatter")) {
+            ReadableMap fillFormatter = config.getMap("fillFormatter");
+            float min = 0F;
+
+            if (BridgeUtils.validate(fillFormatter, ReadableType.Number, "min")) {
+                min = (float) fillFormatter.getDouble("min");
+            }
+            lineDataSet.setFillFormatter(new ConfigurableMinimumLinePositionFillFormatter(min));
+        }
+    }
+
+    @Override
+    Entry createEntry(ReadableArray values, int index) {
+        float x = index;
+
+        Entry entry;
+        if (ReadableType.Map.equals(values.getType(index))) {
+            ReadableMap map = values.getMap(index);
+            if (map.hasKey("x")) {
+                x = (float) map.getDouble("x");
+            }
+
+            if (map.hasKey("icon")) {
+                ReadableMap icon = map.getMap("icon");
+                ReadableMap bundle = icon.getMap("bundle");
+                int width = icon.getInt("width");
+                int height = icon.getInt("height");
+                entry = new Entry(x, (float) map.getDouble("y"), DrawableUtils.drawableFromUrl(bundle.getString("uri"), width, height));
+
+            } else {
+                entry = new Entry(x, (float) map.getDouble("y"), ConversionUtil.toMap(map));
+            }
+        } else if (ReadableType.Number.equals(values.getType(index))) {
+            entry = new Entry(x, (float) values.getDouble(index));
+        } else {
+            throw new IllegalArgumentException("Unexpected entry type: " + values.getType(index));
+        }
+
+        return entry;
+    }
+
+
+}

package/android/src/main/java/com/github/wuxudong/rncharts/data/PieDataExtract.java

@@ -0,0 +1,101 @@
+package com.github.wuxudong.rncharts.data;
+
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.github.mikephil.charting.charts.Chart;
+import com.github.mikephil.charting.data.PieData;
+import com.github.mikephil.charting.data.PieDataSet;
+import com.github.mikephil.charting.data.PieEntry;
+import com.github.mikephil.charting.interfaces.datasets.IDataSet;
+import com.github.wuxudong.rncharts.utils.BridgeUtils;
+import com.github.wuxudong.rncharts.utils.ChartDataSetConfigUtils;
+import com.github.wuxudong.rncharts.utils.ConversionUtil;
+
+import java.util.ArrayList;
+import java.util.Locale;
+
+/**
+ * Created by xudong on 02/03/2017.
+ */
+public class PieDataExtract extends DataExtract<PieData, PieEntry> {
+    @Override
+    PieData createData() {
+        return new PieData();
+    }
+
+    @Override
+    IDataSet<PieEntry> createDataSet(ArrayList<PieEntry> entries, String label) {
+        return new PieDataSet(entries, label);
+    }
+
+    @Override
+    void dataSetConfig(Chart chart, IDataSet<PieEntry> dataSet, ReadableMap config) {
+        PieDataSet pieDataSet = (PieDataSet) dataSet;
+
+        ChartDataSetConfigUtils.commonConfig(chart, pieDataSet, config);
+
+        // PieDataSet only config
+        if (BridgeUtils.validate(config, ReadableType.Number, "sliceSpace")) {
+            pieDataSet.setSliceSpace((float) config.getDouble("sliceSpace"));
+        }
+        if (BridgeUtils.validate(config, ReadableType.Number, "selectionShift")) {
+            pieDataSet.setSelectionShift((float) config.getDouble("selectionShift"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.String, "xValuePosition")) {
+            pieDataSet.setXValuePosition(PieDataSet.ValuePosition.valueOf(config.getString("xValuePosition").toUpperCase(Locale.ENGLISH)));
+        }
+        if (BridgeUtils.validate(config, ReadableType.String, "yValuePosition")) {
+            pieDataSet.setYValuePosition(PieDataSet.ValuePosition.valueOf(config.getString("yValuePosition").toUpperCase(Locale.ENGLISH)));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Number, "valueLinePart1Length")) {
+            pieDataSet.setValueLinePart1Length((float) config.getDouble("valueLinePart1Length"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Number, "valueLinePart2Length")) {
+            pieDataSet.setValueLinePart2Length((float) config.getDouble("valueLinePart2Length"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Number, "valueLineColor")) {
+            pieDataSet.setValueLineColor(config.getInt("valueLineColor"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Number, "valueLineWidth")) {
+            pieDataSet.setValueLineWidth((float) config.getDouble("valueLineWidth"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Number, "valueLinePart1OffsetPercentage")) {
+            pieDataSet.setValueLinePart1OffsetPercentage((float) config.getDouble("valueLinePart1OffsetPercentage"));
+        }
+
+        if (BridgeUtils.validate(config, ReadableType.Boolean, "valueLineVariableLength")) {
+            pieDataSet.setValueLineVariableLength(config.getBoolean("valueLineVariableLength"));
+        }
+
+    }
+
+    @Override
+    PieEntry createEntry(ReadableArray values, int index) {
+        PieEntry entry;
+
+        if (ReadableType.Map.equals(values.getType(index))) {
+            ReadableMap map = values.getMap(index);
+
+            float value = (float) map.getDouble("value");
+            if (BridgeUtils.validate(map, ReadableType.String, "label")) {
+                entry = new PieEntry(value, map.getString("label"), ConversionUtil.toMap(map));
+            } else {
+                entry = new PieEntry(value, ConversionUtil.toMap(map));
+            }
+        } else if (ReadableType.Number.equals(values.getType(index))) {
+            entry = new PieEntry((float) values.getDouble(index));
+        } else {
+            throw new IllegalArgumentException("Unexpected entry type: " + values.getType(index));
+        }
+
+        return entry;
+    }
+
+}