private static int WorstCaseLength(AnyValue value)
{
if (value.SequenceValue)
{
SequenceValue sequenceValue = ( SequenceValue )value;
if (sequenceValue is TextArray)
{
TextArray textArray = ( TextArray )sequenceValue;
int length = 0;
for (int i = 0; i < textArray.Length(); i++)
{
length += StringWorstCaseLength(textArray.StringValue(i).Length);
}
return(length);
}
return(sequenceValue.Length() * BIGGEST_STATIC_SIZE);
}
else
{
switch ((( Value )value).valueGroup().category())
{
case TEXT:
// For text, which is very dynamic in its nature do a worst-case off of number of characters in it
return(StringWorstCaseLength((( TextValue )value).length()));
default:
// For all else then use the biggest possible value for a non-dynamic, non-array value a state can occupy
return(BIGGEST_STATIC_SIZE);
}
}
}
public override void OnMetadata(string key, AnyValue value)
{
if (_responseHandler != null)
{
_responseHandler.onMetadata(key, value);
}
}
public static Value AssertBooleanOrNoValue(AnyValue value)
{
if (value != NO_VALUE && !(value is BooleanValue))
{
throw new CypherTypeException(string.Format("Don't know how to treat a predicate: {0}", value.ToString()), null);
}
return(( Value )value);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public void read(org.neo4j.bolt.messaging.BoltResponseMessageWriter messageWriter) throws java.io.IOException
public virtual void Read(BoltResponseMessageWriter messageWriter)
{
try
{
_unpacker.unpackStructHeader();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int signature = (int) unpacker.unpackStructSignature();
int signature = ( int )_unpacker.unpackStructSignature();
BoltResponseMessage message = BoltResponseMessage.withSignature(signature);
try
{
switch (message.innerEnumValue)
{
case Org.Neo4j.Bolt.v1.messaging.BoltResponseMessage.InnerEnum.SUCCESS:
MapValue successMetadata = _unpacker.unpackMap();
messageWriter.Write(new SuccessMessage(successMetadata));
break;
case Org.Neo4j.Bolt.v1.messaging.BoltResponseMessage.InnerEnum.RECORD:
long length = _unpacker.unpackListHeader();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.values.AnyValue[] fields = new org.neo4j.values.AnyValue[(int) length];
AnyValue[] fields = new AnyValue[( int )length];
for (int i = 0; i < length; i++)
{
fields[i] = _unpacker.unpack();
}
messageWriter.Write(new RecordMessage(record(fields)));
break;
case Org.Neo4j.Bolt.v1.messaging.BoltResponseMessage.InnerEnum.IGNORED:
messageWriter.Write(IgnoredMessage.IGNORED_MESSAGE);
break;
case Org.Neo4j.Bolt.v1.messaging.BoltResponseMessage.InnerEnum.FAILURE:
MapValue failureMetadata = _unpacker.unpackMap();
string code = failureMetadata.ContainsKey("code") ? (( StringValue )failureMetadata.Get("code")).stringValue() : Org.Neo4j.Kernel.Api.Exceptions.Status_General.UnknownError.name();
string msg = failureMetadata.ContainsKey("message") ? (( StringValue )failureMetadata.Get("message")).stringValue() : "<No message supplied>";
messageWriter.Write(new FailureMessage(Neo4jError.codeFromString(code), msg));
break;
default:
throw new BoltIOException(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, string.Format("Message 0x{0} is not supported.", signature.ToString("x")));
}
}
catch (System.ArgumentException)
{
throw new BoltIOException(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, string.Format("Message 0x{0} is not a valid message signature.", signature.ToString("x")));
}
}
catch (PackStream.PackStreamException e)
{
throw new BoltIOException(Org.Neo4j.Kernel.Api.Exceptions.Status_Request.InvalidFormat, string.Format("Unable to read message type. Error was: {0}.", e.Message), e);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void testFailureWithV1Value(org.neo4j.values.AnyValue value, String description) throws Exception
private void TestFailureWithV1Value(AnyValue value, string description)
{
Connection.connect(Address).send(Util.defaultAcceptedVersions());
assertThat(Connection, Util.eventuallyReceivesSelectedProtocolVersion());
Connection.send(Util.chunk(new InitMessage(USER_AGENT, Collections.emptyMap())));
assertThat(Connection, Util.eventuallyReceives(msgSuccess()));
Connection.send(Util.chunk(64, CreateRunWithV1Value(value)));
assertThat(Connection, Util.eventuallyReceives(msgFailure(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.TypeError, description + " values cannot be unpacked with this version of bolt.")));
assertThat(Connection, eventuallyDisconnects());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private byte[] createRunWithV1Value(org.neo4j.values.AnyValue value) throws java.io.IOException
private sbyte[] CreateRunWithV1Value(AnyValue value)
{
PackedOutputArray @out = new PackedOutputArray();
Org.Neo4j.Bolt.messaging.Neo4jPack_Packer packer = Neo4jPack.newPacker(@out);
packer.PackStructHeader(2, RunMessage.SIGNATURE);
packer.Pack("RETURN $x");
packer.PackMapHeader(1);
packer.Pack("x");
packer.Pack(value);
return(@out.Bytes());
}
protected internal override LocalTimeValue Select(AnyValue from, System.Func <ZoneId> defaultZone)
{
return(LocalTimeValue.select(from, defaultZone));
}
public void addMetadata(string key, AnyValue value)
{
outerInstance.OnMetadata(key, value);
}
private void VerifyDoesNotTouchValue(AnyValue value)
{
AnyValue mappedValue = CompiledMaterializeValueMapper.MapAnyValue(spi, value);
assertSame(value, mappedValue); // Test with reference equality since we should get the same reference back
}
private void VerifyConvertsValue(AnyValue expected, AnyValue valueToTest)
{
AnyValue actual = CompiledMaterializeValueMapper.MapAnyValue(spi, valueToTest);
assertEquals(expected, actual);
}
public override void OnMetadata(string key, AnyValue value)
{
// this page intentionally left blank
}
