public override ValueGetter <T> GetGetter <T>(IExceptionContext ctx)
{
ctx.Check(typeof(T) == typeof(VBuffer <TValue>));
return((ValueGetter <T>)_getter);
}
public void CheckColumnInRange(int col)
{
_ectx.Check(0 <= col && col < _groupCount + KeepIds.Length);
}
public void CheckAtModel()
{
_ectx.Check(Writer.BaseStream.Position == FpMin + Header.FpModel);
}
private static object ParseJsonValue(IExceptionContext ectx, Type type, Attributes attributes, JToken value, ComponentCatalog catalog)
{
Contracts.AssertValue(ectx);
ectx.AssertValue(type);
ectx.AssertValueOrNull(value);
ectx.AssertValue(catalog);
if (value == null)
{
return(null);
}
if (value is JValue val && val.Value == null)
{
return(null);
}
if (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(Optional <>) || type.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
if (type.GetGenericTypeDefinition() == typeof(Optional <>) && value.HasValues)
{
value = value.Values().FirstOrDefault();
}
type = type.GetGenericArguments()[0];
}
if (type.IsGenericType && (type.GetGenericTypeDefinition() == typeof(Var <>)))
{
string varName = value.Value <string>();
ectx.Check(VariableBinding.IsBindingToken(value), "Variable name expected.");
var variable = Activator.CreateInstance(type) as IVarSerializationHelper;
var varBinding = VariableBinding.Create(ectx, varName);
variable.VarName = varBinding.VariableName;
return(variable);
}
if (type == typeof(JArray) && value is JArray)
{
return(value);
}
TlcModule.DataKind dt = TlcModule.GetDataType(type);
try
{
switch (dt)
{
case TlcModule.DataKind.Bool:
return(value.Value <bool>());
case TlcModule.DataKind.String:
return(value.Value <string>());
case TlcModule.DataKind.Char:
return(value.Value <char>());
case TlcModule.DataKind.Enum:
if (!Enum.IsDefined(type, value.Value <string>()))
{
throw ectx.Except($"Requested value '{value.Value<string>()}' is not a member of the Enum type '{type.Name}'");
}
return(Enum.Parse(type, value.Value <string>()));
case TlcModule.DataKind.Float:
if (type == typeof(double))
{
return(value.Value <double>());
}
else if (type == typeof(float))
{
return(value.Value <float>());
}
else
{
ectx.Assert(false);
throw ectx.ExceptNotSupp();
}
case TlcModule.DataKind.Array:
var ja = value as JArray;
ectx.Check(ja != null, "Expected array value");
Func <IExceptionContext, JArray, Attributes, ComponentCatalog, object> makeArray = MakeArray <int>;
return(Utils.MarshalInvoke(makeArray, type.GetElementType(), ectx, ja, attributes, catalog));
case TlcModule.DataKind.Int:
if (type == typeof(long))
{
return(value.Value <long>());
}
if (type == typeof(int))
{
return(value.Value <int>());
}
ectx.Assert(false);
throw ectx.ExceptNotSupp();
case TlcModule.DataKind.UInt:
if (type == typeof(ulong))
{
return(value.Value <ulong>());
}
if (type == typeof(uint))
{
return(value.Value <uint>());
}
ectx.Assert(false);
throw ectx.ExceptNotSupp();
case TlcModule.DataKind.Dictionary:
ectx.Check(value is JObject, "Expected object value");
Func <IExceptionContext, JObject, Attributes, ComponentCatalog, object> makeDict = MakeDictionary <int>;
return(Utils.MarshalInvoke(makeDict, type.GetGenericArguments()[1], ectx, (JObject)value, attributes, catalog));
case TlcModule.DataKind.Component:
var jo = value as JObject;
ectx.Check(jo != null, "Expected object value");
// REVIEW: consider accepting strings alone.
var jName = jo[FieldNames.Name];
ectx.Check(jName != null, "Field '" + FieldNames.Name + "' is required for component.");
ectx.Check(jName is JValue, "Expected '" + FieldNames.Name + "' field to be a string.");
var name = jName.Value <string>();
ectx.Check(jo[FieldNames.Settings] == null || jo[FieldNames.Settings] is JObject,
"Expected '" + FieldNames.Settings + "' field to be an object");
return(GetComponentJson(ectx, type, name, jo[FieldNames.Settings] as JObject, catalog));
default:
var settings = value as JObject;
ectx.Check(settings != null, "Expected object value");
var inputBuilder = new InputBuilder(ectx, type, catalog);
if (inputBuilder._fields.Length == 0)
{
throw ectx.Except($"Unsupported input type: {dt}");
}
if (settings != null)
{
foreach (var pair in settings)
{
if (!inputBuilder.TrySetValueJson(pair.Key, pair.Value))
{
throw ectx.Except($"Unexpected value for component '{type}', field '{pair.Key}': '{pair.Value}'");
}
}
}
var missing = inputBuilder.GetMissingValues().ToArray();
if (missing.Length > 0)
{
throw ectx.Except($"The following required inputs were not provided for component '{type}': {string.Join(", ", missing)}");
}
return(inputBuilder.GetInstance());
}
}
catch (FormatException ex)
{
if (ex.IsMarked())
{
throw;
}
throw ectx.Except(ex, $"Failed to parse JSON value '{value}' as {type}");
}
}
// This converts in place.
private static void FillValues(IExceptionContext ectx, ref VBuffer <Float> buffer)
{
int size = buffer.Length;
ectx.Check(0 <= size & size < int.MaxValue / 2);
int count = buffer.Count;
var values = buffer.Values;
var indices = buffer.Indices;
int iivDst = 0;
if (count >= size)
{
// Currently, it's dense. We always produce sparse.
ectx.Assert(Utils.Size(values) >= size);
if (Utils.Size(indices) < size)
{
indices = new int[size];
}
for (int ivSrc = 0; ivSrc < count; ivSrc++)
{
ectx.Assert(iivDst <= ivSrc);
var val = values[ivSrc];
if (val == 0)
{
continue;
}
if (Float.IsNaN(val))
{
values[iivDst] = 1;
indices[iivDst] = 2 * ivSrc + 1;
}
else
{
values[iivDst] = val;
indices[iivDst] = 2 * ivSrc;
}
iivDst++;
}
}
else
{
// Currently, it's sparse.
ectx.Assert(Utils.Size(values) >= count);
ectx.Assert(Utils.Size(indices) >= count);
int ivPrev = -1;
for (int iivSrc = 0; iivSrc < count; iivSrc++)
{
ectx.Assert(iivDst <= iivSrc);
var val = values[iivSrc];
if (val == 0)
{
continue;
}
int iv = indices[iivSrc];
ectx.Assert(ivPrev < iv & iv < size);
ivPrev = iv;
if (Float.IsNaN(val))
{
values[iivDst] = 1;
indices[iivDst] = 2 * iv + 1;
}
else
{
values[iivDst] = val;
indices[iivDst] = 2 * iv;
}
iivDst++;
}
}
ectx.Assert(0 <= iivDst & iivDst <= count);
buffer = new VBuffer <Float>(size * 2, iivDst, values, indices);
}
/// <summary>
/// Sometimes it is necessary to cast the Count to an int. This performs overflow check.
/// </summary>
public static int GetCountAsInt32(this KeyType key, IExceptionContext ectx = null)
{
ectx.Check(key.Count <= int.MaxValue, nameof(KeyType) + "." + nameof(KeyType.Count) + " exceeds int.MaxValue.");
return((int)key.Count);
}
// This converts in place.
private static void FillValues(IExceptionContext ectx, ref VBuffer <Float> buffer)
{
int size = buffer.Length;
ectx.Check(0 <= size & size < int.MaxValue / 2);
var values = buffer.GetValues();
var editor = VBufferEditor.Create(ref buffer, size * 2, values.Length);
int iivDst = 0;
if (buffer.IsDense)
{
// Currently, it's dense. We always produce sparse.
for (int ivSrc = 0; ivSrc < values.Length; ivSrc++)
{
ectx.Assert(iivDst <= ivSrc);
var val = values[ivSrc];
if (val == 0)
{
continue;
}
if (Float.IsNaN(val))
{
editor.Values[iivDst] = 1;
editor.Indices[iivDst] = 2 * ivSrc + 1;
}
else
{
editor.Values[iivDst] = val;
editor.Indices[iivDst] = 2 * ivSrc;
}
iivDst++;
}
}
else
{
// Currently, it's sparse.
var indices = buffer.GetIndices();
int ivPrev = -1;
for (int iivSrc = 0; iivSrc < values.Length; iivSrc++)
{
ectx.Assert(iivDst <= iivSrc);
var val = values[iivSrc];
if (val == 0)
{
continue;
}
int iv = indices[iivSrc];
ectx.Assert(ivPrev < iv & iv < size);
ivPrev = iv;
if (Float.IsNaN(val))
{
editor.Values[iivDst] = 1;
editor.Indices[iivDst] = 2 * iv + 1;
}
else
{
editor.Values[iivDst] = val;
editor.Indices[iivDst] = 2 * iv;
}
iivDst++;
}
}
ectx.Assert(0 <= iivDst & iivDst <= values.Length);
buffer = editor.CommitTruncated(iivDst);
}