static

in grails-data-mongodb/bson/src/main/groovy/org/grails/datastore/bson/codecs/CodecExtensions.groovy [86:240]

• 152 lines of code
• 10 McCabe index (conditional complexity)

    static {
        ADDITIONAL_CODECS[IntRange] = new IntRangeCodec()
        ADDITIONAL_CODECS[GStringImpl] = new GStringCodec()
        ADDITIONAL_CODECS[Locale] = new LocaleCodec()
        ADDITIONAL_CODECS[Currency] = new CurrencyCodec()
        ADDITIONAL_CODECS[GString] = new GStringCodec()
        ADDITIONAL_CODECS[List] = new ListCodec()
        ADDITIONAL_CODECS[Map] = new MapCodec()
        ADDITIONAL_CODECS[LinkedHashMap] = new MapCodec()
        ADDITIONAL_CODECS[HashMap] = new MapCodec()
        ADDITIONAL_CODECS[ArrayList] = new ListCodec()
        BSON_VALUE_CONVERTERS[BsonBinary] << new Converter<BsonBinary, byte[]>() {
            @Override
            byte[] convert(BsonBinary source) {
                return source.data
            }
        }
        BSON_VALUE_CONVERTERS[BsonObjectId] << new Converter<BsonObjectId, ObjectId>() {
            @Override
            ObjectId convert(BsonObjectId source) {
                source.value
            }
        }
        BSON_VALUE_CONVERTERS[BsonTimestamp] << new Converter<BsonTimestamp, Date>() {
            @Override
            Date convert(BsonTimestamp source) {
                new Date(source.time * 1000)
            }
        }
        BSON_VALUE_CONVERTERS[BsonDateTime] << new Converter<BsonDateTime, Date>() {
            @Override
            Date convert(BsonDateTime source) {
                new Date(source.value)
            }
        }
        BSON_VALUE_CONVERTERS[BsonString] << new Converter<BsonString, CharSequence>() {
            @Override
            CharSequence convert(BsonString source) {
                source.value
            }
        }
        BSON_VALUE_CONVERTERS[BsonString] << new Converter<BsonString, String>() {
            @Override
            String convert(BsonString source) {
                source.value
            }
        }
        BSON_VALUE_CONVERTERS[BsonRegularExpression] << new Converter<BsonRegularExpression, Pattern>() {
            @Override
            Pattern convert(BsonRegularExpression source) {
                Pattern.compile(source.pattern)
            }
        }
        BSON_VALUE_CONVERTERS[BsonBoolean] << new Converter<BsonBoolean, Boolean>() {
            @Override
            Boolean convert(BsonBoolean source) {
                source.value
            }
        }
        BSON_VALUE_CONVERTERS[BsonNull] << new Converter<BsonNull, Object>() {
            @Override
            Object convert(BsonNull source) {
                return null
            }
        }
        BSON_VALUE_CONVERTERS[BsonDouble] << new Converter<BsonDouble, Double>() {
            @Override
            Double convert(BsonDouble source) {
                source.doubleValue()
            }
        }
        BSON_VALUE_CONVERTERS[BsonDouble] << new Converter<BsonDouble, Float>() {
            @Override
            Float convert(BsonDouble source) {
                source.doubleValue().floatValue()
            }
        }
        BSON_VALUE_CONVERTERS[BsonInt32] << new Converter<BsonInt32, Integer>() {
            @Override
            Integer convert(BsonInt32 source) {
                return source.intValue()
            }
        }
        BSON_VALUE_CONVERTERS[BsonInt32] << new Converter<BsonInt32, Short>() {
            @Override
            Short convert(BsonInt32 source) {
                source.intValue().shortValue()
            }
        }
        BSON_VALUE_CONVERTERS[BsonInt64] << new Converter<BsonInt64, Long>() {
            @Override
            Long convert(BsonInt64 source) {
                source.longValue()
            }
        }
        BSON_VALUE_CONVERTERS[BsonArray] << new Converter<BsonArray, List>() {
            @Override
            List convert(BsonArray source) {
                List list = []
                for(BsonValue v in source) {
                    if(v != null) {
                        def converter = BSON_VALUE_CONVERTERS[v.getClass()]?.first()
                        list << (converter ? converter.convert(v) : v)
                    }
                    else {
                        list << v
                    }
                }
                return list
            }
        }
        BSON_VALUE_CONVERTERS[BsonArray] << new Converter<BsonArray, Object[]>() {
            @Override
            Object[] convert(BsonArray source) {
                Object[] array = new Object[source.size()]
                int i = 0
                for(BsonValue v in source) {
                    if(v != null) {
                        def converter = BSON_VALUE_CONVERTERS[v.getClass()]?.first()
                        array[i++] = (converter ? converter.convert(v) : v)
                    }
                    else {
                        array[i++] = v
                    }
                }
                return array
            }
        }
        BSON_VALUE_CONVERTERS[BsonDocument] << new Converter<BsonDocument, Map<String, Object>>() {
            @Override
            Map<String, Object> convert(BsonDocument source) {
                Map<String, Object> map = [:]

                for(key in source.keySet()) {
                    def v = source[key]
                    if(v != null) {
                        def converter = BSON_VALUE_CONVERTERS[v.getClass()]?.first()
                        map[key] = (converter ? converter.convert(v) : v)
                    }
                    else {
                        map[key] = v
                    }

                }
                return map
            }
        }

        BSON_VALUE_CONVERTERS[BsonDecimal128] << new Converter<BsonDecimal128, BigDecimal>() {
            @Override
            BigDecimal convert(BsonDecimal128 source) {
                return source.decimal128Value().bigDecimalValue()
            }
        }
    }