#290

Committed 05 Nov 2023 07:20PM UTC coverage: 89.848% (-0.2%) from 90.032%

Build # #290

Build Type

Committed by

Commit Message

Code coverage and clean up. Breaking API change.

Pull Request Pull Request #10: feature/beans record

Run Details

78 of 82 new or added lines in 12 files covered. (95.12%)

2 existing lines in 2 files now uncovered.

7461 of 8304 relevant lines covered (89.85%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.5

/lis-commons-beans/src/main/java/com/link_intersystems/beans/FilteredBeanClass.java

package com.link_intersystems.beans;

import java.util.List;

import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.toList;

/**
 * @author René Link {@literal <rene.link@link-intersystems.com>}
 */
class FilteredBeanClass<T> extends BeanClass<T> {

    private BeanClass<T> beanClass;
    private PropertyDescFilter propertyFilter;

    FilteredBeanClass(BeanClass<T> beanClass, PropertyDescFilter propertyFilter) {
        this.beanClass = requireNonNull(beanClass);
        this.propertyFilter = requireNonNull(propertyFilter);
    }

    @Override
    public String getName() {
        return beanClass.getName();
    }

    @Override
    public Class<T> getType() {
        return beanClass.getType();
    }


    @Override
    public BeanInstanceFactory<T> getBeanInstanceFactory() {
        BeanInstanceFactory<T> beanInstanceFactory = beanClass.getBeanInstanceFactory();
        return new BeanInstanceFactory<T>() {
            @Override
            public Bean<T> newBeanInstance(ArgumentResolver argumentResolver) {
                Bean<T> bean = beanInstanceFactory.newBeanInstance(argumentResolver);
                return new FilteredBean<>(FilteredBeanClass.this, bean, propertyFilter);
            }

            @Override
            public Bean<T> fromExistingInstance(T beanObject) {
                Bean<T> bean = beanInstanceFactory.fromExistingInstance(beanObject);
                return new FilteredBean<>(FilteredBeanClass.this, bean, propertyFilter);
            }
        };
    }

    @Override
    public BeanEventTypeList getBeanEventTypes() {
        return beanClass.getBeanEventTypes();
    }

    @Override
    public PropertyDescList getProperties() {
        PropertyDescList properties = beanClass.getProperties();
        return getFilteredProperties(properties);
    }

    @Override
    public PropertyDescList getIndexedProperties() {
        PropertyDescList properties = beanClass.getIndexedProperties();
        return getFilteredProperties(properties);
    }

    @Override
    public PropertyDescList getAllProperties() {
        PropertyDescList properties = beanClass.getAllProperties();
        return getFilteredProperties(properties);
    }

    private PropertyDescList getFilteredProperties(PropertyDescList properties) {
        List<? extends PropertyDesc> filteredPropertyDescs = properties.stream()
                .filter(propertyFilter::accept)
                .collect(toList());
        return new PropertyDescList(filteredPropertyDescs);
    }

    @Override
    public String toString() {
        return "FilteredBeanClass{" +
                "beanClass=" + beanClass +
                ", propertyFilter=" + propertyFilter +
                '}';
    }

    private static class FilteredBean<T> extends Bean<T> {

        private final BeanClass<T> beanClass;
        private final Bean<T> bean;
        private final PropertyDescFilter propertyFilter;

        public FilteredBean(BeanClass<T> beanClass, Bean<T> bean, PropertyDescFilter propertyFilter) {
            super(beanClass, bean.getBeanObject());
            this.beanClass = beanClass;
            this.bean = bean;
            this.propertyFilter = propertyFilter;
        }

        @Override
        public PropertyList getAllProperties() {
            List<Property> properties = bean.getProperties().stream()
                    .filter(this::accept).collect(toList());
            return new PropertyList(properties);
        }

        private boolean accept(Property property) {
            return propertyFilter.accept(property.getPropertyDesc());
        }

        @Override
        public T getBeanObject() {
            return bean.getBeanObject();
        }

        @Override
        public BeanClass<T> getBeanClass() {
            return beanClass;
        }

        @Override
        public void removeListener(Object listener) {
            bean.removeListener(listener);
        }

        @Override
        public void addListener(Object listener) {
            bean.addListener(listener);
        }

        @Override
        public String toString() {
            return "FilteredBean{" +
                    "bean=" + bean +
                    ", propertyFilter=" + propertyFilter +
                    '}';
        }
    }
}

1	package com.link_intersystems.beans;
2
3	import java.util.List;
4
5	import static java.util.Objects.requireNonNull;
6	import static java.util.stream.Collectors.toList;
7
8	/**
9	* @author René Link {@literal <rene.link@link-intersystems.com>}
10	*/
11	class FilteredBeanClass<T> extends BeanClass<T> {
12
13	private BeanClass<T> beanClass;
14	private PropertyDescFilter propertyFilter;
15
16	FilteredBeanClass(BeanClass<T> beanClass, PropertyDescFilter propertyFilter) {	1✔
17	this.beanClass = requireNonNull(beanClass);	1✔
18	this.propertyFilter = requireNonNull(propertyFilter);	1✔
19	}	1✔
20
21	@Override
22	public String getName() {
23	return beanClass.getName();	1✔
24	}
25
26	@Override
27	public Class<T> getType() {
28	return beanClass.getType();	1✔
29	}
30
31
32	@Override
33	public BeanInstanceFactory<T> getBeanInstanceFactory() {
34	BeanInstanceFactory<T> beanInstanceFactory = beanClass.getBeanInstanceFactory();	1✔
35	return new BeanInstanceFactory<T>() {	1✔
36	@Override
37	public Bean<T> newBeanInstance(ArgumentResolver argumentResolver) {
NEW 38	Bean<T> bean = beanInstanceFactory.newBeanInstance(argumentResolver);	×
UNCOV 39	return new FilteredBean<>(FilteredBeanClass.this, bean, propertyFilter);	×
40	}
41
42	@Override
43	public Bean<T> fromExistingInstance(T beanObject) {
44	Bean<T> bean = beanInstanceFactory.fromExistingInstance(beanObject);	1✔
45	return new FilteredBean<>(FilteredBeanClass.this, bean, propertyFilter);	1✔
46	}
47	};
48	}
49
50	@Override
51	public BeanEventTypeList getBeanEventTypes() {
52	return beanClass.getBeanEventTypes();	×
53	}
54
55	@Override
56	public PropertyDescList getProperties() {
57	PropertyDescList properties = beanClass.getProperties();	1✔
58	return getFilteredProperties(properties);	1✔
59	}
60
61	@Override
62	public PropertyDescList getIndexedProperties() {
63	PropertyDescList properties = beanClass.getIndexedProperties();	×
64	return getFilteredProperties(properties);	×
65	}
66
67	@Override
68	public PropertyDescList getAllProperties() {
69	PropertyDescList properties = beanClass.getAllProperties();	×
70	return getFilteredProperties(properties);	×
71	}
72
73	private PropertyDescList getFilteredProperties(PropertyDescList properties) {
74	List<? extends PropertyDesc> filteredPropertyDescs = properties.stream()	1✔
75	.filter(propertyFilter::accept)	1✔
76	.collect(toList());	1✔
77	return new PropertyDescList(filteredPropertyDescs);	1✔
78	}
79
80	@Override
81	public String toString() {
82	return "FilteredBeanClass{" +	×
83	"beanClass=" + beanClass +
84	", propertyFilter=" + propertyFilter +
85	'}';
86	}
87
88	private static class FilteredBean<T> extends Bean<T> {
89
90	private final BeanClass<T> beanClass;
91	private final Bean<T> bean;
92	private final PropertyDescFilter propertyFilter;
93
94	public FilteredBean(BeanClass<T> beanClass, Bean<T> bean, PropertyDescFilter propertyFilter) {
95	super(beanClass, bean.getBeanObject());	1✔
96	this.beanClass = beanClass;	1✔
97	this.bean = bean;	1✔
98	this.propertyFilter = propertyFilter;	1✔
99	}	1✔
100
101	@Override
102	public PropertyList getAllProperties() {
103	List<Property> properties = bean.getProperties().stream()	1✔
104	.filter(this::accept).collect(toList());	1✔
105	return new PropertyList(properties);	1✔
106	}
107
108	private boolean accept(Property property) {
109	return propertyFilter.accept(property.getPropertyDesc());	1✔
110	}
111
112	@Override
113	public T getBeanObject() {
114	return bean.getBeanObject();	1✔
115	}
116
117	@Override
118	public BeanClass<T> getBeanClass() {
119	return beanClass;	1✔
120	}
121
122	@Override
123	public void removeListener(Object listener) {
124	bean.removeListener(listener);	1✔
125	}	1✔
126
127	@Override
128	public void addListener(Object listener) {
129	bean.addListener(listener);	1✔
130	}	1✔
131
132	@Override
133	public String toString() {
134	return "FilteredBean{" +	×
135	"bean=" + bean +
136	", propertyFilter=" + propertyFilter +
137	'}';
138	}
139	}
140	}

link-intersystems / lis-commons / #290

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous