public static InternalValue create(QValue value) throws RepositoryException { switch (value.getType()) { case PropertyType.BINARY: try { return create(value.getString().getBytes(AbstractQValueFactory.DEFAULT_ENCODING)); } catch (UnsupportedEncodingException e) { throw new InternalError(AbstractQValueFactory.DEFAULT_ENCODING + " not supported"); return new InternalValue(value.getBoolean()); case PropertyType.DATE: return new InternalValue(value.getCalendar()); case PropertyType.DOUBLE: return new InternalValue(value.getDouble()); case PropertyType.DECIMAL: return new InternalValue(value.getDecimal()); case PropertyType.LONG: return new InternalValue(value.getLong()); case PropertyType.REFERENCE: return create(new NodeId(value.getString())); case PropertyType.WEAKREFERENCE: return create(new NodeId(value.getString()), true); case PropertyType.URI: return new InternalValue(value.getURI()); case PropertyType.NAME: return new InternalValue(value.getName()); case PropertyType.PATH: return new InternalValue(value.getPath()); case PropertyType.STRING: return new InternalValue(value.getString(), PropertyType.STRING);
private HttpEntity getEntity(QValue value) throws RepositoryException { // SPI value must be converted to jcr value int type = value.getType(); String contentType = JcrValueType.contentTypeFromType(type); HttpEntity ent; switch (type) { case PropertyType.NAME: case PropertyType.PATH: String str = ValueFormat.getJCRString(value, resolver); ent = new StringEntity(str, ContentType.create(contentType, "UTF-8")); break; case PropertyType.BINARY: InputStream in = value.getStream(); ent = new InputStreamEntity(in, ContentType.create(contentType)); break; default: str = value.getString(); ent = new StringEntity(str, ContentType.create(contentType, "UTF-8")); break; } return ent; }
/** * * @param value * @return * @throws RepositoryException */ private long getLength(QValue value) throws RepositoryException { long length; switch (value.getType()) { case PropertyType.NAME: case PropertyType.PATH: String jcrString = ValueFormat.getJCRString(value, session.getNamePathResolver()); length = jcrString.length(); break; default: length = value.getLength(); break; } return length; }
static String getJsonString(QValue value) throws RepositoryException { String str; switch (value.getType()) { case PropertyType.STRING: str = JsonUtil.getJsonString(value.getString()); break; case PropertyType.BOOLEAN: case PropertyType.LONG: str = value.getString(); break; case PropertyType.DOUBLE: double d = value.getDouble(); if (Double.isNaN(d) || Double.isInfinite(d)) { // JSON cannot specifically handle this property type... str = null; } else { str = value.getString(); if (str.indexOf('.') == -1) { str += ".0"; } } break; default: // JSON cannot specifically handle this property type... str = null; } return str; }
/** * @see javax.jcr.Value#getString() */ public String getString() throws RepositoryException { if (getType() == PropertyType.NAME) { // qualified name value needs to be resolved return resolver.getJCRName(qvalue.getName()); } else if (getType() == PropertyType.PATH) { // qualified path value needs to be resolved return resolver.getJCRPath(qvalue.getPath()); } else { return qvalue.getString(); } }
NamePathResolver resolver) throws RepositoryException { String jcrString; int propertyType = value.getType(); switch (propertyType) { case PropertyType.STRING: case PropertyType.DECIMAL: case PropertyType.BINARY: jcrString = value.getString(); break; case PropertyType.PATH: Path qPath = value.getPath(); jcrString = resolver.getJCRPath(qPath); break; case PropertyType.NAME: Name qName = value.getName(); jcrString = resolver.getJCRName(qName); break;
int propertyType = qualifiedValue.getType(); switch (propertyType) { case PropertyType.STRING: case PropertyType.BOOLEAN: case PropertyType.REFERENCE: jcrValue = factory.createValue(qualifiedValue.getString(), propertyType); break; case PropertyType.PATH: Path qPath = qualifiedValue.getPath(); jcrValue = factory.createValue(resolver.getJCRPath(qPath), propertyType); break; case PropertyType.NAME: Name qName = qualifiedValue.getName(); jcrValue = factory.createValue(resolver.getJCRName(qName), propertyType); break; case PropertyType.BINARY: jcrValue = factory.createValue(qualifiedValue.getStream()); break; case PropertyType.DATE: jcrValue = factory.createValue(qualifiedValue.getCalendar()); break; case PropertyType.DOUBLE: jcrValue = factory.createValue(qualifiedValue.getDouble()); break; case PropertyType.LONG: jcrValue = factory.createValue(qualifiedValue.getLong()); break; default:
public void testEmptyBinaryFromFile() throws RepositoryException, IOException { File f = File.createTempFile("QValueFactoryImplTest", ".txt"); f.deleteOnExit(); QValue v = factory.create(f); assertEquals(PropertyType.BINARY, v.getType()); assertEquals(0, v.getLength()); assertEquals("", v.getString()); ByteArrayOutputStream out = new ByteArrayOutputStream(); spool(out, v.getStream()); assertEquals("", new String(out.toByteArray())); }
/** * {@inheritDoc} */ public InputStream getStream() throws IllegalStateException, RepositoryException { setStreamConsumed(); if (stream == null) { if (getType() == PropertyType.NAME || getType() == PropertyType.PATH) { // needs namespace mapping try { String l_s = getType() == PropertyType.NAME ? resolver.getJCRName(qvalue.getName()) : resolver.getJCRPath(qvalue.getPath()); stream = new ByteArrayInputStream(l_s.getBytes("UTF-8")); } catch (UnsupportedEncodingException ex) { throw new RepositoryException(ex); } } else { stream = qvalue.getStream(); } } return stream; }
+ getString() + "'"); switch (value.getType()) { case PropertyType.LONG: check(value.getLong()); return; check(value.getDouble()); return; check(value.getDouble()); return; long length = value.getLength(); if (length != -1) { check(length); + PropertyType.nameFromValue(value.getType()); log.debug(msg); throw new RepositoryException(msg);
/** * @see javax.jcr.Value#getBoolean() */ public boolean getBoolean() throws RepositoryException { if (getType() == PropertyType.STRING || getType() == PropertyType.BINARY || getType() == PropertyType.BOOLEAN) { return Boolean.valueOf(qvalue.getString()); } else { throw new ValueFormatException("incompatible type " + PropertyType.nameFromValue(qvalue.getType())); } }
public void testCreateFalseBooleanValue() throws RepositoryException { QValue v = factory.create(false); assertEquals("Boolean value must be false", Boolean.FALSE.toString(), v.getString()); assertEquals("Boolean value must be false", false, v.getBoolean()); }
void setPropertyInfos(PropertyInfoImpl[] propInfos, IdFactory idFactory) throws RepositoryException { boolean resolveUUID = false; for (PropertyInfoImpl propInfo : propInfos) { Name pn = propInfo.getId().getName(); if (NameConstants.JCR_UUID.equals(pn)) { id = idFactory.createNodeId(propInfo.getValues()[0].getString()); resolveUUID = true; } else if (NameConstants.JCR_PRIMARYTYPE.equals(pn)) { primaryNodeTypeName = propInfo.getValues()[0].getName(); } else if (NameConstants.JCR_MIXINTYPES.equals(pn)) { QValue[] vs = propInfo.getValues(); Name[] mixins = new Name[vs.length]; for (int i = 0; i < vs.length; i++) { mixins[i] = vs[i].getName(); } mixinNodeTypeNames = mixins; } } propertyIds.clear(); for (PropertyInfoImpl propInfo : propInfos) { if (resolveUUID) { propInfo.setId(idFactory.createPropertyId(id, propInfo.getName())); } propertyIds.add(propInfo.getId()); } }
public static Name getPrimaryTypeName(PropertyState ps) throws RepositoryException { if (!NameConstants.JCR_PRIMARYTYPE.equals(ps.getName())) { throw new IllegalArgumentException(); } QValue[] values = ps.getValues(); return values[0].getName(); }
/** * @see org.apache.jackrabbit.spi.QValueConstraint#check(QValue) */ public void check(QValue value) throws ConstraintViolationException, RepositoryException { if (value == null) { throw new ConstraintViolationException("null value does not satisfy the constraint '" + getString() + "'"); } switch (value.getType()) { case PropertyType.NAME: Name n = value.getName(); if (!name.equals(n)) { throw new ConstraintViolationException(n + " does not satisfy the constraint '" + getString() + "'"); } return; default: String msg = "NAME constraint can not be applied to value of type: " + PropertyType.nameFromValue(value.getType()); log.debug(msg); throw new RepositoryException(msg); } }
@Override public void addProperty(NodeId parentId, Name propertyName, int propertyType, QValue[] values) throws RepositoryException { properties.append("<sv:property sv:name=\"").append(getResolver().getJCRName(propertyName)).append("\""); properties.append(" sv:type=\"").append(PropertyType.nameFromValue(propertyType) + "\">"); for (QValue value : values) { properties.append("<sv:value>").append(value.getString()).append("</sv:value>"); } properties.append("</sv:property>"); }
/** * {@inheritDoc} */ public int getType() { return qvalue.getType(); }
public void testSetEmptyBinaryValue() throws RepositoryException, IOException { NodeId nid = getNodeId(testPath); Name propName = resolver.getQName("binProp"); Batch b = rs.createBatch(si, nid); b.addProperty(nid, propName, rs.getQValueFactory().create(new byte[0])); rs.submit(b); PropertyInfo pi = rs.getPropertyInfo(si, getPropertyId(nid, propName)); assertFalse(pi.isMultiValued()); InputStream in = pi.getValues()[0].getStream(); assertTrue(in.read() == -1); assertEquals("", pi.getValues()[0].getString()); assertEquals(PropertyType.BINARY, pi.getType()); pi = getPropertyInfo(nid, propName); assertFalse(pi.isMultiValued()); in = pi.getValues()[0].getStream(); assertTrue(in.read() == -1); assertEquals("", pi.getValues()[0].getString()); assertEquals(PropertyType.BINARY, pi.getType()); }
public void testPathValueGetPath() throws RepositoryException { QValue v = factory.create(rootPath); assertTrue(v.getPath().equals(rootPath)); }