Move BindingReflections to mdsal-binding-spec-util
[mdsal.git] / binding / mdsal-binding-dom-codec / src / main / java / org / opendaylight / mdsal / binding / dom / codec / impl / ValueTypeCodec.java
1 /*
2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.mdsal.binding.dom.codec.impl;
9
10 import com.google.common.cache.Cache;
11 import com.google.common.cache.CacheBuilder;
12 import java.util.concurrent.Callable;
13 import java.util.concurrent.ExecutionException;
14 import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
15 import org.opendaylight.yangtools.concepts.Codec;
16 import org.opendaylight.yangtools.yang.common.Empty;
17 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
18 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
19 import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
20 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
21
22 /**
23  * Value codec, which serializes / deserializes values from DOM simple values.
24  */
25 abstract class ValueTypeCodec implements Codec<Object, Object> {
26
27     private static final Cache<Class<?>, SchemaUnawareCodec> STATIC_CODECS = CacheBuilder.newBuilder().weakKeys()
28             .build();
29
30     /**
31      * Marker interface for codecs, which functionality will not be affected by schema change (introduction of new YANG
32      * modules) they may have one static instance generated when first time needed.
33      */
34     interface SchemaUnawareCodec extends Codec<Object,Object> {
35
36     }
37
38     /**
39      * No-op Codec, Java YANG Binding uses same types as NormalizedNode model for base YANG types, representing numbers,
40      * binary and strings.
41      */
42     public static final SchemaUnawareCodec NOOP_CODEC = new SchemaUnawareCodec() {
43
44         @Override
45         public Object serialize(final Object input) {
46             return input;
47         }
48
49         @Override
50         public Object deserialize(final Object input) {
51             return input;
52         }
53     };
54
55     public static final SchemaUnawareCodec EMPTY_CODEC = new SchemaUnawareCodec() {
56
57         @Override
58         public Object serialize(final Object input) {
59             // Empty type has Empty value in NormalizedNode and Composite Node representation
60             return Empty.getInstance();
61         }
62
63         @Override
64         public Object deserialize(final Object input) {
65             /* Empty type has boolean.TRUE representation in Binding-aware world otherwise it is null / false.
66              * So when codec is triggered, empty leaf is present, that means we are safe to return true.
67              */
68             return Boolean.TRUE;
69         }
70     };
71
72     private static final Callable<? extends SchemaUnawareCodec> EMPTY_LOADER = () -> EMPTY_CODEC;
73
74
75     public static SchemaUnawareCodec getCodecFor(final Class<?> typeClz, final TypeDefinition<?> def) {
76         if (BindingReflections.isBindingClass(typeClz)) {
77             return getCachedSchemaUnawareCodec(typeClz, getCodecLoader(typeClz, def));
78         }
79         return def instanceof EmptyTypeDefinition ? EMPTY_CODEC : NOOP_CODEC;
80     }
81
82     private static SchemaUnawareCodec getCachedSchemaUnawareCodec(final Class<?> typeClz,
83             final Callable<? extends SchemaUnawareCodec> loader) {
84         try {
85             return STATIC_CODECS.get(typeClz, loader);
86         } catch (ExecutionException e) {
87             throw new IllegalStateException(e);
88         }
89     }
90
91     private static Callable<? extends SchemaUnawareCodec> getCodecLoader(final Class<?> typeClz,
92             final TypeDefinition<?> def) {
93
94         TypeDefinition<?> rootType = def;
95         while (rootType.getBaseType() != null) {
96             rootType = rootType.getBaseType();
97         }
98         if (rootType instanceof EnumTypeDefinition) {
99             return EnumerationCodec.loader(typeClz, (EnumTypeDefinition) rootType);
100         } else if (rootType instanceof BitsTypeDefinition) {
101             return BitsCodec.loader(typeClz, (BitsTypeDefinition) rootType);
102         }
103         return EncapsulatedValueCodec.loader(typeClz, def);
104     }
105
106     @SuppressWarnings("rawtypes")
107     static ValueTypeCodec encapsulatedValueCodecFor(final Class<?> typeClz, final TypeDefinition<?> typeDef,
108              final Codec delegate) {
109         SchemaUnawareCodec extractor = getCachedSchemaUnawareCodec(typeClz,
110             EncapsulatedValueCodec.loader(typeClz, typeDef));
111         return new CompositeValueCodec(extractor, delegate);
112     }
113
114 }