Example usage for java.math MathContext MathContext

Introduction

In this page you can find the example usage for java.math MathContext MathContext.

Prototype

public MathContext(String val) 

Source Link

Document

Constructs a new MathContext from a string.

Usage

From source file:Main.java

public static void main(String[] args) {

    BigDecimal bg1 = new BigDecimal("12.345");
    BigDecimal bg2 = new BigDecimal("23.456");

    System.out.println("Object Value is " + bg1);
    System.out.println("Augend value is " + bg2);

    // create MathContext object with 4 precision
    MathContext mc = new MathContext(4);

    // perform add operation on bg1 with augend bg2 and context mc
    BigDecimal bg3 = bg1.add(bg2, mc);

    System.out.println("Result is " + bg3);
}

---

From source file:Main.java

/**
 * Returns a string representation of number rounded to given number of
 * significant figures// ww  w  .j av  a  2s  .  com
 *
 * @param value
 * @param significantFigures
 * @return String.
 */
public static String roundToString(double value, int significantFigures) {
    MathContext mc = new MathContext(significantFigures);
    BigDecimal num = new BigDecimal(value);
    return num.round(mc).toPlainString();
}

---

From source file:Main.java

public static BigDecimal cuberoot(BigDecimal b) {
    // Specify a math context with 40 digits of precision.

    MathContext mc = new MathContext(40);

    BigDecimal x = new BigDecimal("1", mc);

    // Search for the cube root via the Newton-Raphson loop. Output each // successive iteration's value.

    for (int i = 0; i < ITER; i++) {
        x = x.subtract(//from   w ww .j av a2s .  c o  m
                x.pow(3, mc).subtract(b, mc).divide(new BigDecimal("3", mc).multiply(x.pow(2, mc), mc), mc),
                mc);
    }
    return x;
}

---

From source file:Main.java

public static BigDecimal cuberoot(BigDecimal b) {
    // Specify a math context with 40 digits of precision.

    MathContext mc = new MathContext(40);

    BigDecimal x = new BigDecimal("1", mc);

    // Search for the cube root via the Newton-Raphson loop. Output each //
    // successive iteration's value.

    for (int i = 0; i < ITER; i++) {
        x = x.subtract(/*from w  w w .ja va 2s.  c o  m*/
                x.pow(3, mc).subtract(b, mc).divide(new BigDecimal("3", mc).multiply(x.pow(2, mc), mc), mc),
                mc);
    }
    return x;
}

---

From source file:util.POIUtils.java

/**
 * Converts numbers that include exponents into a regular number.
 *
 * @param number original number/*from w ww .j  av a 2s  . co  m*/
 * @return reformatted number
 **/
private static String formatNumber(double number) {

    String numString = Double.toString(number);
    int idx = numString.indexOf((int) 'E');
    if (idx == -1) {
        // lop off trailing .0
        if (numString.endsWith(".0")) {
            numString = numString.substring(0, numString.length() - 2);
        }
        return numString;
    }

    int exponent = Integer.parseInt(numString.substring(idx + 1));
    int precision = idx - 1;
    if (exponent > 0 && exponent == precision) {
        precision++;
    }
    BigDecimal bd = new BigDecimal(number, new MathContext(precision));
    return bd.toPlainString();
}

---

From source file:gdsc.smlm.ij.utils.Utils.java

/**
 * Round the double to the specified significant digits
 * /*from  www  .j  a  v a  2s  .  c o  m*/
 * @param d
 * @param significantDigits
 * @return
 */
public static String rounded(double d, int significantDigits) {
    if (Double.isInfinite(d) || Double.isNaN(d))
        return "" + d;
    BigDecimal bd = new BigDecimal(d);
    bd = bd.round(new MathContext(significantDigits));
    return "" + bd.doubleValue();
}

---

From source file:nl.strohalm.cyclos.utils.DateHelper.java

/**
 * Returns the number of days between 2 dates as a BigDecimal. Will be negative if date2 < date1, or positive otherwise.
 *//*from  ww  w .  j  av  a  2 s.co  m*/
