/// <summary>Creates a new instance of <see cref="T:TeamSpeak3QueryApi.Net.Parameter"/>.</summary>
/// <param name="name">The name of the Query API parameter.</param>
/// <param name="value">The value of the Query API parameter.</param>
public Parameter(string name, IParameterValue value)
{
if (string.IsNullOrWhiteSpace(name))
throw new ArgumentNullException(nameof(name));
Name = name;
Value = value;
}
/// <summary>
/// Resolves a parameter value based on the provided object.
/// </summary>
/// <param name="descriptor">Parameter descriptor.</param>
/// <param name="value">Value to resolve the parameter value from.</param>
/// <returns>The parameter value.</returns>
public virtual object ResolveParameter(ParameterDescriptor descriptor, IParameterValue value)
{
if (value.GetType() == descriptor.Type)
{
return value;
}
return value.ConvertTo(descriptor.Type);
}
public float NormalizeValue(IParameterValue value)
{
var valueTyped = value as FloatParameterValue;
Contracts.Check(valueTyped != null, "FloatValueGenerator could not normalized parameter because it is not of the correct type");
Contracts.Check(_options.Min <= valueTyped.Value && valueTyped.Value <= _options.Max, "Value not in correct range");
if (_options.LogBase)
{
float logBase = (float)(_options.StepSize ?? Math.Pow(1.0 * _options.Max / _options.Min, 1.0 / (_options.NumSteps - 1)));
return((float)((Math.Log(valueTyped.Value, logBase) - Math.Log(_options.Min, logBase)) / (Math.Log(_options.Max, logBase) - Math.Log(_options.Min, logBase))));
}
else
{
return((valueTyped.Value - _options.Min) / (_options.Max - _options.Min));
}
}
private static ParameterSet ConvertToParameterSet(TlcModule.SweepableParamAttribute[] hps,
RecipeInference.SuggestedRecipe.SuggestedLearner learner)
{
if (learner.PipelineNode.HyperSweeperParamSet != null)
{
return(learner.PipelineNode.HyperSweeperParamSet);
}
var paramValues = new IParameterValue[hps.Length];
if (hps.Any(p => p.RawValue == null))
{
PopulateSweepableParams(learner);
}
for (int i = 0; i < hps.Length; i++)
{
Contracts.CheckValue(hps[i].RawValue, nameof(TlcModule.SweepableParamAttribute.RawValue));
switch (hps[i])
{
case TlcModule.SweepableDiscreteParamAttribute dp:
var learnerVal =
learner.PipelineNode.GetPropertyValueByName(dp.Name, (IComparable)dp.Options[0]);
var optionIndex = (int)(dp.RawValue ?? dp.IndexOf(learnerVal));
paramValues[i] = new StringParameterValue(dp.Name, dp.Options[optionIndex].ToString());
break;
case TlcModule.SweepableFloatParamAttribute fp:
paramValues[i] =
new FloatParameterValue(fp.Name,
(float)(fp.RawValue ?? learner.PipelineNode.GetPropertyValueByName(fp.Name, 0f)));
break;
case TlcModule.SweepableLongParamAttribute lp:
paramValues[i] =
new LongParameterValue(lp.Name,
(long)(lp.RawValue ?? learner.PipelineNode.GetPropertyValueByName(lp.Name, 0L)));
break;
}
}
learner.PipelineNode.HyperSweeperParamSet = new ParameterSet(paramValues);
return(learner.PipelineNode.HyperSweeperParamSet);
}
public void TestLongValueGeneratorRoundTrip()
{
var paramSweep = new LongValueGenerator(new LongParamArguments()
{
Name = "bla", Min = 0, Max = 17
});
var value = new LongParameterValue("bla", 5);
float normalizedValue = paramSweep.NormalizeValue(value);
IParameterValue unNormalizedValue = paramSweep.CreateFromNormalized(normalizedValue);
Assert.Equal("5", unNormalizedValue.ValueText);
IParameterValue param = paramSweep.CreateFromNormalized(0.345);
float unNormalizedParam = paramSweep.NormalizeValue(param);
Assert.Equal("5", param.ValueText);
Assert.Equal((float)5 / 17, unNormalizedParam);
}
// *********** Utility Functions *******************
private ParameterSet UpdateParameterSet(ParameterSet original, IParameterValue newParam)
{
List <IParameterValue> parameters = new List <IParameterValue>();
for (int i = 0; i < _sweepParameters.Length; i++)
{
if (_sweepParameters[i].Name.Equals(newParam.Name))
{
parameters.Add(newParam);
}
else
{
parameters.Add(original[_sweepParameters[i].Name]);
}
}
return(new ParameterSet(parameters));
}
public DatabaseCellViewModel(int columnIndex, DatabaseColumnJson columnDefinition, DatabaseEntityViewModel parent, DatabaseEntity parentEntity, IDatabaseField tableField, IParameterValue parameterValue) : base(parentEntity)
{
ColumnIndex = columnIndex * 2;
CanBeNull = columnDefinition.CanBeNull;
IsReadOnly = columnDefinition.IsReadOnly;
ColumnName = columnDefinition.Name;
DbColumnName = columnDefinition.DbColumnName;
Parent = parent;
TableField = tableField;
ParameterValue = parameterValue;
if (UseItemPicker)
{
AutoDispose(ParameterValue.ToObservable().Subscribe(_ => RaisePropertyChanged(nameof(OptionValue))));
}
if (UseFlagsPicker)
{
AutoDispose(ParameterValue.ToObservable().Subscribe(_ => RaisePropertyChanged(nameof(AsLongValue))));
}
AutoDispose(parameterValue.ToObservable().SubscribeAction(_ =>
{
OriginalValueTooltip =
tableField.IsModified ? "Original value: " + parameterValue.OriginalString : null;
RaisePropertyChanged(nameof(OriginalValueTooltip));
RaisePropertyChanged(nameof(AsBoolValue));
}));
if (parameterValue.BaseParameter is DatabaseStringContextualParameter contextual)
{
var other = parent.Cells.FirstOrDefault(c => c.DbColumnName == contextual.Column);
if (other != null)
{
AutoDispose(other.ParameterValue !.ToObservable().Subscribe(_ =>
{
parameterValue.RaiseChanged();
}));
}
else
{
Console.WriteLine("Couldn't find column " + contextual.Column);
}
}
}
public DatabaseCellViewModel(DatabaseRowViewModel parent,
DatabaseEntity parentEntity,
IDatabaseField tableField,
IParameterValue parameterValue,
IObservable <bool>?cellIsVisible)
{
Link(tableField, tf => tf.IsModified, () => IsModified);
ParentEntity = parentEntity;
Parent = parent;
TableField = tableField;
ParameterValue = parameterValue;
if (cellIsVisible != null)
{
AutoDispose(cellIsVisible.Subscribe(v =>
{
IsVisible = v;
RaisePropertyChanged(nameof(IsVisible));
}));
}
AutoDispose(parameterValue.ToObservable().SubscribeAction(_ =>
{
if (!inConstructor)
{
parent.AnyFieldModified();
}
OriginalValueTooltip =
tableField.IsModified ? "Original value: " + parameterValue.OriginalString : null;
RaisePropertyChanged(nameof(OriginalValueTooltip));
RaisePropertyChanged(nameof(AsBoolValue));
}));
if (UseItemPicker)
{
AutoDispose(ParameterValue.ToObservable().Subscribe(_ => RaisePropertyChanged(nameof(OptionValue))));
}
if (UseFlagsPicker)
{
AutoDispose(ParameterValue.ToObservable().Subscribe(_ => RaisePropertyChanged(nameof(AsLongValue))));
}
inConstructor = false;
}
public DatabaseCellViewModel(int columnIndex, DatabaseColumnJson columnDefinition, DatabaseEntityViewModel parent, DatabaseEntity parentEntity, IDatabaseField tableField, IParameterValue parameterValue)
{
ColumnIndex = columnIndex * 2;
CanBeNull = columnDefinition.CanBeNull;
IsReadOnly = columnDefinition.IsReadOnly;
ColumnName = columnDefinition.DbColumnName;
ParentEntity = parentEntity;
Parent = parent;
TableField = tableField;
ParameterValue = parameterValue;
AutoDispose(parameterValue.ToObservable().SubscribeAction(_ =>
{
OriginalValueTooltip =
tableField.IsModified ? "Original value: " + parameterValue.OriginalString : null;
RaisePropertyChanged(nameof(OriginalValueTooltip));
RaisePropertyChanged(nameof(AsBoolValue));
}));
}
private void addParameterValue(IParameterValue value)
{
if (value != null)
{
if (value.isPrimitive())
{
this.addPrimitiveParameterValue((IPrimitiveValue)value);
}
else
{
this.addParameterCollection((IParameterCollection)value);
}
}
else
{
throw new ArgumentException("Argument 'value' must be not null and " +
"an implemented IParameterValue object.");
}
}
public void Spawn(Visual parent, Rect position, IParameterValue <long> parameter)
{
this.parameter = parameter;
var flagsComboBox = new FlagComboBox();
flagsComboBox.Flags = parameter.Parameter.Items;
flagsComboBox.SelectedValue = parameter.Value;
flagsComboBox.HideButton = true;
flagsComboBox.IsLightDismissEnabled = false; // we are handling it ourselves, without doing .Handled = true so that as soon as user press outside of popup, the click is treated as actual click
flagsComboBox.Closed += CompletionComboBoxOnClosed;
if (!AttachAsAdorner(parent, position, flagsComboBox))
{
return;
}
DispatcherTimer.RunOnce(() =>
{
flagsComboBox.IsDropDownOpen = true;
}, TimeSpan.FromMilliseconds(1));
}
private static string BuildHubExecutableMethodCacheKey(HubDescriptor hub, string method, IParameterValue[] parameters)
{
string normalizedParameterCountKeyPart;
if(parameters != null)
{
normalizedParameterCountKeyPart = parameters.Length.ToString(CultureInfo.InvariantCulture);
}
else
{
// NOTE: we normailize a null parameter array to be the same as an empty (i.e. Length == 0) parameter array
normalizedParameterCountKeyPart = "0";
}
// NOTE: we always normalize to all uppercase since method names are case insensitive and could theoretically come in diff. variations per call
string normalizedMethodName = method.ToUpperInvariant();
string methodKey = hub.Name + "::" + normalizedMethodName + "(" + normalizedParameterCountKeyPart + ")";
return methodKey;
}
private Parameter(String id, String description, IParameterValue value)
{
bool isOK = ((value != null) && (isValidId(id)) &&
(description != null));
if (isOK)
{
this.id = id;
this.name = "";
this.description = description;
this.value = value;
}
else
{
throw new ArgumentException("Arguments 'id', 'description' and " +
"'value' must be not null.\n" +
"Argument 'id' must have a length between " +
"1 and 60 characters and must consist " +
"the characters 0-9a-zA-Z only.\n" +
"Argument 'value' must be a valid IParameterValue.");
}
}
public bool Equals(IParameterValue other)
{
return(this.Equals((object)other));
}
public static Parameter create(String id, String description, IParameterValue value)
{
return(new Parameter(id, description, value));
}
public void AssignParameterValue(IParameter parameter, IParameterValue value)
{
_currentParameters[parameter] = value;
}
public List <IRule> GetRules(IParameterValue value)
{
List <int> ids = _paramObject.GetRulesIds(value.GetValue());
return(RulesPool.GetRules(ids));
}
public bool InRange(IParameterValue value)
{
var valueTyped = value as DoubleParameterValue;
return(this._options.Min <= valueTyped.Value && valueTyped.Value <= this._options.Max);
}
public SingleRecordDatabaseCellViewModel(int columnIndex, DatabaseColumnJson columnDefinition, DatabaseEntityViewModel parent, DatabaseEntity parentEntity, IDatabaseField tableField, IParameterValue parameterValue) : base(parentEntity)
{
ColumnIndex = columnIndex * 2;
CanBeNull = columnDefinition.CanBeNull;
IsReadOnly = columnDefinition.IsReadOnly;
ColumnName = columnDefinition.Name;
Parent = parent;
TableField = tableField;
ParameterValue = parameterValue;
if (UseItemPicker)
{
AutoDispose(ParameterValue.ToObservable().Subscribe(_ => RaisePropertyChanged(nameof(OptionValue))));
}
if (UseFlagsPicker)
{
AutoDispose(ParameterValue.ToObservable().Subscribe(_ => RaisePropertyChanged(nameof(AsLongValue))));
}
OriginalValueTooltip =
tableField.IsModified ? "Original value: " + parameterValue.OriginalString : null;
AutoDispose(parameterValue.ToObservable("Value").Skip(1).SubscribeAction(_ =>
{
Parent.RaiseChanged(this, tableField.FieldName);
OriginalValueTooltip =
tableField.IsModified ? "Original value: " + parameterValue.OriginalString : null;
RaisePropertyChanged(nameof(OriginalValueTooltip));
RaisePropertyChanged(nameof(AsBoolValue));
RaisePropertyChanged(nameof(IsModified));
}));
}
public ParameterValueWithStatus(IParameterValue value, CalculationStatus calculationStatus)
{
Value = value;
CalculationStatus = calculationStatus;
}
public bool InRange(IParameterValue value)
{
var valueTyped = value as LongParameterValue;
return(_args.Min <= valueTyped.Value && valueTyped.Value <= _args.Max);
}
public ParameterCondition(int id)
{
conditionObject = ParameterConditionEntity.GetById(id);
parameter = new ESParameter(conditionObject.parameterId);
value = new ParameterValue(conditionObject.parameterValue);
}
private ResolveNodeBase InnerBuildResolveTree(Type interfaceType, ICollection <Type> discoveredTypes, List <IParameterValue> userDefinedParameters = null)
{
// Factory ?
Func <object> factory;
if (_factories.TryGetValue(interfaceType, out factory))
{
return new FactoryNode
{
InterfaceType = interfaceType,
Factory = factory
}
}
;
// Instance ?
object instance;
if (_instances.TryGetValue(interfaceType, out instance))
{
return new InstanceNode
{
InterfaceType = interfaceType,
Instance = instance
}
}
;
// Implementation ?
Type implementationType;
if (!_implementations.TryGetValue(interfaceType, out implementationType))
{
return(ErrorNode.TypeNotRegistered);
}
ConstructorInfo[] constructorInfos = implementationType.GetConstructors();
// Valid constructor ?
if (constructorInfos.Length == 0 ||
(constructorInfos.Length == 1 && !constructorInfos[0].IsPublic))
{
return(ErrorNode.NoPublicConstructorOrNoConstructor);
}
// Get parameters for each ctor
var constructorAndParameters = constructorInfos.Select(x => new
{
Constructor = x,
Parameters = x.GetParameters()
}).ToList();
// Get first parameterless if any
var parameterless = constructorAndParameters.FirstOrDefault(x => x.Parameters.Length == 0);
if (parameterless != null)
{
return new BuildableNode
{
InterfaceType = interfaceType,
ConstructorInfo = parameterless.Constructor
}
}
;
// Check if every ctor's parameter is registered in container or resolvable, returns first resolvable
foreach (var c in constructorAndParameters)
{
List <ResolveNodeBase> parametersResolvable = new List <ResolveNodeBase>(c.Parameters.Length);
// Try to resolved every parameters
bool ok = true;
foreach (ParameterInfo parameterInfo in c.Parameters)
{
IParameterValue parameterValue = userDefinedParameters?.FirstOrDefault(x => x.Name == parameterInfo.Name);
if (parameterValue != null)
{
ValueNode parameter = new ValueNode
{
InterfaceType = null,
ParameterValue = parameterValue
};
parametersResolvable.Add(parameter);
}
else
{
if (discoveredTypes.Any(x => x == parameterInfo.ParameterType)) // check cyclic dependency
{
ok = false;
break;
}
discoveredTypes.Add(parameterInfo.ParameterType); // add parameter type to discovered type
ResolveNodeBase parameter = InnerBuildResolveTree(parameterInfo.ParameterType, discoveredTypes, userDefinedParameters);
discoveredTypes.Remove(parameterInfo.ParameterType); // remove parameter type from discovered type
if (parameter is ErrorNode) // once an invalid ctor parameter has been found, try next ctor
{
ok = false;
break;
}
parametersResolvable.Add(parameter);
}
}
if (ok)
{
return new BuildableNode
{
InterfaceType = interfaceType,
ConstructorInfo = c.Constructor,
Parameters = parametersResolvable
}
}
;
}
return(ErrorNode.NoResolvableConstructor);
}
#endregion
}
}
/// <summary>
/// パラメータ値を設定します。
/// </summary>
/// <param name="v">パラメータ値</param>
/// <returns>ビルダー</returns>
public Builder AddValue(IParameterValue v)
{
_values.Add(v);
return(this);
}
protected override void Cleanup(FlagComboBox element)
{
element.Closed -= CompletionComboBoxOnClosed;
parameter = null;
}
public bool IsEqual(IParameterValue parameter)
{
var p = parameter as ParameterValue;
return(parameter == null ? false : parameter.GetValue() == value);
}
public static ParameterExpectation Expect(IParameterValue parameter)
{
if (parameter is IParameterValueWithType) return Expect((IParameterValueWithType) parameter);
return Expect(parameter.Name);
}
private static T?GetIfIParameterValueOfT <T>(IParameterValue parameterValue)
where T : struct =>
parameterValue is IParameterValue <T> pvt ? pvt.Value : default(T?);
public ESChoice(int id)
{
_choiceObject = QuestionChoiceEntity.GetById(id); //throw error if null
value = new ParameterValue(_choiceObject.parameterValue);
}
/// <summary>
/// Computes a single-mutation neighborhood (one parameter at a time) for a given configuration. For
/// numeric parameters, samples K mutations (i.e., creates K neighbors based on that parameter).
/// </summary>
/// <param name="parent">Starting configuration.</param>
/// <returns>A set of configurations that each differ from parent in exactly one parameter.</returns>
private ParameterSet[] GetOneMutationNeighborhood(ParameterSet parent)
{
List <ParameterSet> neighbors = new List <ParameterSet>();
SweeperProbabilityUtils spu = new SweeperProbabilityUtils();
for (int i = 0; i < _sweepParameters.Length; i++)
{
// This allows us to query possible values of this parameter.
IValueGenerator sweepParam = _sweepParameters[i];
// This holds the actual value for this parameter, chosen in this parameter set.
IParameterValue pset = parent[sweepParam.Name];
Runtime.Contracts.Assert(pset != null);
DiscreteValueGenerator parameterDiscrete = sweepParam as DiscreteValueGenerator;
if (parameterDiscrete != null)
{
// Create one neighbor for every discrete parameter.
Float[] neighbor = SweeperProbabilityUtils.ParameterSetAsFloatArray(_sweepParameters, parent, false);
int hotIndex = -1;
for (int j = 0; j < parameterDiscrete.Count; j++)
{
if (parameterDiscrete[j].Equals(pset))
{
hotIndex = j;
break;
}
}
Runtime.Contracts.Assert(hotIndex >= 0);
Random r = new Random();
int randomIndex = r.Next(0, parameterDiscrete.Count - 1);
randomIndex += randomIndex >= hotIndex ? 1 : 0;
neighbor[i] = randomIndex;
neighbors.Add(SweeperProbabilityUtils.FloatArrayAsParameterSet(_sweepParameters, neighbor, false));
}
else
{
INumericValueGenerator parameterNumeric = sweepParam as INumericValueGenerator;
Runtime.Contracts.Assert(parameterNumeric != null, "SMAC sweeper can only sweep over discrete and numeric parameters");
// Create k neighbors (typically 4) for every numerical parameter.
for (int j = 0; j < _args.NumNeighborsForNumericalParams; j++)
{
Float[] neigh = SweeperProbabilityUtils.ParameterSetAsFloatArray(_sweepParameters, parent, false);
double newVal = spu.NormalRVs(1, neigh[i], 0.2)[0];
while (newVal <= 0.0 || newVal >= 1.0)
{
newVal = spu.NormalRVs(1, neigh[i], 0.2)[0];
}
neigh[i] = (Float)newVal;
ParameterSet neighbor = SweeperProbabilityUtils.FloatArrayAsParameterSet(_sweepParameters, neigh, false);
neighbors.Add(neighbor);
}
}
}
return(neighbors.ToArray());
}
public void SerializeParameterValue(ISerializer s, ref IParameterValue value)
{
var genericType = value.GetType().GetGenericArguments()[0];
if (value is IParameterValue <bool> )
{
var typedValueParameter = value as IParameterValue <bool>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <bool[]> )
{
var typedValueParameter = value as IParameterValue <bool[]>;
typedValueParameter.Value.Serialize(s);
}
if (value is IParameterValue <byte> )
{
var typedValueParameter = value as IParameterValue <byte>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <byte[]> )
{
var typedValueParameter = value as IParameterValue <byte[]>;
typedValueParameter.Value.Serialize(s);
}
if (value is IParameterValue <Single> )
{
var typedValueParameter = value as IParameterValue <Single>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Single[]> )
{
var typedValueParameter = value as IParameterValue <Single[]>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Double> )
{
var typedValueParameter = value as IParameterValue <Double>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Double[]> )
{
var typedValueParameter = value as IParameterValue <Double[]>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Int16> )
{
var typedValueParameter = value as IParameterValue <Int16>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Int16[]> )
{
var typedValueParameter = value as IParameterValue <Int16>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Int32> )
{
var typedValueParameter = value as IParameterValue <Int32>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Int32[]> )
{
var typedValueParameter = value as IParameterValue <Int32>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <UInt16> )
{
var typedValueParameter = value as IParameterValue <UInt16>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <UInt16[]> )
{
var typedValueParameter = value as IParameterValue <UInt16>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <UInt32> )
{
var typedValueParameter = value as IParameterValue <UInt32>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <UInt32[]> )
{
var typedValueParameter = value as IParameterValue <UInt32>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Float2> )
{
var typedValueParameter = value as IParameterValue <Float2>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Float2[]> )
{
var typedValueParameter = value as IParameterValue <Float2[]>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Float3> )
{
var typedValueParameter = value as IParameterValue <Float3>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Float3[]> )
{
var typedValueParameter = value as IParameterValue <Float3[]>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Float4> )
{
var typedValueParameter = value as IParameterValue <Float4>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Float4[]> )
{
var typedValueParameter = value as IParameterValue <Float4[]>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Vector2> )
{
var typedValueParameter = value as IParameterValue <Vector2>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Vector2[]> )
{
var typedValueParameter = value as IParameterValue <Vector2[]>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Vector3> )
{
var typedValueParameter = value as IParameterValue <Vector3>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Vector3[]> )
{
var typedValueParameter = value as IParameterValue <Vector3[]>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Vector4> )
{
var typedValueParameter = value as IParameterValue <Vector4>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Vector4[]> )
{
var typedValueParameter = value as IParameterValue <Vector4[]>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Matrix4> )
{
var typedValueParameter = value as IParameterValue <Matrix4>;
typedValueParameter.Value.Serialize(s);
}
else if (value is IParameterValue <Matrix4[]> )
{
var typedValueParameter = value as IParameterValue <Matrix4[]>;
typedValueParameter.Value.Serialize(s);
}
else
{
throw new System.Exception("Unhandled IParameterType<ValueType> value type");
}
}
