All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • ru.d_shap.conditionalvalues.ValueSet Maven / Gradle / Ivy

    Go to download

    Conditional values simplify conditional logic and get rid of if-statements in the code

    The newest version!
    ///////////////////////////////////////////////////////////////////////////////////////////////////
// Conditional values simplify conditional logic and get rid of if-statements in the code.
// Copyright (C) 2016 Dmitry Shapovalov.
//
// This file is part of conditional values.
//
// Conditional values is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Conditional values is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see .
///////////////////////////////////////////////////////////////////////////////////////////////////
package ru.d_shap.conditionalvalues;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Class represents a distinct condition with a corresponding values for this condition.
 *
 * @param  generic type for the value.
 *
 * @author Dmitry Shapovalov
 */
public final class ValueSet {

    private final String _id;

    private final Predicate _predicate;

    private final Map _predicates;

    private final Map> _conditions;

    private final Set _conditionNames;

    private final List _values;

    ValueSet(final String id, final Predicate predicate, final Map predicates, final Map> conditions, final List values) {
        super();
        _id = id;
        _predicate = predicate;
        _predicates = createPredicates(predicates);
        _conditions = createConditions(conditions);
        _conditionNames = createConditionNames();
        _values = createValues(values);
    }

    private Map createPredicates(final Map predicates) {
        Map result = new HashMap<>();
        if (predicates != null) {
            for (Map.Entry entry : predicates.entrySet()) {
                String key = entry.getKey();
                Predicate predicate = entry.getValue();
                if (key != null && predicate != null) {
                    result.put(key, predicate);
                }
            }
        }
        return result;
    }

    private Map> createConditions(final Map> conditions) {
        Map> result = new HashMap<>();
        if (conditions != null) {
            for (Map.Entry> entry : conditions.entrySet()) {
                String key = entry.getKey();
                Set values = createConditionValues(entry.getValue());
                if (key != null && !values.isEmpty()) {
                    result.put(key, values);
                }
            }
        }
        return Collections.unmodifiableMap(result);
    }

    private Set createConditionValues(final Set values) {
        Set result = new HashSet<>();
        if (values != null) {
            for (Object value : values) {
                if (value != null) {
                    result.add(value);
                }
            }
        }
        return Collections.unmodifiableSet(result);
    }

    private Set createConditionNames() {
        Set result = _conditions.keySet();
        return Collections.unmodifiableSet(result);
    }

    private List createValues(final List values) {
        List result = new ArrayList<>();
        if (values != null) {
            for (T value : values) {
                if (value != null) {
                    result.add(value);
                }
            }
        }
        return Collections.unmodifiableList(result);
    }

    /**
     * Get the ID.
     *
     * @return the ID.
     */
    public String getId() {
        return _id;
    }

    /**
     * Get all condition names.
     *
     * @return all condition names.
     */
    public Set getAllConditionNames() {
        return _conditionNames;
    }

    /**
     * Get all condition values for the specified condition name.
     *
     * @param conditionName the specified condition name.
     *
     * @return all condition values for the specified condition name.
     */
    public Set getAllConditionValues(final String conditionName) {
        Set values = _conditions.get(conditionName);
        if (values == null) {
            return Collections.emptySet();
        } else {
            return values;
        }
    }

    boolean isMatchConditions(final ConditionSet conditionSet, final TuplePredicate tuplePredicate, final Map predicates, final Predicate predicate) {
        if (conditionSet == null || tuplePredicate == null) {
            return false;
        }
        int matchCount = 0;
        Iterator conditionNameIterator = conditionSet.nameIterator();
        while (conditionNameIterator.hasNext()) {
            String conditionName = conditionNameIterator.next();
            Predicate conditionPredicate = getConditionPredicate(conditionName, predicates, predicate);
            Object conditionSetValue = conditionSet.getValue(conditionName);
            Set valueSetValues = _conditions.get(conditionName);
            if (conditionPredicate == null || valueSetValues == null) {
                continue;
            }
            if (tuplePredicate.evaluate(conditionName, conditionPredicate, conditionSetValue, valueSetValues)) {
                matchCount++;
            }
        }
        return matchCount == _conditions.size();
    }

    private Predicate getConditionPredicate(final String conditionName, final Map predicates, final Predicate predicate) {
        Predicate valueSetPredicate = _predicates.get(conditionName);
        if (valueSetPredicate != null) {
            return valueSetPredicate;
        }
        if (predicates != null) {
            Predicate conditionalValuesPredicate = predicates.get(conditionName);
            if (conditionalValuesPredicate != null) {
                return conditionalValuesPredicate;
            }
        }
        if (_predicate != null) {
            return _predicate;
        }
        return predicate;
    }

    boolean isMoreSpecificValueSet(final ValueSet valueSet) {
        if (valueSet == null) {
            return false;
        }
        int matchCount = 0;
        Iterator conditionNameIterator = _conditionNames.iterator();
        while (conditionNameIterator.hasNext()) {
            String conditionName = conditionNameIterator.next();
            if (valueSet._conditions.containsKey(conditionName)) {
                matchCount++;
            }
        }
        return matchCount == valueSet._conditions.size() && matchCount < _conditions.size();
    }

    List getValueSetUniqueConditions() {
        if (_conditions.isEmpty()) {
            return Collections.emptyList();
        } else {
            List currentUniqueConditions = new ArrayList<>();
            currentUniqueConditions.add(new ValueSetUniqueCondition(_id));
            for (Map.Entry> entry : _conditions.entrySet()) {
                currentUniqueConditions = addConditionValuesToCurrentUniqueConditions(currentUniqueConditions, entry.getKey(), entry.getValue());
            }
            return Collections.unmodifiableList(currentUniqueConditions);
        }
    }

    private List addConditionValuesToCurrentUniqueConditions(final List currentUniqueConditions, final String conditionName, final Set conditionValues) {
        List newUniqueConditions = new ArrayList<>();
        for (ValueSetUniqueCondition currentUniqueCondition : currentUniqueConditions) {
            for (Object conditionValue : conditionValues) {
                ValueSetUniqueCondition newUniqueCondition = new ValueSetUniqueCondition(currentUniqueCondition, conditionName, conditionValue);
                newUniqueConditions.add(newUniqueCondition);
            }
        }
        return newUniqueConditions;
    }

    List getValues() {
        return _values;
    }

    @Override
    public String toString() {
        String conditions = _conditions.toString();
        if (_id != null) {
            conditions = _id + "=" + conditions;
        }
        return conditions;
    }

}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy