es.webbeta.serializer.metadata.MetadataConstructor.buildPropertyAccessor(MetadataProperty,Map) - Code Metrics - webbeta/Serializer - Measure and Improve Code Quality continuously with Scrutinizer

buildPropertyAccessor(MetadataProperty,Map) A
last analyzed 2022-11-10 12:15 UTC

↳ Parent: es.webbeta.serializer.metadata.MetadataConstructor

Complexity

Conditions

Size

Total Lines	13
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	10
dl	0
loc	13
c	0
b	0
f	0
cc	5
rs	9.3333

package es.webbeta.serializer.metadata;

import es.webbeta.serializer.base.MetadataProperty;
import es.webbeta.serializer.type.FieldAccessType;

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

@SuppressWarnings("unchecked")
public class MetadataConstructor {


    private static final String KEY_VIRTUAL_PROPERTIES = "virtual_properties";
    private static final String KEY_PROPERTIES = "properties";
    private static final String KEY_ACCESS_TYPE = "access_type";
    private static final String KEY_ACCESSOR = "accessor";
    private static final String KEY_SERIALIZED_NAME = "serialized_name";

    private static final String KEY_GROUPS = "groups";
    private static final String KEY_GETTER = "getter";

    public static Metadata build(Map<?, ?> map) {
        if (map == null) return null;
        Map.Entry<String, Map<String, Object>> root =
                (Map.Entry<String, Map<String, Object>>) map.entrySet().iterator().next();

        String canonicalName = root.getKey();
        Map<String, Object> modifiers = root.getValue();

        Metadata metadata = new Metadata(canonicalName);

        for (Map.Entry<String, Object> modifierEntry : modifiers.entrySet()) {
            String key = modifierEntry.getKey();

            switch (key) {

                case KEY_PROPERTIES: {
                    List<es.webbeta.serializer.metadata.MetadataProperty> properties =
                            buildProperties((Map<String, Map<String, Object>>) modifierEntry.getValue(), false);
                    metadata.setProperties(properties);
                    break;
                }
                case KEY_ACCESS_TYPE:
                    metadata.setAccessType(FieldAccessType.fromString((String) modifierEntry.getValue()));
                    break;
                case KEY_VIRTUAL_PROPERTIES: {
                    List<MetadataVirtualProperty> properties =
                            buildProperties((Map<String, Map<String, Object>>) modifierEntry.getValue(), true);
                    metadata.setVirtualProperties(properties);
                    break;
                }
            }
        }

        return metadata;
    }

    private static <T extends MetadataProperty> List<T> buildProperties(Map<String, Map<String, Object>> map, Boolean asVirtualProperties) {
        List<MetadataProperty> properties = new ArrayList<>();

        for (Map.Entry<String, Map<String, Object>> propertyEntry : map.entrySet()) {
            String propertyName = propertyEntry.getKey();
            Map<String, Object> args = propertyEntry.getValue();

            MetadataProperty metadataProperty = asVirtualProperties ?
                    new MetadataVirtualProperty(propertyName) :
                    new es.webbeta.serializer.metadata.MetadataProperty(propertyName);

            for (Map.Entry<String, Object> argEntry : args.entrySet()) {
                String key = argEntry.getKey();

                switch (key) {

                    case KEY_GROUPS:
                        List<String> groups = new ArrayList<>();
                        for (Object rawGroup : (List<?>) argEntry.getValue()) {
                            String group = (String) rawGroup;
                            groups.add(group);
                        }
                        metadataProperty.setGroups(groups);
                        break;
                    case KEY_SERIALIZED_NAME:
                        metadataProperty.setSerializedName((String) argEntry.getValue());
                        break;
                }

                if (!asVirtualProperties) {
                    switch (key) {

                        case KEY_ACCESS_TYPE:
                            metadataProperty.setAccessType(FieldAccessType.fromString((String) argEntry.getValue()));
                            break;
                        case KEY_ACCESSOR:
                            MetadataPropertyAccessor accessor =
                                    buildPropertyAccessor(metadataProperty, (Map<String, String>) argEntry.getValue());
                            metadataProperty.setAccessor(accessor);
                            break;
                    }
                }
            }

            properties.add(metadataProperty);
        }

        return (List<T>) properties;
    }

    private static MetadataPropertyAccessor buildPropertyAccessor(MetadataProperty metadataProperty, Map<String, String> map) {
        if (metadataProperty.getAccessType() != FieldAccessType.PUBLIC_METHOD) return null;

        String getter = null;
        for (Map.Entry<String, String> argEntry : map.entrySet()) {
            String key = argEntry.getKey();

            if (key.equals(KEY_GETTER))
                getter = argEntry.getValue();
        }
        return (getter == null) ?
                null :
                new MetadataPropertyAccessor(getter);
    }

}


