Examples of org.jboss.dna.graph.property.Binary

org.jboss.dna.graph.property.Binary
Value holder for binary data. Binary instances are not mutable.

     * 
     * @see javax.jcr.Property#getStream()
     */
    public InputStream getStream() throws RepositoryException {
        try {
            Binary binary = context().getValueFactories().getBinaryFactory().create(property().getFirstValue());
            return new SelfClosingInputStream(binary);
        } catch (org.jboss.dna.graph.property.ValueFormatException e) {
            throw new ValueFormatException(e.getMessage(), e);
        }
    }

View Full Code Here

            return PropertyType.BINARY;
        }


        @Override
        public boolean matches( Value value ) {
            Binary binary = valueFactories.getBinaryFactory().create(((JcrValue)value).value());
            Value sizeValue = ((JcrValue)value).sessionCache().session().getValueFactory().createValue(binary.getSize());
            return super.matches(sizeValue);
        }

View Full Code Here

                String uuid = valueFactories.getStringFactory().create(value.getUUID());
                return new JcrValue(valueFactories, sessionCache, PropertyType.REFERENCE, uuid);
            }


            public Value createValue( InputStream value ) {
                Binary binary = valueFactories.getBinaryFactory().create(value);
                return new JcrValue(valueFactories, sessionCache, PropertyType.BINARY, binary);
            }


            public Value createValue( Calendar value ) {
                DateTime dateTime = valueFactories.getDateFactory().create(value);

View Full Code Here

        if (state == State.NON_INPUT_STREAM_CONSUMED) {
            throw new IllegalStateException(JcrI18n.nonInputStreamConsumed.text());
        }
        try {
            if (asStream == null) {
                Binary binary = valueFactories.getBinaryFactory().create(value);
                asStream = new SelfClosingInputStream(binary);
                state = State.INPUT_STREAM_CONSUMED;
            }
            return asStream;
        } catch (RuntimeException error) {

View Full Code Here

                switch (this.type) {
                    case PropertyType.STRING:
                        return this.getString().equals(that.getString());
                    case PropertyType.BINARY:
                        BinaryFactory binaryFactory = valueFactories.getBinaryFactory();
                        Binary thisValue = binaryFactory.create(this.value);
                        Binary thatValue = binaryFactory.create(that.value);
                        return thisValue.equals(thatValue);
                    case PropertyType.BOOLEAN:
                        return this.getBoolean() == that.getBoolean();
                    case PropertyType.DOUBLE:
                        return this.getDouble() == that.getDouble();

View Full Code Here

        return new JcrValue(factories, cache, PropertyType.DATE, dateTime);
    }


    final JcrValue valueFrom( InputStream value ) {
        ValueFactories factories = cache.factories();
        Binary binary = factories.getBinaryFactory().create(value);
        return new JcrValue(factories, cache, PropertyType.DATE, binary);
    }

View Full Code Here

                            return toValue(value);
                        }


                        public BatchConjunction to( InputStream stream,
                                                    long approximateLength ) {
                            Binary value = getContext().getValueFactories().getBinaryFactory().create(stream, approximateLength);
                            return toValue(value);
                        }


                        public BatchConjunction to( Reader reader,
                                                    long approximateLength ) {
                            Binary value = getContext().getValueFactories().getBinaryFactory().create(reader, approximateLength);
                            return toValue(value);
                        }


                        public BatchConjunction to( Object value ) {
                            value = convertReferenceValue(value);
                            Property property = getContext().getPropertyFactory().create(propertyName, value);
                            requestQueue.setProperty(location, getCurrentWorkspaceName(), property);
                            return nextRequests;
                        }


                        public BatchConjunction to( Object firstValue,
                                                    Object... otherValues ) {
                            firstValue = convertReferenceValue(firstValue);
                            for (int i = 0, len = otherValues.length; i != len; ++i) {
                                otherValues[i] = convertReferenceValue(otherValues[i]);
                            }
                            Property property = getContext().getPropertyFactory().create(propertyName, firstValue, otherValues);
                            requestQueue.setProperty(location, getCurrentWorkspaceName(), property);
                            return nextRequests;
                        }


                        public BatchConjunction to( Object[] values ) {
                            for (int i = 0; i != values.length; ++i) {
                                values[i] = convertReferenceValue(values[i]);
                            }
                            Property property = getContext().getPropertyFactory().create(propertyName, values);
                            requestQueue.setProperty(location, getCurrentWorkspaceName(), property);
                            return nextRequests;
                        }


                        public BatchConjunction to( Iterable<?> values ) {
                            List<Object> valueList = new LinkedList<Object>();
                            for (Object value : values) {
                                value = convertReferenceValue(value);
                                valueList.add(value);
                            }
                            Property property = getContext().getPropertyFactory().create(propertyName, valueList);
                            requestQueue.setProperty(location, getCurrentWorkspaceName(), property);
                            return nextRequests;
                        }


                        public BatchConjunction to( Iterator<?> values ) {
                            List<Object> valueList = new LinkedList<Object>();
                            while (values.hasNext()) {
                                Object value = values.next();
                                valueList.add(value);
                            }
                            Property property = getContext().getPropertyFactory().create(propertyName, valueList);
                            requestQueue.setProperty(location, getCurrentWorkspaceName(), property);
                            return nextRequests;
                        }


                    };
                }


                public SetValuesTo<BatchConjunction> on( String path ) {
                    return on(Location.create(createPath(path)));
                }


                public SetValuesTo<BatchConjunction> on( Path path ) {
                    return on(Location.create(path));
                }


                public SetValuesTo<BatchConjunction> on( Property idProperty ) {
                    return on(Location.create(idProperty));
                }


                public SetValuesTo<BatchConjunction> on( Property firstIdProperty,
                                                         Property... additionalIdProperties ) {
                    return on(Location.create(firstIdProperty, additionalIdProperties));
                }


                public SetValuesTo<BatchConjunction> on( Iterable<Property> idProperties ) {
                    return on(Location.create(idProperties));
                }


                public SetValuesTo<BatchConjunction> on( UUID uuid ) {
                    return on(Location.create(uuid));
                }


                public On<BatchConjunction> to( Node value ) {
                    Object reference = convertReferenceValue(value);
                    return set(getContext().getPropertyFactory().create(propertyName, reference));
                }


                public On<BatchConjunction> to( Location value ) {
                    Object reference = convertReferenceValue(value);
                    return set(getContext().getPropertyFactory().create(propertyName, reference));
                }


                protected On<BatchConjunction> toValue( Object value ) {
                    return set(getContext().getPropertyFactory().create(propertyName, value));
                }


                public On<BatchConjunction> to( String value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( int value ) {
                    return toValue(Integer.valueOf(value));
                }


                public On<BatchConjunction> to( long value ) {
                    return toValue(Long.valueOf(value));
                }


                public On<BatchConjunction> to( boolean value ) {
                    return toValue(Boolean.valueOf(value));
                }


                public On<BatchConjunction> to( float value ) {
                    return toValue(Float.valueOf(value));
                }


                public On<BatchConjunction> to( double value ) {
                    return toValue(Double.valueOf(value));
                }


                public On<BatchConjunction> to( BigDecimal value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( Calendar value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( Date value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( DateTime value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( Name value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( Path value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( Reference value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( URI value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( UUID value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( Binary value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( byte[] value ) {
                    return toValue(value);
                }


                public On<BatchConjunction> to( InputStream stream,
                                                long approximateLength ) {
                    Binary value = getContext().getValueFactories().getBinaryFactory().create(stream, approximateLength);
                    return toValue(value);
                }


                public On<BatchConjunction> to( Reader reader,
                                                long approximateLength ) {
                    Binary value = getContext().getValueFactories().getBinaryFactory().create(reader, approximateLength);
                    return toValue(value);
                }


                public On<BatchConjunction> to( Object value ) {
                    value = convertReferenceValue(value);

View Full Code Here

                        return toValue(value);
                    }


                    public Conjunction<Graph> to( InputStream stream,
                                                  long approximateLength ) {
                        Binary value = getContext().getValueFactories().getBinaryFactory().create(stream, approximateLength);
                        return toValue(value);
                    }


                    public Conjunction<Graph> to( Reader reader,
                                                  long approximateLength ) {
                        Binary value = getContext().getValueFactories().getBinaryFactory().create(reader, approximateLength);
                        return toValue(value);
                    }


                    public Conjunction<Graph> to( Object value ) {
                        value = convertReferenceValue(value);
                        Property property = getContext().getPropertyFactory().create(propertyName, value);
                        requests.setProperty(location, getCurrentWorkspaceName(), property);
                        return nextGraph;
                    }


                    public Conjunction<Graph> to( Object firstValue,
                                                  Object... otherValues ) {
                        firstValue = convertReferenceValue(firstValue);
                        for (int i = 0, len = otherValues.length; i != len; ++i) {
                            otherValues[i] = convertReferenceValue(otherValues[i]);
                        }
                        Property property = getContext().getPropertyFactory().create(propertyName, firstValue, otherValues);
                        requests.setProperty(location, getCurrentWorkspaceName(), property);
                        return nextGraph;
                    }


                    public Conjunction<Graph> to( Object[] values ) {
                        for (int i = 0, len = values.length; i != len; ++i) {
                            values[i] = convertReferenceValue(values[i]);
                        }
                        Property property = getContext().getPropertyFactory().create(propertyName, values);
                        requests.setProperty(location, getCurrentWorkspaceName(), property);
                        return nextGraph;
                    }


                    public Conjunction<Graph> to( Iterable<?> values ) {
                        List<Object> valueList = new LinkedList<Object>();
                        for (Object value : values) {
                            value = convertReferenceValue(value);
                            valueList.add(value);
                        }
                        Property property = getContext().getPropertyFactory().create(propertyName, valueList);
                        requests.setProperty(location, getCurrentWorkspaceName(), property);
                        return nextGraph;
                    }


                    public Conjunction<Graph> to( Iterator<?> values ) {
                        List<Object> valueList = new LinkedList<Object>();
                        while (values.hasNext()) {
                            Object value = values.next();
                            valueList.add(value);
                        }
                        Property property = getContext().getPropertyFactory().create(propertyName, valueList);
                        requests.setProperty(location, getCurrentWorkspaceName(), property);
                        return nextGraph;
                    }
                };
            }


            public SetValuesTo<Conjunction<Graph>> on( String path ) {
                return on(Location.create(createPath(path)));
            }


            public SetValuesTo<Conjunction<Graph>> on( Path path ) {
                return on(Location.create(path));
            }


            public SetValuesTo<Conjunction<Graph>> on( Property idProperty ) {
                return on(Location.create(idProperty));
            }


            public SetValuesTo<Conjunction<Graph>> on( Property firstIdProperty,
                                                       Property... additionalIdProperties ) {
                return on(Location.create(firstIdProperty, additionalIdProperties));
            }


            public SetValuesTo<Conjunction<Graph>> on( Iterable<Property> idProperties ) {
                return on(Location.create(idProperties));
            }


            public SetValuesTo<Conjunction<Graph>> on( UUID uuid ) {
                return on(Location.create(uuid));
            }


            public On<Conjunction<Graph>> to( Node node ) {
                Reference value = (Reference)convertReferenceValue(node);
                return set(getContext().getPropertyFactory().create(propertyName, value));
            }


            public On<Conjunction<Graph>> to( Location location ) {
                Reference value = (Reference)convertReferenceValue(location);
                return set(getContext().getPropertyFactory().create(propertyName, value));
            }


            protected On<Conjunction<Graph>> toValue( Object value ) {
                return set(getContext().getPropertyFactory().create(propertyName, value));
            }


            public On<Conjunction<Graph>> to( String value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( int value ) {
                return toValue(Integer.valueOf(value));
            }


            public On<Conjunction<Graph>> to( long value ) {
                return toValue(Long.valueOf(value));
            }


            public On<Conjunction<Graph>> to( boolean value ) {
                return toValue(Boolean.valueOf(value));
            }


            public On<Conjunction<Graph>> to( float value ) {
                return toValue(Float.valueOf(value));
            }


            public On<Conjunction<Graph>> to( double value ) {
                return toValue(Double.valueOf(value));
            }


            public On<Conjunction<Graph>> to( BigDecimal value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( Calendar value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( Date value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( DateTime value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( Name value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( Path value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( Reference value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( URI value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( UUID value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( Binary value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( byte[] value ) {
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( InputStream stream,
                                              long approximateLength ) {
                Binary value = getContext().getValueFactories().getBinaryFactory().create(stream, approximateLength);
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( Reader reader,
                                              long approximateLength ) {
                Binary value = getContext().getValueFactories().getBinaryFactory().create(reader, approximateLength);
                return toValue(value);
            }


            public On<Conjunction<Graph>> to( Object value ) {
                value = convertReferenceValue(value);

View Full Code Here

        // Get the binary property with the image content, and build the image metadata from the image ...
        ValueFactories factories = context.getExecutionContext().getValueFactories();
        SequencerOutputMap output = new SequencerOutputMap(factories);
        InputStream stream = null;
        Throwable firstError = null;
        Binary binary = factories.getBinaryFactory().create(sequencedProperty.getFirstValue());
        binary.acquire();
        try {
            // Parallel the JCR lemma for converting objects into streams
            stream = binary.getStream();
            StreamSequencerContext StreamSequencerContext = createStreamSequencerContext(input,
                                                                                         sequencedProperty,
                                                                                         context,
                                                                                         problems);
            this.streamSequencer.sequence(stream, output, StreamSequencerContext);
        } catch (Throwable t) {
            // Record the error ...
            firstError = t;
        } finally {
            try {
                if (stream != null) {
                    // Always close the stream, recording the error if we've not yet seen an error
                    try {
                        stream.close();
                    } catch (Throwable t) {
                        if (firstError == null) firstError = t;
                    } finally {
                        stream = null;
                    }
                }
                if (firstError != null) {
                    // Wrap and throw the first error that we saw ...
                    throw new SequencerException(firstError);
                }
            } finally {
                binary.release();
            }
        }


        // Accumulator of paths that we've added to the batch but have not yet been submitted to the graph
        Set<Path> builtPaths = new HashSet<Path>();

View Full Code Here

        }
    }


    @Test
    public void shouldConsiderEquivalentThoseInstancesWithSameContent() {
        Binary another = new InMemoryBinary(validByteArrayContent);
        assertThat(binary.equals(another), is(true));
        assertThat(binary.compareTo(another), is(0));
        assertThat(binary, is(another));
        assertThat(binary, hasContent(validByteArrayContent));
        assertThat(another, hasContent(validByteArrayContent));

View Full Code Here

0 1 2

TOP

Related Classes of org.jboss.dna.graph.property.Binary

org.jboss.dna.connector.store.jpa.model.basic.BasicRequestProcessor$LargeValueSerializer

org.jboss.dna.connector.store.jpa.util.Serializer

org.jboss.dna.connector.store.jpa.util.SerializerTest

org.jboss.dna.connector.svn.SVNRepositoryRequestProcessor

org.jboss.dna.graph.Graph

org.jboss.dna.graph.Graph$Batch

org.jboss.dna.graph.property.basic.AbstractBinary

org.jboss.dna.graph.property.basic.InMemoryBinaryTest

org.jboss.dna.jcr.AbstractJcrNode

org.jboss.dna.jcr.JcrPropertyDefinition$BinaryConstraintChecker

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.