Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.storemate.shared;
  
  import  com.fasterxml.storemate.shared.ByteRange;

Helper class used for dealing with HTTP "Range" and "Content-Range" headers.
  
  public class ByteRange
  {
     private final static String PREFIX_BYTES = "bytes";
     
     protected final String _source;
     
     protected final long _start;
     protected final long _end;
     protected final long _totalLength;

    
Constructor used when programmatically creating instances when sending Range requests to server.
 
     public ByteRange(long startlong length)
     {
     	 = start;
     	// end is last included byte, hence -1
     	 = start + length - 1;
     	 = null;
     	 = -1;
     }
     
     protected ByteRange(long startlong endlong totalLengthString src)
     {
          = start;
          = end;
          = src;
          = totalLength;
     }

    
Method called to create a new instance with known total length; which may be needed to resolve suffix ranges (negative end)
 
     public ByteRange resolveWithTotalLength(long totalLength)
     {
     	long start = ;
     	long end = ;
 
         // missing end?
         if (end < 0) {
             end = totalLength-1;
         }
         // suffix?
         if (start < 0) { // suffix, yup; must modify
             // since start is offset from end (and negative), works with addition
             // but we must consider possibility it might go beyond start, so:
             start = Math.max(0, totalLength+start);
         }
         return new ByteRange(startendtotalLength);
     }
 
     public static ByteRange valueOf(String external)
         throws IllegalArgumentException
     {
         if (external == nullreturn null;
         external = external.trim();
         if (external.length() == 0) return null;
         final String rangeDesc = external;
 
         // Note: code is verbose -- regexp would be way shorter -- but goal is to give meaningful errors
         
         // ok: must start with "bytes"
         if (!external.startsWith()) {
             throw new IllegalArgumentException("range does note start with 'bytes='");
         }
         external = external.substring(.length()).trim();
         if (external.startsWith("=")) {
             external = external.substring(1).trim();
         }
 
         // One more thing: we do NOT support multiple ranges
         if (external.indexOf(',') >= 0) {
             throw new IllegalArgumentException("multiple ranges not supported");
         }
 
         long totalLength;
 
         // Should we accept total length suffix? It's only sent for response... but
         int ix;
         ix = external.indexOf('/');
         if (ix < 0) {
         	totalLength = -1;
         } else {
         	String str = external.substring(ix+1);
         	external = external.substring(0, ix).trim();
         	if ("*".equals(str)) {
         		totalLength = -1L;
         	} else {
 	        	try {
	        		totalLength = Long.parseLong(str);
	        	} catch (NumberFormatException e) {
	                throw new IllegalArgumentException("invalid instance-length suffix for range: '"+str+"'");
	        	}
        	}
        }
        
        // and then either suffix entry or range
        
        ix = external.indexOf('-');
        if (ix < 0) {
            throw new IllegalArgumentException("no hyphen found");
        }
        if (ix == 0) { // suffix entry
            // suffix range, yay; parse as negative number
            return new ByteRange(parseLong(external), -1, -1, rangeDesc);
        }
        // actual range
        long start = parseLong(external.substring(0,ix));
        String num = external.substring(ix+1).trim();
        long end;
        if (num.length() == 0) { // missing end range -- fine, use -1 to indicate 'till the end'
            end = -1;
        } else {
            end = parseLong(num);
            if (end < start) {
                throw new IllegalArgumentException("range end can not be less than start");
            }
        }
        return new ByteRange(startendtotalLengthrangeDesc);
    }
    private final static long parseLong(String num)
    {
        try {
            return Long.parseLong(num);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("invalid number '"+num+"'");
        }
    }
    
    public long getStart() { return ; }
    public long getEnd() { return ; }
    public long getTotalLength() { return ; }
    public long calculateLength() {
        return ( - ) + 1;
    }

    
Method to use for creating value suitable for sending as request header (Range). Does not include "total length" part.
    public String asRequestHeader()
    {
    	StringBuilder sb = new StringBuilder(30)
            .append("bytes ").append()
            .append('-').append();
    	return sb.toString();
    }

    
Method to use for creating value suitable for sending as response header (Content-Range). Does include "total length" part.
    public String asResponseHeader()
    {
    	StringBuilder sb = new StringBuilder(30)
            .append("bytes ").append()
            .append('-').append();
    	if ( < 0) {
    		sb.append("/*");
    	} else {
    		sb.append('/').append();
    	}
    	return sb.toString();
    }
    
    @Override
    public String toString() {
        if ( != null) {
            return ;
        }
        return asResponseHeader();
    }
New to GrepCode? Check out our FAQ X