public override bool TryExtract <T1>(Mark mark, Extractor <T1> extractor, CSVHeaderInformation optionalData)
{
int from = mark.StartPosition();
int to = mark.Position();
return(extractor.Extract(_buffer, from, to - from, mark.Quoted, optionalData));
}
protected internal override Header.Entry Entry <T1>(int index, string name, string typeSpec, Group group, Extractors extractors, Extractor <T1> idExtractor)
{
Type type = null;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.csv.reader.Extractor<?> extractor = null;
Extractor <object> extractor = null;
CSVHeaderInformation optionalParameter = null;
if (string.ReferenceEquals(typeSpec, null))
{ // Property
type = Type.Property;
extractor = extractors.String();
}
else
{
Pair <string, string> split = SplitTypeSpecAndOptionalParameter(typeSpec);
typeSpec = split.First();
string optionalParameterString = split.Other();
if (!string.ReferenceEquals(optionalParameterString, null))
{
if (Extractors.PointExtractor.NAME.Equals(typeSpec))
{
optionalParameter = PointValue.parseHeaderInformation(optionalParameterString);
}
else if (Extractors.TimeExtractor.NAME.Equals(typeSpec) || Extractors.DateTimeExtractor.NAME.Equals(typeSpec))
{
optionalParameter = TemporalValue.parseHeaderInformation(optionalParameterString);
}
}
if (typeSpec.Equals(Type.StartId.name(), StringComparison.OrdinalIgnoreCase))
{
type = Type.StartId;
extractor = idExtractor;
}
else if (typeSpec.Equals(Type.EndId.name(), StringComparison.OrdinalIgnoreCase))
{
type = Type.EndId;
extractor = idExtractor;
}
else if (typeSpec.Equals(Type.Type.name(), StringComparison.OrdinalIgnoreCase))
{
type = Type.Type;
extractor = extractors.String();
}
else if (IsRecognizedType(typeSpec))
{
throw new HeaderException("Unexpected relationship header type '" + typeSpec + "'");
}
else
{
type = Type.Property;
extractor = ParsePropertyType(typeSpec, extractors);
}
}
return(new Header.Entry(name, type, group, extractor, optionalParameter));
}
/// <summary>
/// Parses the given text into a PointValue. The information stated in the header is saved into the PointValue
/// unless it is overridden by the information in the text
/// </summary>
/// <param name="text"> the input text to be parsed into a PointValue </param>
/// <param name="fieldsFromHeader"> must be a value obtained from <seealso cref="parseHeaderInformation(CharSequence)"/> or null </param> </returns> </param>
/// <returns> a PointValue instance with information from the {<param name="fieldsFromHeader">} and {<param name="text">} </param>
public static PointValue Parse(CharSequence text, CSVHeaderInformation fieldsFromHeader)
{
PointBuilder fieldsFromData = ParseHeaderInformation(text);
if (fieldsFromHeader != null)
{
// Merge InputFields: Data fields override header fields
if (!(fieldsFromHeader is PointBuilder))
{
throw new System.InvalidOperationException("Wrong header information type: " + fieldsFromHeader);
}
fieldsFromData.MergeWithHeader(( PointBuilder )fieldsFromHeader);
}
return(FromInputFields(fieldsFromData));
}
internal static void ParseHeaderInformation(CharSequence text, string type, CSVHeaderInformation info)
{
Matcher mapMatcher = MapPattern.matcher(text);
string errorMessage = format("Failed to parse %s value: '%s'", type, text);
if (!(mapMatcher.find() && mapMatcher.groupCount() == 1))
{
throw new InvalidValuesArgumentException(errorMessage);
}
string mapContents = mapMatcher.group(1);
if (mapContents.Length == 0)
{
throw new InvalidValuesArgumentException(errorMessage);
}
Matcher matcher = KeyValuePattern.matcher(mapContents);
if (!(matcher.find()))
{
throw new InvalidValuesArgumentException(errorMessage);
}
do
{
string key = matcher.group("k");
if (!string.ReferenceEquals(key, null))
{
string value = matcher.group("v");
if (!string.ReferenceEquals(value, null))
{
info.Assign(key, value);
}
}
} while (matcher.find());
}
public override EXTRACTOR Extract <EXTRACTOR>(Mark mark, EXTRACTOR extractor, CSVHeaderInformation optionalData)
{
if (!TryExtract(mark, extractor, optionalData))
{
throw new System.InvalidOperationException(extractor + " didn't extract value for " + mark + ". For values which are optional please use tryExtract method instead");
}
return(extractor);
}
protected internal override bool Extract0(char[] data, int offset, int length, CSVHeaderInformation optionalData)
{
if (length > 1)
{
throw new System.InvalidOperationException("Was told to extract a character, but length:" + length);
}
ValueConflict = data[offset];
return(true);
}
protected internal override void Extract0(char[] data, int offset, int length, CSVHeaderInformation optionalData)
{
int numberOfValues = numberOfValues(data, offset, length);
ValueConflict = numberOfValues > 0 ? new bool[numberOfValues] : Empty;
for (int arrayIndex = 0, charIndex = 0; arrayIndex < numberOfValues; arrayIndex++, charIndex++)
{
int numberOfChars = CharsToNextDelimiter(data, offset + charIndex, length - charIndex);
ValueConflict[arrayIndex] = ExtractBoolean(data, offset + charIndex, numberOfChars);
charIndex += numberOfChars;
}
}
protected internal override bool Extract0(char[] data, int offset, int length, CSVHeaderInformation optionalData)
{
ValueConflict = PointValue.parse(CharBuffer.wrap(data, offset, length), optionalData);
return(true);
}
protected internal abstract void Extract0(char[] data, int offset, int length, CSVHeaderInformation optionalData);
protected internal override void Extract0(char[] data, int offset, int length, CSVHeaderInformation optionalData)
{
int numberOfValues = numberOfValues(data, offset, length);
ValueConflict = numberOfValues > 0 ? new double[numberOfValues] : Empty;
for (int arrayIndex = 0, charIndex = 0; arrayIndex < numberOfValues; arrayIndex++, charIndex++)
{
int numberOfChars = CharsToNextDelimiter(data, offset + charIndex, length - charIndex);
// TODO Figure out a way to do this conversion without round tripping to String
// parseDouble automatically handles leading/trailing whitespace so no need for us to do it
ValueConflict[arrayIndex] = double.Parse(string.valueOf(data, offset + charIndex, numberOfChars));
charIndex += numberOfChars;
}
}
protected internal override bool Extract0(char[] data, int offset, int length, CSVHeaderInformation optionalData)
{
try
{
// TODO Figure out a way to do this conversion without round tripping to String
// parseDouble automatically handles leading/trailing whitespace so no need for us to do it
ValueConflict = double.Parse(string.valueOf(data, offset, length));
}
catch (System.FormatException)
{
throw new System.FormatException("Not a number: \"" + string.valueOf(data, offset, length) + "\"");
}
return(true);
}
public override bool Extract(char[] data, int offset, int length, bool hadQuotes, CSVHeaderInformation optionalData)
{
Extract0(data, offset, length, optionalData);
return(true);
}
public static TimeValue Parse(CharSequence text, System.Func <ZoneId> defaultZone, CSVHeaderInformation fieldsFromHeader)
{
if (fieldsFromHeader != null)
{
if (!(fieldsFromHeader is TimeCSVHeaderInformation))
{
throw new System.InvalidOperationException("Wrong header information type: " + fieldsFromHeader);
}
// Override defaultZone
defaultZone = (( TimeCSVHeaderInformation )fieldsFromHeader).ZoneSupplier(defaultZone);
}
return(Parse(typeof(TimeValue), _pattern, TimeValue.parse, text, defaultZone));
}
protected internal override bool Extract0(char[] data, int offset, int length, CSVHeaderInformation optionalData)
{
ValueConflict = ExtractBoolean(data, offset, length);
return(true);
}
protected internal override bool Extract0(char[] data, int offset, int length, CSVHeaderInformation optionalData)
{
ValueConflict = safeCastLongToByte(ExtractLong(data, offset, length));
return(true);
}
public override bool Extract(char[] data, int offset, int length, bool hadQuotes, CSVHeaderInformation optionalData)
{
if (NullValue(length, hadQuotes))
{
Clear();
return(false);
}
return(Extract0(data, offset, length, optionalData));
}
public abstract bool Extract(char[] data, int offset, int length, bool hadQuotes, CSVHeaderInformation optionalData);
