New results api

driver/src/main/java/org/neo4j/driver/v1/internal/value/InternalValue.java → driver/src/main/java/org/neo4j/driver/internal/AsValue.java

@@ -16,12 +16,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.neo4j.driver.v1.internal.value;
+package org.neo4j.driver.internal;
 
 import org.neo4j.driver.v1.Value;
-import org.neo4j.driver.v1.internal.types.TypeConstructor;
 
-public interface InternalValue extends Value
+public interface AsValue
 {
-    TypeConstructor typeConstructor();
+    /**
+     * Retrieve a value representation of this
+     *
+     * @see Value
+     * @return {@link Value} that represents this
+     */
+    Value asValue();
 }

driver/src/main/java/org/neo4j/driver/v1/internal/Identities.java → driver/src/main/java/org/neo4j/driver/internal/Identities.java

@@ -16,15 +16,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.neo4j.driver.v1.internal;
+package org.neo4j.driver.internal;
 
 import org.neo4j.driver.v1.Identity;
 
 public class Identities
 {
     public static Identity identity( long raw )
     {
-        return new SimpleIdentity( raw );
+        return new InternalIdentity( raw );
     }
-
 }

driver/src/main/java/org/neo4j/driver/v1/internal/SimpleEntity.java → driver/src/main/java/org/neo4j/driver/internal/InternalEntity.java

@@ -16,21 +16,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.neo4j.driver.v1.internal;
+package org.neo4j.driver.internal;
 
-import java.util.Collection;
 import java.util.Map;
 
+import org.neo4j.driver.internal.util.Extract;
+import org.neo4j.driver.internal.util.Iterables;
+import org.neo4j.driver.internal.value.MapValue;
 import org.neo4j.driver.v1.Entity;
+import org.neo4j.driver.v1.Function;
 import org.neo4j.driver.v1.Identity;
+import org.neo4j.driver.v1.Property;
 import org.neo4j.driver.v1.Value;
+import org.neo4j.driver.v1.Values;
 
-public abstract class SimpleEntity implements Entity
+import static org.neo4j.driver.v1.Values.valueAsIs;
+
+public abstract class InternalEntity implements Entity, AsValue
 {
     private final Identity id;
     private final Map<String,Value> properties;
 
-    public SimpleEntity( Identity id, Map<String,Value> properties )
+    public InternalEntity( Identity id, Map<String, Value> properties )
     {
         this.id = id;
         this.properties = properties;
@@ -43,21 +50,19 @@ public Identity identity()
     }
 
     @Override
-    public Collection<String> propertyKeys()
+    public Property property( String key )
     {
-        return properties.keySet();
+        return InternalProperty.of( key, value( key ) );
     }
 
-    @Override
-    public Value property( String key )
+    public int propertyCount()
     {
-        return properties.get( key );
+        return properties.size();
     }
 
-    @Override
-    public int propertyCount()
+    public Value asValue()
     {
-        return properties.size();
+        return new MapValue( properties );
     }
 
     @Override
@@ -72,7 +77,7 @@ public boolean equals( Object o )
             return false;
         }
 
-        SimpleEntity that = (SimpleEntity) o;
+        InternalEntity that = (InternalEntity) o;
 
         return id.equals( that.id );
 
@@ -92,4 +97,47 @@ public String toString()
                ", properties=" + properties +
                '}';
     }
+
+    @Override
+    public boolean containsKey( String key )
+    {
+        return properties.containsKey( key );
+    }
+
+    @Override
+    public Iterable<String> keys()
+    {
+        return properties.keySet();
+    }
+
+    @Override
+    public Value value( String key )
+    {
+        Value value = properties.get( key );
+        return value == null ? Values.NULL : value;
+    }
+
+    @Override
+    public Iterable<Value> values()
+    {
+        return properties.values();
+    }
+
+    @Override
+    public <T> Iterable<T> values( Function<Value,T> mapFunction )
+    {
+        return Iterables.map( properties.values(), mapFunction );
+    }
+
+    @Override
+    public Iterable<Property<Value>> properties()
+    {
+        return properties( valueAsIs() );
+    }
+
+    @Override
+    public <V> Iterable<Property<V>> properties( final Function<Value, V> Function )
+    {
+        return Extract.properties( this, Function );
+    }
 }

driver/src/main/java/org/neo4j/driver/internal/InternalField.java

