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

    • net.technearts.Repository Maven / Gradle / Ivy

    The newest version!
    package net.technearts;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableSet;
import java.util.Optional;
import java.util.Queue;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.function.Predicate;

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Table;

public class Repository {
  private static final Logger LOG = LoggerFactory.getLogger("Marshaller");
  private Table table = HashBasedTable.create();
  private Table nonMappedMembers = HashBasedTable.create();
  private List> entityPredicates = new ArrayList<>();

  public void put(Mapping mapping, int line, Object value) {
    if (entityPredicates.stream().allMatch(predicate -> predicate.test(value))) {
      table.put(mapping, line, value);
    }
  }

  public Object get(String name, int line) {
    if (name == null) {
      throw new IllegalArgumentException("Nome não pode ser nulo");
    }
    return table.column(line).entrySet().stream()
        .filter(entry -> name.equals(entry.getKey().getName())).findFirst().orElse(null);
  }

  public Map get(String name) {
    for (Entry> entry : table.rowMap().entrySet()) {
      if (name.equals(entry.getKey().getName())) {
        return entry.getValue();
      }
    }
    return null;
  }

  public Map get(Class klazz) {
    for (Entry> entry : table.rowMap().entrySet()) {
      if (klazz.getName().equals(entry.getKey().getClassName())) {
        return entry.getValue();
      }
    }
    return null;
  }

  public void addFilter(Predicate predicate) {
    entityPredicates.add(predicate);
  }

  @SuppressWarnings("unchecked")
  public final  void set(final T bean, final Member member, final V value, String separator,
      List mappings) {
    final String name = member.getProperty();
    final String mappedBy = member.getMappedBy();
    final String converter = member.getConverter();
    try {
      Class klass = (Class) PropertyUtils.getPropertyType(bean, name);
      if (Arrays.asList(klass.getInterfaces()).contains(Collection.class)) {
        Collection c = (Collection) PropertyUtils.getProperty(bean, name);
        if (c == null) {
          c = (Collection) newCollectionInstance(klass);
          PropertyUtils.setProperty(bean, name, c);
        }
        if (value == null) {
          return;
        }
        // embedded
        if (!member.isReferenceBased()) {
          c.add(value);
          return;
        }
        // multivalued reference
        for (String o : value.toString().split(separator)) {
          if (StringUtils.isBlank(mappedBy)) {
            c.add((V) o);
          } else {
            for (Object v : this.get(converter).values()) {
              try {
                String property = mappedBy;
                Optional optionalMapping = mappings.stream()
                    .filter(mapping -> mapping.getName().equals(converter)).findFirst();
                if (optionalMapping.isPresent()) {
                  Member m = optionalMapping.get().getMember(mappedBy);
                  if (m != null) {
                    property = m.getProperty();
                  } else {
                    // TODO ?
                  }
                } else {
                  // TODO ?
                }
                String element = PropertyUtils.getProperty(v, property).toString().trim();
                if (o.trim().equals(element)) {
                  c.add((V) v);
                }
              } catch (NullPointerException e) {
                throw new IllegalArgumentException(
                    "Mapeamento " + mappedBy + " da classe " + converter + " não encontrado.");
              }
            }
          }
        }
      } else {
        PropertyUtils.setProperty(bean, name, value);
      }
    } catch (ReflectiveOperationException e) {
      LOG.error(
          "A propriedade " + name + " não foi encontrada em " + bean.getClass().getSimpleName());
    }
  }

  @SuppressWarnings("unchecked")
  private  T newCollectionInstance(Class klass) {
    T t = null;
    try {
      t = (T) klass.newInstance();
    } catch (NullPointerException | InstantiationException | IllegalAccessException e) {
      if (NavigableSet.class.equals(klass) || Set.class.equals(klass)
          || SortedSet.class.equals(klass)
          || Arrays.asList(klass.getInterfaces()).contains(NavigableSet.class)
          || Arrays.asList(klass.getInterfaces()).contains(Set.class)
          || Arrays.asList(klass.getInterfaces()).contains(SortedSet.class)) {
        t = (T) newCollectionInstance(TreeSet.class);
      } else if (List.class.equals(klass) || Queue.class.equals(klass) || Deque.class.equals(klass)
          || Arrays.asList(klass.getInterfaces()).contains(List.class)
          || Arrays.asList(klass.getInterfaces()).contains(Queue.class)
          || Arrays.asList(klass.getInterfaces()).contains(Deque.class)) {
        t = (T) newCollectionInstance(LinkedList.class);
      }
    }
    return t;
  }

  public  void set(Member member, int line, V value) {
    nonMappedMembers.put(member, line, value.toString());
  }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy