Problema dificil com tipologias (o coisa chata esses <T> do java)

Lavieri:

Tudo isso está na classe *Manager, certo ? Defina a classe como EntityCollectionManager e
defina os métodos em função do parametro da classe,
e não em cada um dos métodos.

+1 coisa, no método containsAll(EntityCollectionManager), por que não usa o “enhanced for” ? O código fica bem mais limpo

Jorge

Jorge Diz:

Lavieri:

Tudo isso está na classe *Manager, certo ? Defina a classe como EntityCollectionManager e
defina os métodos em função do parametro da classe,
e não em cada um dos métodos.

+1 coisa, no método containsAll(EntityCollectionManager), por que não usa o “enhanced for” ? O código fica bem mais limpo

Jorge

Noop… são 3 classes ai em questão…

1° se chama DataBase… ela tem funções estaticas, é uma classe de configuração, nela esta contida todos os reposiotorios do meu sistema… Por exemplo, se eu quiser resgatar o repositorio de alunos eu faço DataBase.getCurrentEntityRepository(Aluno.class) … e o repositorio de alunos sabe como tratar as entidades alunos… com esse repositorio eu tenho acesso a todas as funções como add, remove, update, etc etc etc …

2° se chama Repositories… ela é um atalho da 1° classe… através dela, eu consigo invocar os métodos dos repositorios sem ter q ficar passando a classe… para adcionar um aluno, por exemplo, basta fazer… repositories.add(aluno1) … o que esta classe faz é simples… ela busca o repositorio correto fazendo DataBase.getCurrentEntityRepository(aluno1.getClass).add(aluno1) … é basicamento isso que ela faz, ala me poupa de chamar o repositorio separado, e funciona como um repositorio generico…

3° se chama EntityCollectionManager … esta classe organiza coleções… c eu der um manager.add(aluno1) e manager.add(curso3) e manager.add(aluno2) e manager.add(matricula2) … ele vai guardar cada qual em sua coleção correspondente… c eu fizer … manager.getEntityCollection(Aluno.class) ele vai me voltar uma Collection só com o aluno1 e aluno2 … posso fazer o mesmo pra curso e matriculas… posso tb pedir a lista de entidades contidas no manager, esta lista são todas de Classes que extende a assinatura de entidade…

Enfim … desta forma eu estou querendo implementar, na segunda classe (a de atalhos de repositorios) … métodos como… addAll(EntityCollectionManager manager) … containsAll(EntityCollectionManager manager) … removeAll(EntityCollectionManager manager) …

Esta classe repositorios teria que ver a lista de de coleções do manager… para cada coleção, invocar o método correspondente, e passar a coleção como parametro…

o problema todo está nas tipologias…

se eu tiver

repAlunos = DataBase.getCurrentEntityRepository(Aluno.class); //o comando add do repositorio só irá aceitar alunos repAlunos.addAll(Collection<Aluno> entitys);

o problema está aqui… quando eu faço…

listaDeClasses = manager.getEntityClasses(); //eu recebo 1 Iterator com a lista de classes que tem dentro do manager... while(listaDeClasses.hasnext()) { entityClass = listaDeClasses.next(); manager.getEntityCollection(entityClass); //isto vai me retornar a coleção para primeira classe de entidades //eu sei que tanto "entityClass" como "manager.getEntityCollection(entityClass)" são referentes a alunos, e são da mesma classe //porem meu compilador não aceita fazer contaisAll(entityClass, manager.getEntityCollection(entityClass)); //a tipologia dois para o compilador é <? extends IEntitySignature> e ele não entende que os 2 são da mesma classe //apesar de que "entityClass" é uma Class<Aluno> e manager.getEntityCollection(entityClass) é uma Collection<Aluno> //o fato é que como manager.getEntityClasses(); me reporta uma lista sem a tipologia definida, eu precisaria fazer um cast... //mas eu não sei fazer um cast do tipo (Class<entityClass.getClass()>)entityClass ... entendeu o problema ??

Deixa eu ver se eu entendi… sua situação atual é a seguinte, certo?

import java.util.Collection;
import java.util.Iterator;

public class TesteTipo {

	private interface IEntidade {};
	
	private class Repositorio {
	
		public <E extends IEntidade> boolean contaisAll(Class<E> entityClass,
			 	Collection<E> entitys) {
			return false;
		}
	}
	
	private class Manager {

		 public <T extends IEntidade> Collection<T> getEntityCollection 
			(Class<T> forThisClass) {  
			 return null; 
		 }
		 
		 public Iterator<Class<? extends IEntidade>> getEntityClasses() {
			 return null;
		 }
		 
		 public void addEntity(IEntidade entity) { }
	 }
	 