public static BigDecimal decimalDaysBetween(final Calendar date1, final Calendar date2) {
    if (date1 == null || date2 == null) {
        return BigDecimal.ZERO;
    }
    final BigDecimal difference = new BigDecimal(date2.getTimeInMillis() - date1.getTimeInMillis());
    final MathContext mathContext = new MathContext(LocalSettings.MAX_PRECISION);
    final BigDecimal result = difference.divide(new BigDecimal(DateUtils.MILLIS_PER_DAY), mathContext);
    return result;
}

---

From source file:com.alibaba.dragoon.client.jmx.Threading.java

public BigDecimal getProcessCpuTimeRate() {
    long cpuTime = getProcessCpuTime();
    long upTime = getUpTime();

    long elapsedCpu = cpuTime - lastCPUTime;
    long elapsedTime = upTime - lastCPUUpTime;

    lastCPUTime = cpuTime;/*from   w  w w .  j  a  v  a2s .c  om*/
    lastCPUUpTime = upTime;

    BigDecimal cpuRate;
    if (elapsedTime <= 0) {
        return new BigDecimal(0);
    }

    float cpuUsage = elapsedCpu / (elapsedTime * 10000F);
    cpuRate = new BigDecimal(cpuUsage, new MathContext(4));

    return cpuRate;
}

---

From source file:com.alibaba.dragoon.client.jmx.Threading.java

public BigDecimal getFullGCCollectionTimeRate() {
    long gcTime = getFullGCCollectionTime() + getYoungGCCollectionTime();
    long upTime = getUpTime();

    long elapsedGc = gcTime - lastGCTime;
    long elapsedTime = upTime - lastGCUpTime;

    BigDecimal gcRate;// w  ww .  j  a  v  a 2s.co m
    if (elapsedTime <= 0) {
        gcRate = new BigDecimal(0);
    } else {
        float gcUsage = (elapsedGc * 10F) / (elapsedTime);
        gcRate = new BigDecimal(gcUsage, new MathContext(4));
    }

    lastGCTime = gcTime;
    lastGCUpTime = upTime;

    return gcRate;
}

---

From source file:org.alfresco.serializers.PropertiesTypeConverter.java

