/**

* Método que coloca un nodo en un 'nivel_n' a partir de un 'nivel_0' y

através de una ruta 'nivel_1/nivel2/../nivel_n-1/'.
* El método recorrerá los nodos [nivel_1 .. nivel_n-1], este recorrido
podrá estár condicionado por los atributos de cada nodo
* para ello será oblibatorio enviar una lista con los atributos a busca
r de cada nodo [attNivel_1 .. attNivel_n-1]
* @param sRuta String en el siguiente formato nivel_1/nivel2/../nivel_n
-1/.
* Debe acabar con "/" y empezar con un hijo del nodo elementPadre
* @param root Element nodo raiz que corresponderá con nivel_0.
* @param elementPadre Element nodo padre de la ruta 'sRuta' corresponde
ría con el nivel_0 y será siempre el padre del primer elemento de la ruta sRuta
* @param elementParaColocar Element nodo hijo que correspondería a nive
l_n y es el que queremos colocar.
* @param listaAtributos List de objetos Hashtable que contiene los atri
butos, habrá tantos objetos Hashtable como elementos con atributos.
* A la hora de formar esta lista hay que tener encuenta:
* 1. Tiene que haber tantos items en la lista como niveles en la sRuta.
* 2. Cada item de la lista representa los atributos de un nodo de sRuta
* 3. Cuando se quiere representar un nodo de sRuta sin tener en cuenta
los atributos se introducirá un item null.
* Ejemplo sRuta(nivel_1/nivel_2/) el nodo nivel_1 no tiene atributos y
el nodo nivel_2 tiene(id="4") entonces listaAtributos=[null, hashtable.put("id",
"4")]
* @return Element nodo padre que correspondería con nivel_0 con el nuev
o hijo en su sitio
* null en el caso de encontrar algún error
* @throws Throwable
*/
public static Element colocaElementRutaXPath(String sRuta, Element root,
Element elementPadre, Element elementParaColocar, List listaAtributos) throws T
hrowable{
//Preparo parámetros
sRuta=sRuta.trim();
String[] aElementRuta = sRuta.split("/");
String nombreElementHijo = null;
Hashtable atributosElementHijo = null;
Element elementHijo = null;
try{
if(aElementRuta!=null){
nombreElementHijo = aElementRuta[0];
}
//caso base
if(nombreElementHijo == null || "".equals(nombreElementH
ijo)){
cuelgaClonHijoEnNodoPadre(elementParaColocar, el
ementPadre);
return root;
}
//caso inductivo
else{
atributosElementHijo = (Hashtable)listaAtributos
.get(0);//puede ser null
//no existe el atributo hijo
if( !testExisteNodoHijoConAtributos(nombreElemen
tHijo, atributosElementHijo, elementPadre)){
elementHijo = creaNodoConAtributos(nombr
eElementHijo, atributosElementHijo);
elementPadre = cuelgaHijoEnNodoPadre(ele
mentHijo, elementPadre);
}
//si existe atributo hijo
else{
elementHijo = dameNodoHijoConAtributos(n
ombreElementHijo, atributosElementHijo, elementPadre);
}
//actualizo variables para llamada recursiva
sRuta = sRuta.replaceFirst(nombreElementHijo+"/"
, "");
listaAtributos.remove(0);
//llamada recursiva.
colocaElementRutaXPath(sRuta, root, elementHijo
, elementParaColocar, listaAtributos);
}
}
catch(Throwable e){
logger.error("EncapsuladorJDOM.colocaElementRutaXPath(sR
uta, root, elementPadre, elementParaColocar, listaAtributos)", e);
throw new Throwable("EncapsuladorJDOM.colocaElementRutaX
Path(sRuta, root, elementPadre, elementParaColocar, listaAtributos)", e);
}
return null;
}
/**
* Método que cuelga un nodo(hijo) de otro (padre)
* @param elementHijo Element
* @param elementPadre Element
* @return Element elementPadre
*/
public static Element cuelgaHijoEnNodoPadre(Element elementHijo, Element
elementPadre) {
elementPadre.addContent(elementHijo);
return elementPadre;
}
/**
* Método que cuelga una copia de un nodo (hijo) en otro (padre)
* Será usado cuando el nodo hijo pertenezca a un arbol (Document)
* distinto al nodo padre.
* @param elementHijo Element
* @param elementPadre Element
* @return Element elementPadre
*/
public static Element cuelgaClonHijoEnNodoPadre(Element elementHijo, Ele
ment elementPadre) {
Element newElementHijo = new Element(elementHijo.getName());
List cloneContent = elementHijo.cloneContent();
newElementHijo.setContent(cloneContent);
elementPadre.addContent(newElementHijo);
return elementPadre;
}
/**
 * Método que comprueba la existencia de un nodo(hijo) con ciertos atrib
utos colgando de un nodo(padre)
* @param nombreElementHijo String
* @param atributosElementHijo Hashtable key=nombreAtributo, value=valo
rAtributo o null
* @param elementPadre Element
* @return true si esite un nodo con nombreElementHijo y atributosElemen
tHijo false en caso contrario
* @throws Throwable
*/
public static boolean testExisteNodoHijoConAtributos(String nombreElemen
tHijo, Hashtable atributosElementHijo, Element elementPadre) throws Throwable {
try{
List listaHijos = elementPadre.getChildren(nombreElement
Hijo);
for(Iterator itr = listaHijos.iterator(); itr.hasNext();
){
Element elementHijo = (Element)itr.next();
if(testNodoTieneEstosAtributos(elementHijo, atri
butosElementHijo)){
return true;
}
}
}
catch(Throwable e){
logger.error("EncapsuladorJDOM.testExisteNodoHijoConAtri
butos(nombreElementHijo, atributosElementHijo, elementPadre)", e);
throw new Throwable("EncapsuladorJDOM.testExisteNodoHijo
ConAtributos(nombreElementHijo, atributosElementHijo, elementPadre)", e);
}
return false;
}
/**
* Método que crea un nuevo nodo con los atributos que está en es Hashta
ble atributosNodo
* @param nombreNodo String
* @param atributosNodo Hashtable key=nombreAtributo, value=valorAtribu
to o null
* @return Element el nuevo nodo
* @throws Throwable
*/
public static Element creaNodoConAtributos(String nombreNodo, Hashtable
atributosNodo) throws Throwable {
Element newElementHijo = null;
try{
if(nombreNodo != null || "".equals(nombreNodo)){
newElementHijo = new Element(nombreNodo);
if(atributosNodo != null){
Enumeration enumeration = atributosNodo.
keys();
while(enumeration.hasMoreElements()){
String nombreAtributo = (String)
enumeration.nextElement();
String valorAtributo = (String)a
tributosNodo.get(nombreAtributo);
//añado atributos.
newElementHijo.setAttribute(nomb
reAtributo, valorAtributo);
}
 }
}
}
catch(Throwable e){
logger.error("EncapsuladorJDOM.creaNodoConAtributos(nomb
reNodo, atributosNodo)", e);
throw new Throwable("EncapsuladorJDOM.creaNodoConAtribut
os(nombreNodo, atributosNodo)", e);
}
return newElementHijo;
}

/**
* Método que retorna un nodo hijo con ciertos atributos
* @param nombreElementHijo String
* @param atributosElementHijo Hashtable key=nombreAtributo, value=valor
Atributo o null
* @param elementPadre Element
* @return Element nodo hijo o si no se encuentra null
* @throws Throwable
*/
public static Element dameNodoHijoConAtributos(String nombreElementHijo,
Hashtable atributosElementHijo, Element elementPadre) throws Throwable {
try{
List listaHijos = elementPadre.getChildren(nombreElement
Hijo);
for(Iterator itr = listaHijos.iterator(); itr.hasNext();
){
Element elementHijo = (Element)itr.next();
if(testNodoTieneEstosAtributos(elementHijo, atri
butosElementHijo)){
return elementHijo;
}
}
}
catch(Throwable e){
logger.error("EncapsuladorJDOM.dameNodoHijoConAtributos(
nombreElementHijo, atributosElementHijo, elementPadre)", e);
throw new Throwable("EncapsuladorJDOM.dameNodoHijoConAtr
ibutos(nombreElementHijo, atributosElementHijo, elementPadre)", e);
}
return null;
}

/**
* Método que comprueba que un nodo tenga todos los atributos atributosN
odo Hashtable
* @param nodo Element
* @param atributosNodo Hashtable key=nombreAtributo, value=valorAtribu
to o null
* @return true tiene los mismos atributos, false en caso contrario
* @throws Throwable
*/
public static boolean testNodoTieneEstosAtributos(Element nodo, Hashtabl
e atributosNodo) throws Throwable {
try{
if(atributosNodo == null || atributosNodo.isEmpty()){
return true;
 }
else{
Enumeration enumeration = atributosNodo.keys();
while(enumeration.hasMoreElements()){
String nombreAtributo = (String)enumerat
ion.nextElement();
String valorAtributo = (String)atributos
Nodo.get(nombreAtributo);
if(valorAtributo.equalsIgnoreCase(nodo.g
etAttributeValue(nombreAtributo))){
return true;
}
}
}
}
catch(Throwable e){
logger.error("EncapsuladorJDOM.testNodoTieneEstosAtribut
os(nodo="+nodo+", atributosNodo)", e);
throw new Throwable("EncapsuladorJDOM.testNodoTieneEstos
Atributos(nodo="+nodo+", atributosNodo)", e);
}
return false;
}
/**
* Método que retorna el contenido (String) del primer nodo hijo ciertos
atributos
* @param nombreElementHijo String
* @param atributos Hashtable [key=nombreAtributo, value=valorAtributo]
o null
* @param elementPadre Element
* @return String con el contenido y "" en caso contrario.
* @throws Throwable
*/
public static String dameContenidoEtiquetaConAtributos(String nombreElem
entHijo, Hashtable atributos, Element elementPadre) throws Throwable {
try{
List listaHijos = elementPadre.getChildren(nombreElement
Hijo);
for(Iterator itr = listaHijos.iterator(); itr.hasNext();
){
Element elementHijo = (Element)itr.next();
if(testNodoTieneEstosAtributos(elementHijo, atri
butos)){
return dameNodoTieneEstosAtributos(eleme
ntHijo, atributos);
}
}
}catch (Throwable e) {
String mensaje ="JDOMUtils.dameContenidoEtiquetaConAtrib
utos(nombreEtiquetaABuscar, atributos, raiz)";
logger.error(mensaje, e);
throw new Throwable(mensaje);
}
return "";
}
/**
* Método que retorna el contenido del primer nodo que tenga ciertos atr
ibutos
* @param nodo Element
* @param atributosNodo Hashtable [key=nombreAtributo, value=valorAtrib
uto] o null
* @return String con el contenido y "" en caso contrario.
* @throws Throwable
*/
public static String dameNodoTieneEstosAtributos(Element nodo, Hashtable
atributosNodo) throws Throwable {
try{
if(atributosNodo == null || atributosNodo.isEmpty()){
return nodo.getTextTrim();
}
else{
Enumeration enumeration = atributosNodo.keys();
while(enumeration.hasMoreElements()){
String nombreAtributo = (String)enumerat
ion.nextElement();
String valorAtributo = (String)atributos
Nodo.get(nombreAtributo);
if(valorAtributo.equalsIgnoreCase(nodo.g
etAttributeValue(nombreAtributo))){
return nodo.getTextTrim();
}
}
}
}
catch(Throwable e){
logger.error("EncapsuladorJDOM.dameNodoTieneEstosAtribut
os(nodo="+nodo+", atributosNodo)", e);
throw new Throwable("EncapsuladorJDOM.dameNodoTieneEstos
Atributos(nodo="+nodo+", atributosNodo)", e);
}
return "";
}