Moin moin,
ich hab da mal eine abstrakte klasse für die geschichte rund um xpath geschrieben, welche ihrerseits nur die ganzen achsen beinhaltet...
desweiteren hab ich, wie dem aufmerksamen code-leser aufgefallen ist, zwei weitere klassen davon abgeleitet:
und
Jetzt wollt ich fragen, ob das so sinnvoll ist... das es geht, erübrigt sich an dieser stelle...
Ich persönlich finde das mit den zwei abgeleiteten klassen genial (klar, ist ja auch von mir :wink
Gut, ja, es gibt da noch andere Möglichkeiten...
aber was sagt ihr zu diesem Stil ?
ich hab da mal eine abstrakte klasse für die geschichte rund um xpath geschrieben, welche ihrerseits nur die ganzen achsen beinhaltet...
Code:
import java.util.Arrays;
import java.util.Random;
import java.util.Vector;
public abstract class AbstractAxes
{
private final Vector<EnumAxes> _axes;
private final int AXES_LENGTH;
private final Random _rand = new Random();
private int _lastIndex = 0;
public AbstractAxes( Class child )
{
_axes = new Vector<EnumAxes>();
if( child == XPathAxes.class )
{
_axes.addAll( Arrays.asList( EnumAxes.values() ) );
}
if( child == FirstLevelAxes.class )
{
_axes.add( EnumAxes.CHILD );
_axes.add( EnumAxes.DESCENDANT );
_axes.add( EnumAxes.DESCENDANT_OR_SELF );
_axes.add( EnumAxes.FOLLOWING_SIBLING );
}
AXES_LENGTH = _axes.size();
}
/**
* This method ensures that the next axe is not the same as the last axe.
* @return the next axe.
*/
public final String nextShuffledAxe()
{
int lastIndex = _lastIndex;
while( _lastIndex == lastIndex )
_lastIndex = Math.abs( _rand.nextInt() ) % AXES_LENGTH;
return _axes.get( _lastIndex ).value();
}
private enum EnumAxes
{
CHILD ( "/child::" ),
DESCENDANT ( "/descendant::" ),
DESCENDANT_OR_SELF( "/descendant-or-self::" ),
FOLLOWING_SIBLING ( "/following-sibling::" ),
PARENT ( "/parent::" ),
ANCESTOR ( "/ancestor::" ),
ANCESTOR_OR_SELF ( "/ancestor-or-self::" ),
PRECEDING ( "/preceding::" ),
PRECEDING_SIBLING ( "/preceding-sibling::" ),
FOLLOWING ( "/following::" ),
SELF ( "/self::" );
private String _value;
private EnumAxes( String valuep )
{
_value = value;
}
/**
* @return the value of the axe.
*/
public String value(){ return _value; }
}
}
desweiteren hab ich, wie dem aufmerksamen code-leser aufgefallen ist, zwei weitere klassen davon abgeleitet:
Code:
public class FirstLevelAxes extends AbstractAxes
{
public FirstLevelAxes()
{
super( FirstLevelAxes.class );
}
}
Code:
public class XPathAxes extends AbstractAxes
{
public XPathAxes()
{
super( XPathAxes.class );
}
}
Jetzt wollt ich fragen, ob das so sinnvoll ist... das es geht, erübrigt sich an dieser stelle...
Ich persönlich finde das mit den zwei abgeleiteten klassen genial (klar, ist ja auch von mir :wink
Gut, ja, es gibt da noch andere Möglichkeiten...
aber was sagt ihr zu diesem Stil ?