package org.jscsi.target.settings.entry;

 import org.jscsi.target.TargetServer;

 import org.jscsi.target.settings.KeySet;

 import org.jscsi.target.settings.NegotiationStatus;

 import org.jscsi.target.settings.NegotiationType;

 import org.jscsi.target.settings.NumericalResultFunction;

 import org.jscsi.target.settings.NumericalValueRange;

 import org.jscsi.target.settings.SingleNumericalValue;

 /**

  * An {@link Entry} sub-class for boolean parameters.

  * <p>

  * During text parameter negotiation, numerical parameters are negotiated by sending a single integer <i>value</i> as

  * part of a <i>key=value</i> pair. Based on the values permitted for the specific <i>key</i> (

  * {@link #protocolValueRange}), the {@link #resultFunction} and the {@link #negotiationValue}, the jSCSI Target will

  * choose a single value as the negotiation outcome.

  * <p>

  * For declared parameters this process is less complex, any proposed value from the {@link #protocolValueRange} will be

  * silently accepted.

  * <p>

  * Please note the difference between numerical values and numerical range values (see {@link NumericalRangeEntry}).

  * <p>

  * The default or negotiated value can be accessed via the {@link #getIntegerValue()} method.

  * 

  * @see Entry

  * @author Andreas Ergenzinger

  */

 public final class NumericalEntry extends Entry {

     /**

      * The integer interval describing the range of legal values.

      */

     private final NumericalValueRange protocolValueRange;

     /**

      * An integer serving as a boundary to the values the jSCSI Target is willing to accept.

      */

     private final int negotiationValue;

     /**

      * The {@link NumericalResultFunction} used for negotiating the parameter.

      */

     private final NumericalResultFunction resultFunction;

     /**

      * <code>true</code> means that a {@link #negotiationValue} of <code>0</code> allows the jSCSI Target to choose any

      * value from the resulting range. <code>false</code> means that {@link #negotiationValue} must always be treated as

      * an upper or lower boundary.

      */

     private final boolean zeroMeansDontCare;

     /**

      * The {@link NumericalEntry} constructor.

      * 

      * @param keySet contains all relevant keys

      * @param negotiationType declared or negotiated

      * @param use determines under which circumstances the parameter may be negotiated

      * @param negotiationStatus indicates whether there is a default value or if the parameter must be negotiated

      * @param negotiationValue together with the <i>resultFunction</i> and the <i>protocolValueRange</i> parameters this

      *            value indicates the values supported by the jSCSI Target

      * @param protocolValueRange specifying the range of legal values

      * @param resultFunction determines the negotiation outcome

      * @param defaultValue the default value or <code>null</code>

      * @param zeroMeansDontCare if <code>true</code> and <i>negotiationValue</i> equals <code>0</code> then

      *            <i>negotiationValue</i> does not serve as an upper or lower boundary to the values the jSCSI Target

      *            will accept

      */

     public NumericalEntry (final KeySet keySet, final NegotiationType negotiationType, final Use use, final NegotiationStatus negotiationStatus, final int negotiationValue, final NumericalValueRange protocolValueRange, final NumericalResultFunction resultFunction, final Integer defaultValue, final boolean zeroMeansDontCare) {

         super(keySet, negotiationType, use, negotiationStatus, defaultValue);

         this.protocolValueRange = protocolValueRange;

         this.negotiationValue = negotiationValue;

         this.resultFunction = resultFunction;

         this.zeroMeansDontCare = zeroMeansDontCare;

     }

     @Override

     protected boolean inProtocolValueRange (final Object values) {

         // receives an Integer

         final int val = (Integer) values;

         if (zeroMeansDontCare && val == 0) // val might not lie inside reg.

                                            // interval

         return true;

         return protocolValueRange.contains(val);

     }

     @Override

     protected Object parseOffer (final TargetServer target, final String values) {

         // return an Integer

         return SingleNumericalValue.parseSingleNumericValue(values).getValue();

     }

     @Override

     protected void processDeclaration (final Object values) {

         // receives an Integer

         final int val = (Integer) values;

         if (zeroMeansDontCare && val == 0)// pick value desired by target

             value = negotiationValue;

         else

             value = values;

     }

     @Override

     protected String processNegotiation (final Object values) {

         // receives an Integer

         final int val = (Integer) values;

         if (zeroMeansDontCare && val == 0)// pick value desired by target

             value = negotiationValue;

         else

             // pick value based on result function and offer

             value = resultFunction.getResult(negotiationValue, val);

         return value.toString();

     }

     @Override

     public Integer getIntegerValue () {

         return (Integer) value;

     }

     @Override

     public Entry copy () {

         final NumericalEntry e = new NumericalEntry(keySet, negotiationType, use, negotiationStatus, negotiationValue, protocolValueRange, resultFunction, (Integer) value, zeroMeansDontCare);

         e.alreadyNegotiated = this.alreadyNegotiated;

         return e;

     }

 }