bytedata.java

Logica lastest SMPP API

     * @throws  thrown if the value is out of bounds
     */
    protected static void checkString(int min, int length, int max)
    throws WrongLengthOfStringException
    {
        if ((length < min) || (length > max)) {
            throw new WrongLengthOfStringException(min, max, length);
        }
    }

    /**
     * Checks if the length of the string plus 1 for terminating zero
     * is less or equal than provided maximum.
     *
     * @param string the string to check
     * @param max    the maximal length of the string with added term. zero
     * @exception WrongLengthOfStringException thrown if string with added
     *            terminating zero would be longer than the maximum
     */
    protected static void checkCString(String string, int max)
    throws WrongLengthOfStringException
    {
        checkCString(string,1,max); // min = empty + 1 for zero
    }
    
    /**
     * Checks if the length of the string plus 1 for terminating zero
     * is greater or equal than provided minimum and less or equal than
     * provided maximum.
     *
     * @param string the string to check
     
     * @param min    the minimal length of the string with added term. zero
     * @param max    the maximal length of the string with added term. zero
     * @throws WrongLengthOfStringException thrown if string with added
     *         terminating zero would be shorter than minimum or longer than
     *         the maximum
     */
    protected static void checkCString(String string, int min, int max)
    throws WrongLengthOfStringException
    {
    	//System.out.println("The invalid String is :"+string);
        int count = string==null ? 1 : (string.length() + 1); // 1 is for terminating zero
        if (count < min || count > max) {
            throw new WrongLengthOfStringException(min, max, count);
        }
    }
    
    /**
     * Checks if the string contains valid date string as specified in SMPP spec.
     *
     * @param dateStr the date to check
     * @throws WrongDateFormatException throwsn if the string doesn't
     *         contain date with valid format
     */
    protected static void checkDate(String dateStr)
    throws WrongDateFormatException
    {
        int count = dateStr==null ? 1 : (dateStr.length() + 1); // 1 is for terminating zero
        if ((count != 1) && (count != Data.SM_DATE_LEN)) {
            throw new WrongDateFormatException(dateStr);
        }
        if ((count == 1) || (!libraryCheckDateFormat)) {
            // i.e. no date provided or don't check the format
            return;
        }
        char locTime = dateStr.charAt(dateStr.length()-1);
        if ("+-R".lastIndexOf(locTime) == -1) {
            // i.e. the locTime isn't one of the possible values
            throw new WrongDateFormatException(dateStr,"time difference relation indicator incorrect; "+
                                               "should be +, - or R and is "+locTime);
        }
        int formatLen = SMPP_TIME_DATE_FORMAT.length();
        String dateJavaStr = dateStr.substring(0,formatLen);
        Date date = null;
        synchronized (dateFormatter) {
            try {
                if (locTime=='R') {
                    // check relative date
                    // won't check date validity just if it's all number it
                    Long.parseLong(dateJavaStr);
                } else {
                    // check absolute dates
                    date = dateFormatter.parse(dateJavaStr);
                }
            } catch (ParseException e) {
                debug.write("Exception parsing absolute date "+dateStr + " " +e);
                throw new WrongDateFormatException(dateStr,"format of absolute date-time incorrect");
            } catch (NumberFormatException e) {
                debug.write("Exception parsing relative date "+dateStr + " " +e);
                throw new WrongDateFormatException(dateStr,"format of relative date-time incorrect");
            }
        }
        String tenthsOfSecStr = dateStr.substring(formatLen,formatLen+1);
        int tenthsOfSec = 0;
        try {
            tenthsOfSec = Integer.parseInt(tenthsOfSecStr);
        } catch (NumberFormatException e) {
            throw new WrongDateFormatException(dateStr,"non-numeric tenths of seconds "+tenthsOfSecStr);
        }
        String timeDiffStr = dateStr.substring(formatLen+1,formatLen+3);
        int timeDiff = 0;
        try {
            timeDiff = Integer.parseInt(timeDiffStr);
        } catch (NumberFormatException e) {
            throw new WrongDateFormatException(dateStr,"non-numeric time difference "+timeDiffStr);
        }
        if ((timeDiff<0) || (timeDiff>48)) {
            // defined in SMPP v3.4 sect. 7.1.1
            throw new WrongDateFormatException(dateStr,"time difference is incorrect; "+
                                               "should be between 00-48 and is "+timeDiffStr);
        }
    }
    
    /**
     * Checks if the integer value is within provided valid range of values.
     *
     * @param min minimal possible value
     * @param val the value to check
     * @param max maximal possible value
     * @throws IntegerOutOfRangeException thrown if the value is out of bounds
     */
    protected static void checkRange(int min, int val, int max)
    throws IntegerOutOfRangeException
    {
        if ((val < min) || (val > max)) {
            throw new IntegerOutOfRangeException(min, max, val);
        }
    }

    /**
     * Allow a variable of type <code>byte</code> to carry lengths or sizes up to 255.
     * The integral types are signed in Java, so if there is necessary to store
     * an unsigned type into signed of the same size, the value can be stored
     * as negative number even if it would be positive in unsigned case.
     * For example message length can be 0 to 254 and is carried by 1 octet
     * i.e. unsigned 8 bits. We use a byte variable to read the value from octet stream.
     * If the length is >127, it is interpreted as negative byte using negative
     * complement notation.
     * So length 150 would be interpreted as Java byte -106. If we want to know
     * the actual value (*length) we need to make a correction to a bigger integral type,
     * in case of byte it's short. The correction from (negative) byte to short is<br>
     * <code>(short)(256+(short)length)</code><br>
     * This converts the negative byte value representing positive length into positive
     * short value.
     * @see #encodeUnsigned(short)
     */
    protected static short decodeUnsigned(byte signed)
    {
        if (signed>=0) {
            return signed;
        } else {
            return (short)(256+(short)signed);
        }
    }

    /**
     * Provides correction of positive unsigned 2 byte carried 
     * by (signed) <code>short</code> into positive signed <code>int</code>.
     * See explanation in <code>decodeUnsigned(byte)</code>.
     * @see #decodeUnsigned(byte)
     * @see #encodeUnsigned(int)
     */
    protected static int decodeUnsigned(short signed)
    {
        if (signed>=0) {
            return signed;
        } else {
            return (int)(65536+(int)signed);
        }
    }

    /**
     * Complementary operation to <code>decodeUnsigned</code>.
     * @see #decodeUnsigned(byte)
     */
    protected static byte encodeUnsigned(short positive)
    {
        if (positive<128) {
            return (byte)positive;
        } else {
            return (byte)(-(256-positive));
        }
    }

    /**
     * Complementary operation to <code>decodeUnsigned</code>.
     * @see #decodeUnsigned(byte)
     * @see #decodeUnsigned(short)
     */
    protected static short encodeUnsigned(int positive)
    {
        if (positive<32768) {
            // [e-mail] 2005-09-22: no, this isn't right! Casting the
			// short to a byte here overflows the byte, converts it back to a
			// short, and produces a bogus result. This was the cause of a bug
			// whereby invalid TLVs were produced: try creating a TLV longer than
			// 127 octets and see what happens...
			//return (byte)positive;
			return (short)positive;
        } else {
            return (short)(-(65536-positive));
        }
    }

    /**
     * Returns human readable version of the data carried by the object.
     * Derived classes should override this method with possible inclusion
     * of result of <code>super.debugString()</code>.
     *
     * @return the textual form of the content of the object
     */
    public String debugString()
    {
        return new String("");
    }

}