@SuppressWarnings("rawtypes")
private PropertiesTypeConverter() {
    ////  w  w  w  .j a  v a 2s  . co m
    // From string
    //
    addConverter(String.class, Class.class, new TypeConverter.Converter<String, Class>() {
        public Class convert(String source) {
            try {
                return Class.forName(source);
            } catch (ClassNotFoundException e) {
                throw new TypeConversionException("Failed to convert string to class: " + source, e);
            }
        }
    });
    addConverter(String.class, Boolean.class, new TypeConverter.Converter<String, Boolean>() {
        public Boolean convert(String source) {
            return Boolean.valueOf(source);
        }
    });
    addConverter(String.class, Character.class, new TypeConverter.Converter<String, Character>() {
        public Character convert(String source) {
            if ((source == null) || (source.length() == 0)) {
                return null;
            }
            return Character.valueOf(source.charAt(0));
        }
    });
    addConverter(String.class, Number.class, new TypeConverter.Converter<String, Number>() {
        public Number convert(String source) {
            try {
                return DecimalFormat.getNumberInstance().parse(source);
            } catch (ParseException e) {
                throw new TypeConversionException("Failed to parse number " + source, e);
            }
        }
    });
    addConverter(String.class, Byte.class, new TypeConverter.Converter<String, Byte>() {
        public Byte convert(String source) {
            return Byte.valueOf(source);
        }
    });
    addConverter(String.class, Short.class, new TypeConverter.Converter<String, Short>() {
        public Short convert(String source) {
            return Short.valueOf(source);
        }
    });
    addConverter(String.class, Integer.class, new TypeConverter.Converter<String, Integer>() {
        public Integer convert(String source) {
            return Integer.valueOf(source);
        }
    });
    addConverter(String.class, Long.class, new TypeConverter.Converter<String, Long>() {
        public Long convert(String source) {
            return Long.valueOf(source);
        }
    });
    addConverter(String.class, Float.class, new TypeConverter.Converter<String, Float>() {
        public Float convert(String source) {
            return Float.valueOf(source);
        }
    });
    addConverter(String.class, Double.class, new TypeConverter.Converter<String, Double>() {
        public Double convert(String source) {
            return Double.valueOf(source);
        }
    });
    addConverter(String.class, BigInteger.class, new TypeConverter.Converter<String, BigInteger>() {
        public BigInteger convert(String source) {
            return new BigInteger(source);
        }
    });
    addConverter(String.class, BigDecimal.class, new TypeConverter.Converter<String, BigDecimal>() {
        public BigDecimal convert(String source) {
            return new BigDecimal(source);
        }
    });
    addConverter(JSON.class, BigDecimal.class, new TypeConverter.Converter<JSON, BigDecimal>() {
        public BigDecimal convert(JSON source) {
            String type = (String) source.get("t");
            if (type.equals("FIXED_POINT")) {
                String number = (String) source.get("n");
                Integer precision = (Integer) source.get("p");
                MathContext ctx = new MathContext(precision);
                return new BigDecimal(number, ctx);
            } else {
                throw new IllegalArgumentException(
                        "Invalid source object for conversion " + source + ", expected a Fixed Decimal object");
            }
        }
    });
    addConverter(String.class, Date.class, new TypeConverter.Converter<String, Date>() {
        public Date convert(String source) {
            try {
                Date date = ISO8601DateFormat.parse(source);
                return date;
            } catch (PlatformRuntimeException e) {
                throw new TypeConversionException("Failed to convert date " + source + " to string", e);
            } catch (AlfrescoRuntimeException e) {
                throw new TypeConversionException("Failed to convert date " + source + " to string", e);
            }
        }
    });
    addConverter(String.class, Duration.class, new TypeConverter.Converter<String, Duration>() {
        public Duration convert(String source) {
            return new Duration(source);
        }
    });
    addConverter(String.class, QName.class, new TypeConverter.Converter<String, QName>() {
        public QName convert(String source) {
            return QName.createQName(source);
        }
    });
    addConverter(JSON.class, QName.class, new TypeConverter.Converter<JSON, QName>() {
        public QName convert(JSON source) {
            String type = (String) source.get("t");
            if (type.equals("QNAME")) {
                String qname = (String) source.get("v");
                return QName.createQName(qname);
            } else {
                throw new IllegalArgumentException();
            }
        }
    });
    addConverter(String.class, ContentData.class, new TypeConverter.Converter<String, ContentData>() {
        public ContentData convert(String source) {
            return ContentData.createContentProperty(source);
        }
    });
    addConverter(String.class, NodeRef.class, new TypeConverter.Converter<String, NodeRef>() {
        public NodeRef convert(String source) {
            return new NodeRef(source);
        }
    });
    addConverter(JSON.class, NodeRef.class, new TypeConverter.Converter<JSON, NodeRef>() {
        public NodeRef convert(JSON source) {
            String type = (String) source.get("t");
            if (!type.equals("NODEREF")) {
                throw new IllegalArgumentException(
                        "Invalid source object for conversion " + source + ", expected a NodeRef object");
            }
            String protocol = (String) source.get("p");
            String storeId = (String) source.get("s");
            String id = (String) source.get("id");
            NodeRef nodeRef = new NodeRef(new StoreRef(protocol, storeId), id);
            return nodeRef;
        }
    });
    addConverter(String.class, StoreRef.class, new TypeConverter.Converter<String, StoreRef>() {
        public StoreRef convert(String source) {
            return new StoreRef(source);
        }
    });
    addConverter(JSON.class, StoreRef.class, new TypeConverter.Converter<JSON, StoreRef>() {
        public StoreRef convert(JSON source) {
            String type = (String) source.get("t");
            if (!type.equals("STOREREF")) {
                throw new IllegalArgumentException(
                        "Invalid source object for conversion " + source + ", expected a StoreRef object");
            }
            String protocol = (String) source.get("p");
            String storeId = (String) source.get("s");
            return new StoreRef(protocol, storeId);
        }
    });
    addConverter(String.class, ChildAssociationRef.class,
            new TypeConverter.Converter<String, ChildAssociationRef>() {
                public ChildAssociationRef convert(String source) {
                    return new ChildAssociationRef(source);
                }
            });
    addConverter(String.class, AssociationRef.class, new TypeConverter.Converter<String, AssociationRef>() {
        public AssociationRef convert(String source) {
            return new AssociationRef(source);
        }
    });
    addConverter(String.class, InputStream.class, new TypeConverter.Converter<String, InputStream>() {
        public InputStream convert(String source) {
            try {
                return new ByteArrayInputStream(source.getBytes("UTF-8"));
            } catch (UnsupportedEncodingException e) {
                throw new TypeConversionException("Encoding not supported", e);
            }
        }
    });
    addConverter(String.class, MLText.class, new TypeConverter.Converter<String, MLText>() {
        public MLText convert(String source) {
            return new MLText(source);
        }
    });
    addConverter(JSON.class, MLText.class, new TypeConverter.Converter<JSON, MLText>() {
        public MLText convert(JSON source) {
            String type = (String) source.get("t");
            if (!type.equals("MLTEXT")) {
                throw new IllegalArgumentException(
                        "Invalid source object for conversion " + source + ", expected a NodeRef object");
            }

            MLText mlText = new MLText();
            for (String languageTag : source.keySet()) {
                String text = (String) source.get(languageTag);
                Locale locale = Locale.forLanguageTag(languageTag);
                mlText.put(locale, text);
            }

            return mlText;
        }
    });
    //        addConverter(JSON.class, ContentDataWithId.class, new TypeConverter.Converter<JSON, ContentDataWithId>()
    //        {
    //            public ContentDataWithId convert(JSON source)
    //            {
    //                String type = (String)source.get("t");
    //                if(!type.equals("CONTENT_DATA_ID"))
    //                {
    //                    throw new IllegalArgumentException("Invalid source object for conversion "
    //                            + source 
    //                            + ", expected a ContentDataWithId object");
    //                }
    //                String contentUrl = (String)source.get("u");
    //                String mimeType = (String)source.get("m");
    //                Long size = (Long)source.get("s");
    //                String encoding = (String)source.get("e");
    //                String languageTag = (String)source.get("l");
    //                Long id = (Long)source.get("id");
    //                Locale locale = Locale.forLanguageTag(languageTag);
    //
    //                ContentData contentData = new ContentData(contentUrl, mimeType, size, encoding, locale);
    //                ContentDataWithId contentDataWithId = new ContentDataWithId(contentData, id);
    //                return contentDataWithId;
    //            }
    //        });
    addConverter(JSON.class, ContentData.class, new TypeConverter.Converter<JSON, ContentData>() {
        public ContentData convert(JSON source) {
            ContentData contentData = null;

            String type = (String) source.get("t");
            if (type.equals("CONTENT")) {
                String contentUrl = (String) source.get("u");
                String mimeType = (String) source.get("m");
                Long size = (Long) source.get("s");
                String encoding = (String) source.get("e");
                String languageTag = (String) source.get("l");
                Locale locale = Locale.forLanguageTag(languageTag);
                contentData = new ContentData(contentUrl, mimeType, size, encoding, locale);
            } else if (type.equals("CONTENT_DATA_ID")) {
                String contentUrl = (String) source.get("u");
                String mimeType = (String) source.get("m");
                Long size = (Long) source.get("s");
                String encoding = (String) source.get("e");
                String languageTag = (String) source.get("l");
                Locale locale = Locale.forLanguageTag(languageTag);
                contentData = new ContentData(contentUrl, mimeType, size, encoding, locale);
            } else {
                throw new IllegalArgumentException(
                        "Invalid source object for conversion " + source + ", expected a ContentData object");
            }

            return contentData;
        }
    });
    addConverter(JSON.class, String.class, new TypeConverter.Converter<JSON, String>() {
        public String convert(JSON source) {
            // TODO distinguish between different BasicDBObject representations e.g. for MLText, ...

            Set<String> languageTags = source.keySet();
            if (languageTags.size() == 0) {
                throw new IllegalArgumentException("Persisted MLText is invalid " + source);
            } else if (languageTags.size() > 1) {
                // TODO
                logger.warn("Persisted MLText has more than 1 locale " + source);
            }

            String languageTag = languageTags.iterator().next();
            String text = (String) source.get(languageTag);
            return text;
        }
    });
    addConverter(String.class, Locale.class, new TypeConverter.Converter<String, Locale>() {
        public Locale convert(String source) {
            return I18NUtil.parseLocale(source);
        }
    });
    addConverter(String.class, Period.class, new TypeConverter.Converter<String, Period>() {
        public Period convert(String source) {
            return new Period(source);
        }
    });
    addConverter(String.class, VersionNumber.class, new TypeConverter.Converter<String, VersionNumber>() {
        public VersionNumber convert(String source) {
            return new VersionNumber(source);
        }
    });

    //
    // From Locale
    //
    addConverter(Locale.class, String.class, new TypeConverter.Converter<Locale, String>() {
        public String convert(Locale source) {
            String localeStr = source.toString();
            if (localeStr.length() < 6) {
                localeStr += "_";
            }
            return localeStr;
        }
    });

    //
    // From VersionNumber
    //
    addConverter(VersionNumber.class, String.class, new TypeConverter.Converter<VersionNumber, String>() {
        public String convert(VersionNumber source) {
            return source.toString();
        }
    });

    //
    // From MLText
    //
    addConverter(MLText.class, String.class, new TypeConverter.Converter<MLText, String>() {
        public String convert(MLText source) {
            return source.getDefaultValue();
        }
    });

    addConverter(MLText.class, JSON.class, new TypeConverter.Converter<MLText, JSON>() {
        public JSON convert(MLText source) {
            JSON map = new JSON();
            map.put("t", "MLTEXT");
            for (Map.Entry<Locale, String> entry : source.entrySet()) {
                map.put(entry.getKey().toLanguageTag(), entry.getValue());
            }
            return map;
        }
    });

    //        addConverter(ContentDataWithId.class, JSON.class, new TypeConverter.Converter<ContentDataWithId, JSON>()
    //        {
    //            public JSON convert(ContentDataWithId source)
    //            {
    //                JSON map = new JSON();
    //
    //                String contentUrl = source.getContentUrl();
    //                Long id = source.getId();
    //                String languageTag = source.getLocale().toLanguageTag();
    //                String encoding = source.getEncoding();
    //                long size = source.getSize();
    //                String mimeType = source.getMimetype();
    //
    //                map.put("t", "CONTENT_DATA_ID");
    //                map.put("u", contentUrl);
    //                map.put("m", mimeType);
    //                map.put("s", size);
    //                map.put("e", encoding);
    //                map.put("l", languageTag);
    //                map.put("id", id);
    //                return map;
    //            }
    //        });

    addConverter(ContentData.class, JSON.class, new TypeConverter.Converter<ContentData, JSON>() {
        public JSON convert(ContentData source) {
            JSON map = new JSON();

            String contentUrl = source.getContentUrl();
            String languageTag = source.getLocale().toLanguageTag();
            String encoding = source.getEncoding();
            long size = source.getSize();
            String mimeType = source.getMimetype();

            map.put("t", "CONTENT_DATA");
            map.put("u", contentUrl);
            map.put("m", mimeType);
            map.put("s", size);
            map.put("e", encoding);
            map.put("l", languageTag);
            return map;
        }
    });

    //
    // From enum
    //
    addConverter(Enum.class, String.class, new TypeConverter.Converter<Enum, String>() {
        public String convert(Enum source) {
            return source.toString();
        }
    });

    // From Period
    addConverter(Period.class, String.class, new TypeConverter.Converter<Period, String>() {
        public String convert(Period source) {
            return source.toString();
        }
    });

    // From Class
    addConverter(Class.class, String.class, new TypeConverter.Converter<Class, String>() {
        public String convert(Class source) {
            return source.getName();
        }
    });

    //
    // Number to Subtypes and Date
    //
    addConverter(Number.class, Boolean.class, new TypeConverter.Converter<Number, Boolean>() {
        public Boolean convert(Number source) {
            return new Boolean(source.longValue() > 0);
        }
    });
    addConverter(Number.class, Byte.class, new TypeConverter.Converter<Number, Byte>() {
        public Byte convert(Number source) {
            return Byte.valueOf(source.byteValue());
        }
    });
    addConverter(Number.class, Short.class, new TypeConverter.Converter<Number, Short>() {
        public Short convert(Number source) {
            return Short.valueOf(source.shortValue());
        }
    });
    addConverter(Number.class, Integer.class, new TypeConverter.Converter<Number, Integer>() {
        public Integer convert(Number source) {
            return Integer.valueOf(source.intValue());
        }
    });
    addConverter(Number.class, Long.class, new TypeConverter.Converter<Number, Long>() {
        public Long convert(Number source) {
            return Long.valueOf(source.longValue());
        }
    });
    addConverter(Number.class, Float.class, new TypeConverter.Converter<Number, Float>() {
        public Float convert(Number source) {
            return Float.valueOf(source.floatValue());
        }
    });
    addConverter(Number.class, Double.class, new TypeConverter.Converter<Number, Double>() {
        public Double convert(Number source) {
            return Double.valueOf(source.doubleValue());
        }
    });
    addConverter(Number.class, Date.class, new TypeConverter.Converter<Number, Date>() {
        public Date convert(Number source) {
            return new Date(source.longValue());
        }
    });
    addConverter(Number.class, String.class, new TypeConverter.Converter<Number, String>() {
        public String convert(Number source) {
            return source.toString();
        }
    });
    addConverter(Number.class, BigInteger.class, new TypeConverter.Converter<Number, BigInteger>() {
        public BigInteger convert(Number source) {
            if (source instanceof BigDecimal) {
                return ((BigDecimal) source).toBigInteger();
            } else {
                return BigInteger.valueOf(source.longValue());
            }
        }
    });
    addConverter(Number.class, BigDecimal.class, new TypeConverter.Converter<Number, BigDecimal>() {
        public BigDecimal convert(Number source) {
            if (source instanceof BigInteger) {
                return new BigDecimal((BigInteger) source);
            } else if (source instanceof Double) {
                return BigDecimal.valueOf((Double) source);
            } else if (source instanceof Float) {
                Float val = (Float) source;
                if (val.isInfinite()) {
                    // What else can we do here?  this is 3.4 E 38 so is fairly big
                    return new BigDecimal(Float.MAX_VALUE);
                }
                return BigDecimal.valueOf((Float) source);
            } else {
                return BigDecimal.valueOf(source.longValue());
            }
        }
    });
    addDynamicTwoStageConverter(Number.class, String.class, InputStream.class);

    //
    // Date, Timestamp ->
    //
    addConverter(Timestamp.class, Date.class, new TypeConverter.Converter<Timestamp, Date>() {
        public Date convert(Timestamp source) {
            return new Date(source.getTime());
        }
    });
    addConverter(Date.class, Number.class, new TypeConverter.Converter<Date, Number>() {
        public Number convert(Date source) {
            return Long.valueOf(source.getTime());
        }
    });
    addConverter(Date.class, String.class, new TypeConverter.Converter<Date, String>() {
        public String convert(Date source) {
            try {
                return ISO8601DateFormat.format(source);
            } catch (PlatformRuntimeException e) {
                throw new TypeConversionException("Failed to convert date " + source + " to string", e);
            }
        }
    });
    addConverter(Date.class, Calendar.class, new TypeConverter.Converter<Date, Calendar>() {
        public Calendar convert(Date source) {
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(source);
            return calendar;
        }
    });

    addConverter(Date.class, GregorianCalendar.class, new TypeConverter.Converter<Date, GregorianCalendar>() {
        public GregorianCalendar convert(Date source) {
            GregorianCalendar calendar = new GregorianCalendar();
            calendar.setTime(source);
            return calendar;
        }
    });
    addDynamicTwoStageConverter(Date.class, String.class, InputStream.class);

    //
    // Boolean ->
    //
    final Long LONG_FALSE = new Long(0L);
    final Long LONG_TRUE = new Long(1L);
    addConverter(Boolean.class, Long.class, new TypeConverter.Converter<Boolean, Long>() {
        public Long convert(Boolean source) {
            return source.booleanValue() ? LONG_TRUE : LONG_FALSE;
        }
    });
    addConverter(Boolean.class, String.class, new TypeConverter.Converter<Boolean, String>() {
        public String convert(Boolean source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(Boolean.class, String.class, InputStream.class);

    //
    // Character ->
    //
    addConverter(Character.class, String.class, new TypeConverter.Converter<Character, String>() {
        public String convert(Character source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(Character.class, String.class, InputStream.class);

    //
    // Duration ->
    //
    addConverter(Duration.class, String.class, new TypeConverter.Converter<Duration, String>() {
        public String convert(Duration source) {
            return source.toString();
        }

    });
    addDynamicTwoStageConverter(Duration.class, String.class, InputStream.class);

    //
    // Byte
    //
    addConverter(Byte.class, String.class, new TypeConverter.Converter<Byte, String>() {
        public String convert(Byte source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(Byte.class, String.class, InputStream.class);

    //
    // Short
    //
    addConverter(Short.class, String.class, new TypeConverter.Converter<Short, String>() {
        public String convert(Short source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(Short.class, String.class, InputStream.class);

    //
    // Integer
    //
    addConverter(Integer.class, String.class, new TypeConverter.Converter<Integer, String>() {
        public String convert(Integer source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(Integer.class, String.class, InputStream.class);

    //
    // Long
    //
    addConverter(Long.class, String.class, new TypeConverter.Converter<Long, String>() {
        public String convert(Long source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(Long.class, String.class, InputStream.class);

    //
    // Float
    //
    addConverter(Float.class, String.class, new TypeConverter.Converter<Float, String>() {
        public String convert(Float source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(Float.class, String.class, InputStream.class);

    //
    // Double
    //
    addConverter(Double.class, String.class, new TypeConverter.Converter<Double, String>() {
        public String convert(Double source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(Double.class, String.class, InputStream.class);

    //
    // BigInteger
    //
    addConverter(BigInteger.class, String.class, new TypeConverter.Converter<BigInteger, String>() {
        public String convert(BigInteger source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(BigInteger.class, String.class, InputStream.class);

    //
    // Calendar
    //
    addConverter(Calendar.class, Date.class, new TypeConverter.Converter<Calendar, Date>() {
        public Date convert(Calendar source) {
            return source.getTime();
        }
    });
    addConverter(Calendar.class, String.class, new TypeConverter.Converter<Calendar, String>() {
        public String convert(Calendar source) {
            try {
                return ISO8601DateFormat.format(source.getTime());
            } catch (PlatformRuntimeException e) {
                throw new TypeConversionException("Failed to convert date " + source + " to string", e);
            }
        }
    });

    //
    // BigDecimal
    //
    addConverter(BigDecimal.class, JSON.class, new TypeConverter.Converter<BigDecimal, JSON>() {
        public JSON convert(BigDecimal source) {
            String number = source.toPlainString();
            int precision = source.precision();
            JSON map = new JSON();
            map.put("t", "FIXED_POINT");
            map.put("n", number);
            map.put("p", precision);
            return map;
        }
    });
    addConverter(BigDecimal.class, String.class, new TypeConverter.Converter<BigDecimal, String>() {
        public String convert(BigDecimal source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(BigDecimal.class, String.class, InputStream.class);

    //
    // QName
    //
    addConverter(QName.class, String.class, new TypeConverter.Converter<QName, String>() {
        public String convert(QName source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(QName.class, String.class, InputStream.class);

    //
    // EntityRef (NodeRef, ChildAssociationRef, NodeAssociationRef)
    //
    addConverter(EntityRef.class, String.class, new TypeConverter.Converter<EntityRef, String>() {
        public String convert(EntityRef source) {
            return source.toString();
        }
    });
    addConverter(EntityRef.class, JSON.class, new TypeConverter.Converter<EntityRef, JSON>() {
        public JSON convert(EntityRef source) {
            JSON ret = null;

            if (source instanceof NodeRef) {
                NodeRef nodeRef = (NodeRef) source;

                JSON map = new JSON();
                map.put("t", "NODEREF");
                map.put("p", nodeRef.getStoreRef().getProtocol());
                map.put("s", nodeRef.getStoreRef().getIdentifier());
                map.put("id", nodeRef.getId());
                ret = map;
            } else if (source instanceof StoreRef) {
                StoreRef storeRef = (StoreRef) source;

                JSON map = new JSON();
                map.put("t", "STOREREF");
                map.put("p", storeRef.getProtocol());
                map.put("s", storeRef.getIdentifier());
                ret = map;
            } else {
                throw new IllegalArgumentException();
            }

            return ret;
        }
    });
    addDynamicTwoStageConverter(EntityRef.class, String.class, InputStream.class);

    //
    // ContentData
    //
    addConverter(ContentData.class, String.class, new TypeConverter.Converter<ContentData, String>() {
        public String convert(ContentData source) {
            return source.getInfoUrl();
        }
    });
    addDynamicTwoStageConverter(ContentData.class, String.class, InputStream.class);

    //
    // Path
    //
    addConverter(Path.class, String.class, new TypeConverter.Converter<Path, String>() {
        public String convert(Path source) {
            return source.toString();
        }
    });
    addDynamicTwoStageConverter(Path.class, String.class, InputStream.class);

    //
    // Content Reader
    //
    addConverter(ContentReader.class, InputStream.class,
            new TypeConverter.Converter<ContentReader, InputStream>() {
                public InputStream convert(ContentReader source) {
                    return source.getContentInputStream();
                }
            });
    addConverter(ContentReader.class, String.class, new TypeConverter.Converter<ContentReader, String>() {
        public String convert(ContentReader source) {
            // Getting the string from the ContentReader binary is meaningless
            return source.toString();
        }
    });

    //
    // Content Writer
    //
    addConverter(ContentWriter.class, String.class, new TypeConverter.Converter<ContentWriter, String>() {
        public String convert(ContentWriter source) {
            return source.toString();
        }
    });

    //        addConverter(Collection.class, BasicDBList.class, new TypeConverter.Converter<Collection, BasicDBList>()
    //        {
    //            public BasicDBList convert(Collection source)
    //            {
    //                BasicDBList ret = new BasicDBList();
    //                for(Object o : source)
    //                {
    //                    ret.add(o);
    //                }
    //                return ret;
    //            }
    //        });

    //        addConverter(BasicDBList.class, Collection.class, new TypeConverter.Converter<BasicDBList, Collection>()
    //        {
    //            @SuppressWarnings("unchecked")
    //            public Collection convert(BasicDBList source)
    //            {
    //                Collection ret = new LinkedList();
    //                for(Object o : source)
    //                {
    //                    ret.add(o);
    //                }
    //                return ret;
    //            }
    //        });

    //
    // Input Stream
    //
    addConverter(InputStream.class, String.class, new TypeConverter.Converter<InputStream, String>() {
        public String convert(InputStream source) {
            try {
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                byte[] buffer = new byte[8192];
                int read;
                while ((read = source.read(buffer)) > 0) {
                    out.write(buffer, 0, read);
                }
                byte[] data = out.toByteArray();
                return new String(data, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                throw new TypeConversionException("Cannot convert input stream to String.", e);
            } catch (IOException e) {
                throw new TypeConversionException("Conversion from stream to string failed", e);
            } finally {
                if (source != null) {
                    try {
                        source.close();
                    } catch (IOException e) {
                        //NOOP
                    }
                }
            }
        }
    });
    addDynamicTwoStageConverter(InputStream.class, String.class, Date.class);

    addDynamicTwoStageConverter(InputStream.class, String.class, Double.class);

    addDynamicTwoStageConverter(InputStream.class, String.class, Long.class);

    addDynamicTwoStageConverter(InputStream.class, String.class, Boolean.class);

    addDynamicTwoStageConverter(InputStream.class, String.class, QName.class);

    addDynamicTwoStageConverter(InputStream.class, String.class, Path.class);

    addDynamicTwoStageConverter(InputStream.class, String.class, NodeRef.class);

}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• »