@@ -0,0 +1,110 @@
+/**
+ * Copyright (c) 2002-2015 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.neo4j.driver.internal;
+
+import java.util.Objects;
+
+import org.neo4j.driver.v1.Field;
+import org.neo4j.driver.v1.Function;
+import org.neo4j.driver.v1.Property;
+
+public class InternalField<V> implements Field<V>
+{
+    private final int index;
+    private final String key;
+    private final V value;
+
+    public InternalField( String key, int index, V value )
+    {
+        if ( key == null )
+        {
+            throw new IllegalArgumentException( "null key" );
+        }
+        if ( value == null )
+        {
+            throw new IllegalArgumentException( "null value" );
+        }
+        this.index = index;
+        this.key = key;
+        this.value = value;
+    }
+
+    public String key()
+    {
+        return key;
+    }
+
+    public V value()
+    {
+        return value;
+    }
+
+    @Override
+    public int index()
+    {
+        return index;
+    }
+
+    @Override
+    public Property<V> asProperty()
+    {
+        return InternalProperty.of( key, value );
+    }
+
+    @Override
+    public String toString()
+    {
+        return String.format( "%s: %s", key, Objects.toString( value ) );
+    }
+
+    public String toString( Function<V, String> printValue )
+    {
+        return String.format( "%s: %s", key, printValue.apply( value ) );
+    }
+
+    @Override
+    public boolean equals( Object o )
+    {
+        if ( this == o )
+        {
+            return true;
+        }
+        if ( o == null || getClass() != o.getClass() )
+        {
+            return false;
+        }
+
+        InternalField<?> that = (InternalField<?>) o;
+        return index == that.index && key.equals( that.key ) && value.equals( that.value );
+    }
+
+    @Override
+    public int hashCode()
+    {
+        int result = index;
+        result = 31 * result + key.hashCode();
+        result = 31 * result + value.hashCode();
+        return result;
+    }
+
+    public static <V> Field<V> of( String key, int index, V value )
+    {
+        return new InternalField<>( key, index, value );
+    }
+}

driver/src/main/java/org/neo4j/driver/v1/internal/SimpleIdentity.java → driver/src/main/java/org/neo4j/driver/internal/InternalIdentity.java

@@ -16,19 +16,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.neo4j.driver.v1.internal;
+package org.neo4j.driver.internal;
 
+import org.neo4j.driver.internal.value.IdentityValue;
 import org.neo4j.driver.v1.Identity;
+import org.neo4j.driver.v1.Value;
 
-public class SimpleIdentity implements Identity
+public class InternalIdentity implements Identity, AsValue
 {
     private final long raw;
 
-    public SimpleIdentity( long raw )
+    public InternalIdentity( long raw )
     {
         this.raw = raw;
     }
 
+    @Override
+    public Value asValue()
+    {
+        return new IdentityValue( this );
+    }
+
     @Override
     public String toString()
     {
@@ -47,7 +55,7 @@ public boolean equals( Object o )
             return false;
         }
 
-        SimpleIdentity that = (SimpleIdentity) o;
+        InternalIdentity that = (InternalIdentity) o;
 
         return raw == that.raw;
 

driver/src/main/java/org/neo4j/driver/v1/internal/SimpleNode.java → driver/src/main/java/org/neo4j/driver/internal/InternalNode.java

@@ -16,34 +16,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.neo4j.driver.v1.internal;
+package org.neo4j.driver.internal;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Map;
 
+import org.neo4j.driver.internal.value.NodeValue;
 import org.neo4j.driver.v1.Identity;
 import org.neo4j.driver.v1.Node;
 import org.neo4j.driver.v1.Value;
 
 /**
  * {@link Node} implementation that directly contains labels and properties.
  */
-public class SimpleNode extends SimpleEntity implements Node
+public class InternalNode extends InternalEntity implements Node
 {
     private final Collection<String> labels;
 
-    public SimpleNode( long id )
+    public InternalNode( long id )
     {
         this( id, Collections.<String>emptyList(), Collections.<String,Value>emptyMap() );
     }
 
-    public SimpleNode( long id, Collection<String> labels, Map<String,Value> properties )
+    public InternalNode( long id, Collection<String> labels, Map<String, Value> properties )
     {
         this( Identities.identity( id ), labels, properties );
     }
 
-    public SimpleNode( Identity identity, Collection<String> labels, Map<String,Value> properties )
+    public InternalNode( Identity identity, Collection<String> labels, Map<String, Value> properties )
     {
         super( identity, properties );
         this.labels = labels;
@@ -55,10 +56,22 @@ public Collection<String> labels()
         return labels;
     }
 
+    @Override
+    public boolean hasLabel( String label )
+    {
+        return labels.contains( label );
+    }
+
+    @Override
+    public Value asValue()
+    {
+        return new NodeValue( this );
+    }
+
     @Override
     public String toString()
     {
-        return "node<" + identity() + '>';
+        return String.format( "node<%s>", identity()  );
     }
 
     @Override
@@ -77,7 +90,7 @@ public boolean equals( Object o )
             return false;
         }
 
-        SimpleNode that = (SimpleNode) o;
+        InternalNode that = (InternalNode) o;
 
         return !(labels != null ? !labels.equals( that.labels ) : that.labels != null);