1			package es.webbeta.serializer.metadata;
2
3			import es.webbeta.serializer.base.MetadataProperty;
4			import es.webbeta.serializer.type.FieldAccessType;
5
6			import java.util.ArrayList;
7			import java.util.List;
8			import java.util.Map;
9
10			@SuppressWarnings("unchecked")
11			public class MetadataConstructor {
			0 ignored issues – show Best Practice introduced 2019-06-18 15:02 UTC by Report Bug Copy Issue Report This looks like a utility class. You may want to hide the implict public constructor behind a private one, so the class cannot be instantiated, Loading history...
12
13			private static final String KEY_VIRTUAL_PROPERTIES = "virtual_properties";
14			private static final String KEY_PROPERTIES = "properties";
15			private static final String KEY_ACCESS_TYPE = "access_type";
16			private static final String KEY_ACCESSOR = "accessor";
17			private static final String KEY_SERIALIZED_NAME = "serialized_name";
18
19			private static final String KEY_GROUPS = "groups";
20			private static final String KEY_GETTER = "getter";
21
22			public static Metadata build(Map<?, ?> map) {
23			if (map == null) return null;
24			Map.Entry<String, Map<String, Object>> root =
25			(Map.Entry<String, Map<String, Object>>) map.entrySet().iterator().next();
26
27			String canonicalName = root.getKey();
28			Map<String, Object> modifiers = root.getValue();
29
30			Metadata metadata = new Metadata(canonicalName);
31
32			for (Map.Entry<String, Object> modifierEntry : modifiers.entrySet()) {
33			String key = modifierEntry.getKey();
34
35			switch (key) {
			0 ignored issues – show Code Smell introduced 2019-06-18 15:02 UTC by Report Bug Copy Issue Report You may want to add a default case to this switch to deal with unforseen inputs. Default branches should deal with the unexpected. At a minimum, they should log the error and if applicable, return a default value (null, empty collection). If you really do not expect the default branch to ever be use, throw a RuntimeException when it is. Loading history...
36			case KEY_PROPERTIES: {
37			List<es.webbeta.serializer.metadata.MetadataProperty> properties =
38			buildProperties((Map<String, Map<String, Object>>) modifierEntry.getValue(), false);
39			metadata.setProperties(properties);
40			break;
41			}
42			case KEY_ACCESS_TYPE:
43			metadata.setAccessType(FieldAccessType.fromString((String) modifierEntry.getValue()));
44			break;
45			case KEY_VIRTUAL_PROPERTIES: {
46			List<MetadataVirtualProperty> properties =
47			buildProperties((Map<String, Map<String, Object>>) modifierEntry.getValue(), true);
48			metadata.setVirtualProperties(properties);
49			break;
50			}
51			}
52			}
53
54			return metadata;
55			}
56
57			private static <T extends MetadataProperty> List<T> buildProperties(Map<String, Map<String, Object>> map, Boolean asVirtualProperties) {
58			List<MetadataProperty> properties = new ArrayList<>();
59
60			for (Map.Entry<String, Map<String, Object>> propertyEntry : map.entrySet()) {
61			String propertyName = propertyEntry.getKey();
62			Map<String, Object> args = propertyEntry.getValue();
63
64			MetadataProperty metadataProperty = asVirtualProperties ?
65			new MetadataVirtualProperty(propertyName) :
66			new es.webbeta.serializer.metadata.MetadataProperty(propertyName);
67
68			for (Map.Entry<String, Object> argEntry : args.entrySet()) {
69			String key = argEntry.getKey();
70
71			switch (key) {
			0 ignored issues – show Code Smell introduced 2019-06-18 15:02 UTC by Report Bug Copy Issue Report You may want to add a default case to this switch to deal with unforseen inputs. Default branches should deal with the unexpected. At a minimum, they should log the error and if applicable, return a default value (null, empty collection). If you really do not expect the default branch to ever be use, throw a RuntimeException when it is. Loading history...
72			case KEY_GROUPS:
73			List<String> groups = new ArrayList<>();
74			for (Object rawGroup : (List<?>) argEntry.getValue()) {
75			String group = (String) rawGroup;
76			groups.add(group);
77			}
78			metadataProperty.setGroups(groups);
79			break;
80			case KEY_SERIALIZED_NAME:
81			metadataProperty.setSerializedName((String) argEntry.getValue());
82			break;
83			}
84
85			if (!asVirtualProperties) {
86			switch (key) {
			0 ignored issues – show Code Smell introduced 2019-06-18 15:02 UTC by Report Bug Copy Issue Report You may want to add a default case to this switch to deal with unforseen inputs. Default branches should deal with the unexpected. At a minimum, they should log the error and if applicable, return a default value (null, empty collection). If you really do not expect the default branch to ever be use, throw a RuntimeException when it is. Loading history...
87			case KEY_ACCESS_TYPE:
88			metadataProperty.setAccessType(FieldAccessType.fromString((String) argEntry.getValue()));
89			break;
90			case KEY_ACCESSOR:
91			MetadataPropertyAccessor accessor =
92			buildPropertyAccessor(metadataProperty, (Map<String, String>) argEntry.getValue());
93			metadataProperty.setAccessor(accessor);
94			break;
95			}
96			}
97			}
98
99			properties.add(metadataProperty);
100			}
101
102			return (List<T>) properties;
103			}
104
105			private static MetadataPropertyAccessor buildPropertyAccessor(MetadataProperty metadataProperty, Map<String, String> map) {
106			if (metadataProperty.getAccessType() != FieldAccessType.PUBLIC_METHOD) return null;
107
108			String getter = null;
109			for (Map.Entry<String, String> argEntry : map.entrySet()) {
110			String key = argEntry.getKey();
111
112			if (key.equals(KEY_GETTER))
113			getter = argEntry.getValue();
114			}
115			return (getter == null) ?
116			null :
117			new MetadataPropertyAccessor(getter);
118			}
119
120			}
121

webbeta / Serializer

buildPropertyAccessor(MetadataProperty,Map) A last analyzed 2022-11-10 12:15 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

buildPropertyAccessor(MetadataProperty,Map) A
last analyzed 2022-11-10 12:15 UTC