import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
     * Equalness of DataTypes in Jena is implemented through the class
     * com.hp.hpl.jena.datatypes.BaseDatatype#isEqual .
     * In that implementation Datatypes are Compared on the Object Level.
     * We dont know the reason for that design desicision, but in our case
     * we need DataTypes to be equal if their URIs are equal.
     * 
     * So we compare the URIs of both Data Types and the Values of both literals. 
     * @see com.hp.hpl.jena.datatypes.BaseDatatype#isEqual(com.hp.hpl.jena.graph.impl.LiteralLabel, com.hp.hpl.jena.graph.impl.LiteralLabel)
     */
    @Override
	public boolean isEqual(LiteralLabel a, LiteralLabel b) {

    	// because LiteralLabel.sameValueAs does not check data typed literals itself,
    	// but instead just calls RDFDatatype.isEqual for data typed literals
    	// we have the undesired effect of comparing data types on the object level
    	
    	// what we want for rdf2go is the following:
    	// datatyped literals l1,l2 are equal if and only if:
    	// 		the uri of the datatype of l1 and the uri of the datatype of l2 are equal
    	//		and the value of both literals are equal
    	// We dont concern ourselves with the lexical representation of the
    	// data typed literal, which might be the cause for all this confusion ^_-
    	
    	// the new
    	return a.getDatatype().getURI().equals( b.getDatatype().getURI() )
    		&& a.getValue().equals(b.getValue());
    	
    	// the old
//    	 return a.getDatatype().equals( b.getDatatype() )
//    	       && a.getValue().equals(b.getValue());
    }
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
@Override
public LiteralLabel getLiteral() {
 graphDb.beginTx();
 String value = delegate.getProperty(NeoGraph.PROPERTY_VALUE).toString();
 String language = null;
 RDFDatatype datatype = null;

 if(delegate.hasProperty(NeoGraph.PROPERTY_LANGUAGE))
	language = delegate.getProperty(NeoGraph.PROPERTY_LANGUAGE).toString();

 TypeMapper mapper = new TypeMapper();
 if(delegate.hasProperty(NeoGraph.PROPERTY_DATATYPE))
	 datatype = mapper.getTypeByName( delegate.getProperty(NeoGraph.PROPERTY_DATATYPE).toString());

 LiteralLabel label = LiteralLabelFactory.create(value, language, datatype); //datatype);
 //System.out.println("Label: " +label);
 return label;
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Match the literal value with the given value  .
 */
@Override
public boolean sameValueAs(Object o) {
// System.out.println("Same value as");
 graphDb.beginTx();
 com.hp.hpl.jena.graph.Node n = (com.hp.hpl.jena.graph.Node)o;
 if(n.isLiteral() && isLiteral()) {
	 // TODO ((LiteralLabel)label).sameValueAs( ((Node_Literal) o).getLiteral() )
	// return n.getLiteralValue().equals(getLiteralValue());
	 //System.out.println("Same value as");
	 return o instanceof Node_Literal 
              && ((LiteralLabel)label).sameValueAs( ((Node_Literal) o).getLiteral() );
 }
 else 
	 return false;
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Test if the given typed value is in the right partition of the XSD type
 * space. If this test passes then if the typed value has a legal lexical
 * form for this type then it is a legal instance.
 */
public boolean isBaseTypeCompatible(LiteralLabel lit) {
	XSDBuiltinType base = getFoundingType();
	RDFDatatype litDT = lit.getDatatype();
	if (litDT instanceof XSDDatatype) {
		XSDBuiltinType litBase = ((XSDDatatype) litDT).getFoundingType();
		return base.equals(litBase);

	} else if (litDT == null && lit.language().equals("")) {
		// Special RDF case, a plain literal is type compatible with and
		// xsd:string-based type
		return base.equals(XSDstring.typeDeclaration);
	} else {
		return false;
	}
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Test whether the given LiteralLabel is a valid instance
 * of this datatype. This takes into accound typing information
 * as well as lexical form - for example an xsd:string is
 * never considered valid as an xsd:integer (even if it is
 * lexically legal like "1").
 */
@Override
public boolean isValidLiteral(LiteralLabel lit) {
    if (isBaseTypeCompatible(lit)) {
        String lex = lit.getLexicalForm();
        if (JenaParameters.enableWhitespaceCheckingOfTypedLiterals) {
            if (lex.trim().equals(lex)) {
                return isValid(lit.getLexicalForm());
            } else {
                return false;
            }
        } else {
            return isValid(lit.getLexicalForm());
        }
    } else {
        return false;
    }
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Compares two instances of values of the given datatype.
 * This ignores lang tags and just uses the java.lang.Number 
 * equality.
 */
@Override
public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
    if (value1.getDatatype() instanceof XSDBaseNumericType && value2.getDatatype() instanceof XSDBaseNumericType) {
        Number n1 = (Number)value1.getValue();
        Number n2 = (Number)value2.getValue();
        // The cannonicalization step should take care of all cross-type cases, leaving
        // us just that equals doesn't work on BigDecimals in the way you expect
        if (n1 instanceof BigDecimal && n2 instanceof BigDecimal) {
            return  ((BigDecimal)n1).compareTo((BigDecimal)n2) == 0;
        } 
        return n1.equals(n2);
    } else {
        // At least one arg is not part of the integer hierarchy
        return false;
    }
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Check a given literal value for a property against the set of
 * known range constraints for it.
 * @param prop the property node whose range is under scrutiny
 * @param triple the statement whose object value is to be checked.
 * @return null if the range is legal, otherwise a ValidityReport.Report
 * which describes the problem.
 */
public ValidityReport.Report checkLiteral(Node prop, Triple triple) {
    Node value = triple.getObject();
    List<RDFDatatype> range = getDTRange().get(prop);
    if (range != null) {
        if (value.isBlank()) return null;
        if (!value.isLiteral()) {
            return new ValidityReport.Report(true, "dtRange", 
                "Property " + prop + " has a typed range but was given a non literal value " + value);
        }
        LiteralLabel ll = value.getLiteral();   
        for (Iterator<RDFDatatype> i = range.iterator(); i.hasNext(); ) {
            RDFDatatype dt = i.next();
            if (!dt.isValidLiteral(ll)) {
                return new ValidityReport.Report(true, "dtRange", 
                    "Property " + prop + " has a typed range " + dt +
                    "that is not compatible with " + value, triple);
            }
        }
    }
    return null;
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Check if a literal value node is a legal value for the given datatype.
 * @param val the literal value node
 * @param dt  the Node designating a datatype URI 
 */
public static boolean isTypeOK(Node val, Node dt) {
    if (!dt.isURI()) return false;
    if (val.isBlank()) return true;
    if (val.isLiteral()) {
        LiteralLabel ll = val.getLiteral();
        if (ll.getDatatype() != null && (! ll.isWellFormed())) return false;
        if (dt.equals(RDFS.Nodes.Literal)) {
            return true;
        } else {
            RDFDatatype dtype = TypeMapper.getInstance().getSafeTypeByName(dt.getURI());
            return dtype.isValidLiteral(val.getLiteral());   
        }
    }
    return false;
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
@Override
public void write(Kryo kryo, Output output, Node_Literal object) {
	final LiteralLabel label = object.getLiteral();
	output.writeString(label.getLexicalForm());
	output.writeString(label.language());
	output.writeString(label.getDatatypeURI());
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Transforms a Jena node into a java object. Possible node types: uri,
 * variable, literal (datatype, languageTag), blank node
 * 
 * @param n The node to transform
 * @return A specific java object
 * @throws ModelRuntimeException from the underlying model
 */
public static org.ontoware.rdf2go.model.node.Node toRDF2Go(Node n) throws ModelRuntimeException {
	// A return of null indicates that the variable is not present in this
	// solution.
	if(n == null)
		return null;
	
	if(n.isURI())
		return new URIImpl(n.getURI());
	
	if(n.isVariable())
		throw new RuntimeException("Cannot convert a Jena variable to an RDF2Go node");
	
	if(n.isLiteral()) {
		LiteralLabel lit = n.getLiteral();
		// datatype
		if(lit.getDatatypeURI() != null) {
			return new DatatypeLiteralImpl(lit.getLexicalForm(), new URIImpl(
			        lit.getDatatypeURI()));
		}
		
		// language tagged
		if(lit.language() != null && !lit.language().equals(""))
			return new LanguageTagLiteralImpl(lit.getLexicalForm(), lit.language());
		
		// plain
		return new PlainLiteralImpl(lit.getLexicalForm());
	}
	
	if(n.isBlank())
		return new JenaBlankNode(n);
	
	// none of the above - don't know how to transform that
	throw new RuntimeException("no transformation defined from " + n + " to java");
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
@Override
protected byte[] getIdInternal(final Node value, final boolean p) throws StorageLayerException {		
	if (value.isLiteral()) {
		final LiteralLabel literal = value.getLiteral();
		final String literalValue = String.valueOf(literal.getValue());
		if (literalValue.length() > threshold) {
			final byte[] idFromEmbeddedDictionary = longLiteralsDictionary.getID(value, p);
			final byte [] result = new byte[idFromEmbeddedDictionary.length + 1];
			result[0] = THRESHOLD_EXCEEDED;
			fillIn(result, 1, idFromEmbeddedDictionary);
			RUNTIME_CONTEXTS.get().isFirstLevelResult = false;
			return result;
		}
	} 
	 
	final String n3 = asNt(value);

	final byte[] n3b = n3.getBytes(CHARSET_UTF8);
	final byte[] id = new byte[n3b.length + 2];
	
	if (value.isLiteral()) {
		id[0] = THRESHOLD_NOT_EXCEEDED;
		id[1] = LITERAL_BYTE_FLAG;
	} else if (value.isBlank()) {
		id[0] = THRESHOLD_NOT_EXCEEDED;
		id[1] = BNODE_BYTE_FLAG;
	} else {
		id[0] = THRESHOLD_NOT_EXCEEDED;
		id[1] = RESOURCE_BYTE_FLAG;
	}		
	
	fillIn(id, 2, n3b);
	RUNTIME_CONTEXTS.get().isFirstLevelResult = true;
	return id;			
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
     * Compares two instances of values of the given datatype.
     * This ignores lang tags and just uses the java.lang.Number 
     * equality.
     */
    @Override
    public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
        return value1.getDatatype() == value2.getDatatype()
            && Arrays.equals((byte[])value1.getValue(), (byte[])value2.getValue());
//      && value1.getLexicalForm().equals(value2.getLexicalForm());  // bug tracking, not real code
    }
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Compares two instances of values of the given datatype. 
 * This ignores lang tags and optionally allows plain literals to
 * equate to strings. The latter option is currently set by a static
 * global flag in LiteralLabel.
 */
@Override
public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
    // value1 will have been used to dispatch here so we know value1 is an xsdstring or extension
    if ((value2.getDatatype() == null && JenaParameters.enablePlainLiteralSameAsString) ||
         (value2.getDatatype() instanceof XSDBaseStringType)) {
            return value1.getValue().equals(value2.getValue());
    } else {
            return false;
    }
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Helper function to compare language tag values
 */
public boolean langTagCompatible(LiteralLabel value1, LiteralLabel value2) {
    if (value1.language() == null) {
        return (value2.language() == null || value2.language().equals(""));
    } else {
        return value1.language().equalsIgnoreCase(value2.language());
    }
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
public Literal createTypedLiteral( Object value ) {
    LiteralLabel ll = null;
    if (value instanceof Calendar) {
        Object valuec = new XSDDateTime( (Calendar) value);
        ll = LiteralLabelFactory.create(valuec, "", XSDDatatype.XSDdateTime);
    } else {
        ll =  LiteralLabelFactory.create(value);
    }
    return new LiteralImpl(Node.createLiteral( ll ), null) ;
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
@Test
public void testDataTypeEqualness() throws Exception {
	
	// die erste DatenTyp URI
	URI testA = new URIImpl("test://somedata-A", false);
	// die zweite DatenTyp URI
	URI testB = new URIImpl("test://somedata-B", false);
	
	// der erste BaseDatatype wird von der ersten DatenTyp URI erzeugt
	BaseDatatype BDtestA1 = new BaseDatatype(testA + "");
	// der zweite BaseDatatype ebenso
	BaseDatatype BDtestA2 = new BaseDatatype(testA + "");
	// f�r den dritten BaseDatatype nehmen wir eine neue Datentyp URI
	BaseDatatype BDtestB = new BaseDatatype(testB + "");
	
	// alle Literals haben den gleichen Inhalt
	
	// das erste Literal kriegt den ersten BaseDatatype
	LiteralLabel litA11 = LiteralLabelFactory.create("teststring", "", BDtestA1);
	// das zweite Liertal kriegt den auch, es hat also komplett die gleichen
	// Eigenschaften wie das erste Literal aber in einem neuen Objekt
	LiteralLabel litA12 = LiteralLabelFactory.create("teststring", "", BDtestA1);
	// jetzt machen wir ein drittes Literal, welches aber den zweiten
	// BasedataType
	// bekommt, der aber eigentlich von der ersten DataTypeURI stammt
	LiteralLabel litA2 = LiteralLabelFactory.create("teststring", "", BDtestA2);
	// und jetzt machen wir noch nen vierten Literal, der von einem neuen
	// Basedatatype komt, welche wiederrum von einer neuen DatatypeURI ist
	LiteralLabel litB = LiteralLabelFactory.create("teststring", "", BDtestB);
	
	// dann wollen wir mal schauen was passiert:
	
	// reflexivit�t: A == A , passt
	assertTrue(litA11.sameValueAs(litA11));
	// gleicher Inhalt, in zwei versch. Objekten, passt auch
	assertTrue(litA11.sameValueAs(litA12));
	// zwei Objekte, mit untersch. BaseDatatypes, von der gleichen Datatype
	// URI:
	// nein
	assertFalse(litA11.sameValueAs(litA2));
	// und zur sicherheit: 2 versch Datentyp URIs: nein
	assertFalse(litA11.sameValueAs(litB));
	
	// und nochmal der negativ Test:
	assertTrue(litB.sameValueAs(litB));
	assertFalse(litB.sameValueAs(litA11));
	assertFalse(litB.sameValueAs(litA12));
	assertFalse(litB.sameValueAs(litA2));
	
	// weiterlesen ;)
	
	// das liegt an der Implementierung von BaseDatatype.isEqual()
	assertFalse(BDtestA1.isEqual(litA11, litA2));
	
	/**
	 * Compares two instances of values of the given datatype. This default
	 * requires value and datatype equality.
	 * 
	 * public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
	 * return value1.getDatatype() == value2.getDatatype() ^^^^^^ &&
	 * value1.getValue().equals(value2.getValue()); }
	 */
	
	// Es werden dirket 2 Object Referenzen verglichen, und 2 versch.
	// Basedatatype Objecte sind ebend unterschiedlich.
	// wir m�ssen entweder irgendwo auf der Seite von RDF2GO
	// BaseDatatypes recyclen, oder einen eigenen Datentyp schreiben,
	// bei dem isEqual() den Inhalt der Datentyp URIs der beiden
	// Basedatatypes
	// vergleicht.
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
@Test
public void testGeneralDataTypeEqualness() throws Exception {
	
	// Die Idee mit dem GeneralDataType ist an sich echt gut, aber:
	// Es kann passieren das mit addStatement(object, object, object,
	// object)
	// als Object des Tripels ein Literal mit Daten Typ erzeugt wird.
	// Wenn ich nun mein Literal mit einem GeneralDataType erzeuge,
	// es in den Graphen einf�ge, und ich sp�ter abfragen will
	// ob dieses data typed Literal sich wirklich im Graphen befindet,
	// dann wird das literal mit dem GeneralDataType mit dem eigentlich
	// gleichen Literal verglichen, aber die zweite Instanz hat einen
	// BaseDatatype
	// weil sie automatisch in Search-Triple oder irgend sowas eingef�gt
	// wurde.
	// Da GeneralDataType auf BaseDatatype down-gecastet werden kann, werden
	// sie
	// dann mit dem BaseDatatype.equals() verglichen und dann passt es
	// wieder nicht.
	
	// L�sung siehe Funktion testDataTypesWithUnknownType()
	
	// die erste DatenTyp URI
	URI testA = new URIImpl("test://somedata-A", false);
	// die zweite DatenTyp URI
	URI testB = new URIImpl("test://somedata-B", false);
	
	// der erste BaseDatatype wird von der ersten DatenTyp URI erzeugt
	GeneralDataType BDtestA1 = new GeneralDataType(testA + "");
	// der zweite BaseDatatype ebenso
	GeneralDataType BDtestA2 = new GeneralDataType(testA + "");
	// f�r den dritten BaseDatatype nehmen wir eine neue Datentyp URI
	GeneralDataType BDtestB = new GeneralDataType(testB + "");
	
	// alle Literals haben den gleichen Inhalt
	
	// das erste Literal kriegt den ersten BaseDatatype
	LiteralLabel litA11 = LiteralLabelFactory.create("teststring", "", BDtestA1);
	// das zweite Liertal kriegt den auch, es hat also komplett die gleichen
	// Eigenschaften wie das erste Literal aber in einem neuen Objekt
	LiteralLabel litA12 = LiteralLabelFactory.create("teststring", "", BDtestA1);
	// jetzt machen wir ein drittes Literal, welches aber den zweiten
	// BasedataType
	// bekommt, der aber eigentlich von der ersten DataTypeURI stammt
	LiteralLabel litA2 = LiteralLabelFactory.create("teststring", "", BDtestA2);
	// und jetzt machen wir noch nen vierten Literal, der von einem neuen
	// Basedatatype komt, welche wiederrum von einer neuen DatatypeURI ist
	LiteralLabel litB = LiteralLabelFactory.create("teststring", "", BDtestB);
	
	// dann wollen wir mal schauen was passiert:
	
	// reflexivit�t: A == A , passt
	assertTrue(litA11.sameValueAs(litA11));
	// gleicher Inhalt, in zwei versch. Objekten, passt auch
	assertTrue(litA11.sameValueAs(litA12));
	// zwei Objekte, mit untersch. BaseDatatypes, von der gleichen Datatype
	// URI:
	
	// ACHTUNG: mit GeneralDataType passt das jetzt weil f�r die Gleichheit
	// der Datentypen
	// nun nur die Gleichheit der URIs der Datentypen notwendig ist
	assertTrue(litA11.sameValueAs(litA2));
	// und zur sicherheit: 2 versch Datentyp URIs: nein
	assertFalse(litA11.sameValueAs(litB));
	
	// und nochmal der negativ Test:
	assertTrue(litB.sameValueAs(litB));
	assertFalse(litB.sameValueAs(litA11));
	assertFalse(litB.sameValueAs(litA12));
	assertFalse(litB.sameValueAs(litA2));
	
	// und hier nochmal der Low Level Test:
	// mit GeneralDataType ist nun isEqual()
	// so implementiert, das die URIs der Datentypen verglichen werden und
	// die Werte der Strings
	// und deswegen ist das jetzt hier True
	assertTrue(BDtestA1.isEqual(litA11, litA2));
	
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
@Override
public int getHashCode( LiteralLabel lit )
    { return getHashCode( (byte []) lit.getValue() ); }
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Compares two instances of values of the given datatype. This ignores lang
 * tags and just uses the java.lang.Number equality.
 */
@Override
public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
	return value1.getDatatype() == value2.getDatatype()
			&& value1.getValue().equals(value2.getValue());
}
 

import com.hp.hpl.jena.graph.impl.LiteralLabel; //导入依赖的package包/类
/**
 * Compares two instances of values of the given datatype.
 * This default requires value and datatype equality.
 */
public boolean isEqual(LiteralLabel value1, LiteralLabel value2) {
    return value1.getDatatype() == value2.getDatatype()
         && value1.getValue().equals(value2.getValue());
}