	 public static void main(String[] args) {
		TesteTipo t = new TesteTipo();
		Repositorio repositorio = t.new Repositorio();
		Manager manager = t.new Manager();
		Iterator<Class<? extends IEntidade>> listaDeClasses = manager.getEntityClasses();
		while(listaDeClasses.hasNext()) {
			Class<? extends IEntidade> clazz = listaDeClasses.next();
			boolean b = repositorio.contaisAll(clazz, manager.getEntityCollection(clazz)); // essa linha dá erro
		}
	}
}

Acho que a maneira mais fácil de resolver o problema é evitar que o compilador faça a verificação de tipos…:

import java.util.Collection;
import java.util.Iterator;

public class TesteTipo {

	private interface IEntidade {};
	
	private class Repositorio {
	
		public <E extends IEntidade> boolean contaisAll(Class<E> entityClass,
			 	Collection<E> entitys) {
			return false;
		}
	}
	
	private class Manager {

		 public <T extends IEntidade> Collection<T> getEntityCollection 
			(Class<T> forThisClass) {  
			 return null; 
		 }
		 
		 public Iterator<Class> getEntityClasses() {
			 return null;
		 }
		 
		 public void addEntity(IEntidade entity) { }
	 }
	 
	 public static void main(String[] args) {
		TesteTipo t = new TesteTipo();
		Repositorio repositorio = t.new Repositorio();
		Manager manager = t.new Manager();
		Iterator<Class> listaDeClasses = manager.getEntityClasses();
		while(listaDeClasses.hasNext()) {
			Class clazz = listaDeClasses.next();
			boolean b = repositorio.contaisAll(clazz, manager.getEntityCollection(clazz));
		}
	}
}

É feio? É… mas resolve

é MarceloS… é +ou- isso dai mesmo…

só que remover o tipo gera um outro problema…

Eu tenho 1 classe assim… Repository<E extends IEntidade> …

quando alguem faz… containsAll(Collection<Aluno> collection) por exemplo…
esse contains all… chama o repositorio Repository<Aluno> para resolver o assunto…

e o repositorio que entende de Alunos é o Repository<Aluno> … c eu mandar 1 coleção de Matriculas pra ele, vai dar merda ^^

enfim… se eu num tiver a confirmação de tipologia, não consigo invocar o repositorio correto pra tratar… lembrando que além de containsAll() tempos addAll, etc etc etc … é preciso saber o tipo, pro tratamento ser de acordo la do lado da persistencia… não sei pq não funciona

Olha… não sei como vc implementou o método pra chamar o repositório, mas em tempo de execução, a classe que você terá chamando como “Class” é a mesma que você terá chamando como “Class<? extends AlgumaCoisa>”… tirando os <> você só evita que o compilador verifique isso pra você.

me tira uma dúvida.... c eu tenho um método assim....

public <E extends IEntitySignature> void updateAll(Collection<E> entitys) {
       //Aqui dentro eu tenho como saber a classe E ?? o simples seria E.class ...

       //O ideal era fazer assim
       DataBase.getCurrentEntityRepository(E.class).updateAll(entitys);
}
}

@SuppressWarnings("unchecked")
public <E extends IEntitySignature> void updateAll(Collection<E> entitys){
	if (entitys.size() > 0) {
		E firstElement = entitys.iterator().next();
		Class<E> entitysClass = (Class<E>)firstElement.getClass();
		DataBase.getCurrentEntityRepository(entitysClass).updateAll(entitys);
	}
}

........

public static <E extends IEntitySignature> Repository<E> getCurrentEntityRepository(Class<E> entityClass)

public abstract class Repository<T extends IEntitySignature> {
	//...
	public final TransactionResult addOrUpdateAll(Collection<T> entitys)
	//...

Repositories.class

//public <E extends IEntitySignature> void updateAll(Collection<E> entitys) {
public void updateAll(Collection entitys) {
     Class clazz = entitys.get(0).getClass();
     DataBase.getCurrentEntityRepository(clazz).updateAll(entitys);
}
// ou ainda
public void updateAll(Collection entitys, Class clazz) {
       DataBase.getCurrentEntityRepository(clazz).updateAll(entitys);
}

public void updateAll(Collection entitys){
	if (entitys.size() > 0) {
		Object firstElement = entitys.iterator().next();
		Class entitysClass = firstElement.getClass();
		DataBase.getCurrentEntityRepository(entitysClass).updateAll(entitys);
	}
}

Acredito que você não tenha maiores problemas tirando o tipo daquele método; você só vai ter um monte de "warnings" gerados pelo compilador avisando que você está fazendo operações "unchecked"…

O problema é que a classe Repositories é publica… é usada por outras pessoas, e algum ignorante (quando falo ignorante, falo desinformado) pode tentar enviar uma Collection de Objejetos que não assinam IEntity… isso vai gerar uma exceção em tempo de execução… ai depois o bug vai ter q ser rastreado, ate verificar que algum burrinho, fez a cagada de não checar o tipo… preferia não liberar o tipos incopativeis com o repositório… ai se alguem kizer mandar um tipo genérico mesmo assim, ai já não posso fazer nada ^^, pelomenos o aviso vai ta la no método ao olho de todos