com.bigdata.rdf.internal.InlineLocalNameIntegerURIHandler Maven / Gradle / Ivy

Go to download
/**

Copyright (C) SYSTAP, LLC DBA Blazegraph 2006-2016.  All rights reserved.

Contact:
     SYSTAP, LLC DBA Blazegraph
     2501 Calvert ST NW #106
     Washington, DC 20008
     [email protected]

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package com.bigdata.rdf.internal;

/**
 * 
 * Abstract class that defines the integer packing needed to allow for 
 * support of multiple inline integer URI handlers with the same namepace.
 * 
 * This is required as once the integer value is inlined it is not possible
 * to determine which handler to apply if there are multiple namespaces that use
 * different prefixed or suffixed inline handlers.  
 * 
 * For example:
 *  
 *   http://rdf.ncbi.nlm.nih.gov/pubchem/descriptor/ 
 *   descriptor:CID5606223_Compound_Identifier , 
 *   descriptor:CID5606223_Covalent_Unit_Count , 
 *   descriptor:CID5606223_Defined_Atom_Stereo_Count ,
 *   
 * 
 *   Each of these can be supported as a different {@link InlinePrefixedSuffixedIntegerURIHandler} at the
 *   namespace http://rdf.ncbi.nlm.nih.gov/pubchem/descriptor/.
 *   
 *   It current supports up to 32 different inline values for a single namespace URI.  It is used
 *   in conjunction with the {@link InlineIntegerURIHandlerMap}.
 *   
 *   For an example, see {@see com.blazegraph.vocab.pubchem.PubchemInlineURIFactory}.
 *   
 *   The max inline integer value that can supported in this scheme is 2^57 - 1, which is 2^5 less
 *   than the Java {@link Long.MAX_VALUE}.  
 * 
 * @author beebs
 *
 */
public abstract class InlineLocalNameIntegerURIHandler extends
		InlineSignedIntegerURIHandler {
	
	/**
	 * The ID to pack.  From 0 to the MAX_IDS
	 */
	protected int packedId = 0;
	
	/**
	 * Maximum nubmer of IDs 
	 * 
	 * Up to 32 different values for a single URI.
	 */
	private static final int MAX_IDS = 32 - 1;
	
	/**
	 * 
	 * The bitmask used.
	 * 
	 */
	private static final long ID_MASK = 32L << 58;
	
	/**
	 *
	 * The maximum int value supported with packing.
	 * 2^57 -1
	 * 
	 */
	private static final long MAX_VALUE = 144115188075856000L;

	public InlineLocalNameIntegerURIHandler(String namespace) {
		super(namespace);
	}
	
	public InlineLocalNameIntegerURIHandler(String namespace, int packedId) {
		super(namespace);

		if(packedId > MAX_IDS) {
			throw new RuntimeException (packedId + " is greater than the max ids value:  " + MAX_IDS);
		}
		
		if(packedId < 0) {
			throw new RuntimeException (packedId + " is a negative value.");
		}

		this.packedId = packedId;
	}
	
	/**
	 * Pack the value with the leading 5 bits used to encode the 
	 * id used for decoding the inline URI handler. 
	 * 
	 * @param value
	 * @return
	 */
	public long packValue(final long value) {
		
		if(value >= MAX_VALUE) {
			throw new RuntimeException(value + " exceeds " + MAX_VALUE + ".");
		} else if (value < 0 ) {
			throw new RuntimeException(value + " is less than zero.");
		}
		
		long idVal = (long) packedId << 58;

		long packedVal = idVal | value;
		
		return packedVal;
			
	}
	
	/**
	 * Convenience method to take an Integer string value, pack it, and convert back to a string. 
	 * 
	 * @param intVal
	 * @return
	 */
	public String getPackedValueString(final String intVal) {
	
		String longVal = null;
		
		try {
			longVal = Long.toString(packValue((long)Long.parseLong(intVal)));
		} catch (NumberFormatException nfe) {
			//It is not a valid number
			//Do not inline
			return null;
		}
		
		return longVal;

	}
	
	/**
	 * Convenience method for unpacking a value from a string. 
	 * 
	 * @param s
	 * @return
	 */
	public String getUnpackedValueString(final String s) {
		return Long.toString(unpackValue((long)Long.parseLong(s)));
	}
	
	/**
	 * Convenience method to unpack a long value from a string. 
	 * 
	 * @param s
	 * @return
	 */
	public long getUnpackedValueFromString(final String s) {
		return unpackValue((long)Long.parseLong(s));
	}
	
	/**
	 * Take a packed long and extract the value. 
	 * 
	 * @param packedVal
	 * @return
	 */
	public long unpackValue(final long packedVal) {

		
		long idVal = (long) packedId << 58;

		long unpackedVal = packedVal  & ~idVal;
		
		return unpackedVal;

	}

	/**
	 * Convenience method to get the packed ID value from an
	 * input {@link String}. 
	 * 
	 * @param s
	 * @return
	 */
	public int unpackId(final String s) {
		return unpackId(Long.parseLong(s));
	}
	
	/**
	 * Take a packed long and extract the ID. 
	 * 
	 * @param packedVal
	 * @return
	 */
	public int unpackId(final long packedVal) {
		
		long unpackedId = (packedVal & ~ID_MASK) >> 58;
		
		return (int) unpackedId;
		
	}


}