//computed world-space normal and clipping space depth (depth in range 0, 1)
//where the result will be stored, results will be stored to the first component of the texture
//how many samples will be used for occlusion estimation
public static RenderPass CreateAoc(
TextureBase normalDepth,
TextureBase aoc,
IValueProvider<Matrix4> modelviewprojection,
IValueProvider<Matrix4> modelviewprojection_inv,
IValueProvider<Matrix4> projection,
IValueProvider<Matrix4> projection_inv,
AocParameters parameters)
{
return CreateAoc(
normalDepth,
aoc,
modelviewprojection,
modelviewprojection_inv,
projection,
projection_inv,
ValueProvider.Create (() => parameters.SamplesCount),
ValueProvider.Create (() => parameters.OccMaxDist),
ValueProvider.Create (() => parameters.OccPixmax),
ValueProvider.Create (() => parameters.OccPixmin),
ValueProvider.Create (() => parameters.OccMinSampleRatio),
ValueProvider.Create (() => parameters.OccConstantArea),
ValueProvider.Create (() => parameters.Strength),
ValueProvider.Create (() => parameters.Bias));
}
protected virtual object GetArrayModel( ControllerContext controllerContext, Type modelType, IValueProvider valueProvider, string prefix)
{
List<object> list = GetListModel(controllerContext, modelType, modelType.GetElementType(), valueProvider, prefix);
object[] array = (object[])Array.CreateInstance(modelType.GetElementType(), list.Count);
list.CopyTo(array);
return array;
}
//computed world-space normal and clipping space depth (depth in range 0, 1)
//where the result will be stored, results will be stored to the first component of the texture
//how many samples will be used for occlusion estimation
public static RenderPass CreateAoc(
TextureBase normalDepth,
TextureBase aoc,
IValueProvider<Matrix4> modelviewprojection,
IValueProvider<Matrix4> modelviewprojection_inv,
IValueProvider<Matrix4> projection,
IValueProvider<Matrix4> projection_inv,
IValueProvider<int> samplesCount,
IValueProvider<float> occ_max_dist = null,
IValueProvider<float> occ_pixmax = null,
IValueProvider<float> occ_pixmin = null,
IValueProvider<float> occ_min_sample_ratio = null,
IValueProvider<bool> occ_constant_area = null,
IValueProvider<float> strength = null,
IValueProvider<float> bias = null)
{
var viewport = ValueProvider.Create (() => new Vector2 (aoc.Width, aoc.Height));
// var sampling_pattern = ValueProvider.Create
// (
// () => MathHelper2.RandomVectorSet (256, new Vector2 (1, 1))
// );
var current_pattern = MathHelper2.RandomVectorSet (256, new Vector2 (1, 1));
var sampling_pattern = ValueProvider.Create
(
() => current_pattern
);
var uniformState = new UniformState ();
uniformState.Set ("viewport_size", viewport);
uniformState.Set ("sampling_pattern", sampling_pattern);
uniformState.Set ("sampling_pattern_len", samplesCount);
uniformState.Set ("modelviewprojection_transform", modelviewprojection);
uniformState.Set ("modelviewprojection_inv_transform", modelviewprojection_inv);
uniformState.Set ("projection_transform", projection);
uniformState.Set ("projection_inv_transform", projection_inv);
uniformState.Set ("OCCLUDER_MAX_DISTANCE", occ_max_dist ?? ValueProvider.Create(35.0f));
uniformState.Set ("PROJECTED_OCCLUDER_DISTANCE_MAX_SIZE", occ_pixmax ?? ValueProvider.Create(35.0f));
uniformState.Set ("PROJECTED_OCCLUDER_DISTANCE_MIN_SIZE", occ_pixmin ?? ValueProvider.Create(2.0f));
uniformState.Set ("MINIMAL_SAMPLES_COUNT_RATIO", occ_min_sample_ratio ?? ValueProvider.Create(0.1f));
uniformState.Set ("USE_CONSTANT_OCCLUDER_PROJECTION", occ_constant_area ?? ValueProvider.Create(false));
uniformState.Set ("AOC_STRENGTH", strength ?? ValueProvider.Create(2f));
uniformState.Set ("AOC_BIAS", bias ?? ValueProvider.Create(-0.5f));
return CreateFullscreenQuad (
"aoc", "RenderPassFactory",
viewport, null,
window =>
{
GL.Clear (ClearBufferMask.ColorBufferBit);
GL.Disable (EnableCap.DepthTest);
GL.Disable (EnableCap.Blend);
},
new FramebufferBindingSet{{ "OUT_FragData_aoc", aoc }},
uniformState,
new TextureBindingSet {{ "normaldepth_texture", normalDepth }});
}
public MetricIdFromOperationalDashboardSubtypeValueProvider(ControllerContext controllerContext, IDomainSpecificMetricNodeResolver domainSpecificMetricNodeResolver,
IValueProvider schoolIdValueProvider)
{
this.controllerContext = controllerContext;
this.domainSpecificMetricNodeResolver = domainSpecificMetricNodeResolver;
this.schoolIdValueProvider = schoolIdValueProvider;
}
protected BaseValueGenerator(IValueProvider valueProvider, Func<ITypeGenerator> getTypeGenerator,
Func<IArrayRandomizer> getArrayRandomizer, IUniqueValueGenerator uniqueValueGenerator, IAttributeDecorator attributeDecorator)
{
BaseValueGenerator.Logger.Debug("Entering constructor");
this.ValueProvider = valueProvider;
this.GetTypeGenerator = getTypeGenerator;
this.GetArrayRandomizer = getArrayRandomizer;
this.UniqueValueGenerator = uniqueValueGenerator;
this.AttributeDecorator = attributeDecorator;
this.typeValueGetterDictionary = new Dictionary<Type, GetValueForTypeDelegate>
{
{typeof (EmailAttribute), x => this.ValueProvider.GetEmailAddress()},
{typeof (PrimaryKeyAttribute), this.GetPrimaryKey},
{typeof (string), this.GetString},
{typeof (decimal), this.GetDecimal},
{typeof (int), this.GetInteger},
{typeof (uint), this.GetInteger},
{typeof (long), this.GetLong},
{typeof (ulong), this.GetLong},
{typeof (short), this.GetShort},
{typeof (ushort), this.GetShort},
{typeof (bool), x => this.ValueProvider.GetBoolean()},
{typeof (char), x => this.ValueProvider.GetCharacter()},
{typeof (DateTime), this.GetDateTime},
{typeof (byte), x => this.ValueProvider.GetByte()},
{typeof (double), this.GetDouble},
{typeof (float), this.GetFloat},
{typeof (Guid), this.GetGuid },
};
BaseValueGenerator.Logger.Debug("Exiting constructor");
}
public override bool TryGetValueProvider(object target, string name, out IValueProvider provider)
{
provider = default(IValueProvider);
var dictionaryType = default(Type);
foreach (var interfaceType in target.GetType().GetInterfaces()) {
if (interfaceType.IsGenericType &&
interfaceType.GetGenericTypeDefinition() == typeof(IDictionary<,>) &&
interfaceType.GetGenericArguments()[0] == typeof(string)) {
dictionaryType = interfaceType;
break;
}
}
if (dictionaryType != null) {
var containsKeyMethod = dictionaryType.GetMethod("ContainsKey");
if ((bool)containsKeyMethod.Invoke(target, new object[] { name })) {
provider = new GenericDictionaryValueProvider(target, name, dictionaryType);
}
}
return provider != null;
}
public override QuestionResult GetResult(IValueProvider provider)
{
int value = 0;
TryGetValue(provider, ResultName, out value);
return new QuestionResult { Answer = value.ToString(), Value = 0};
}
/*
/// <summary>
/// given color and depth textures, render them.
/// </summary>
public static RenderPass CreateSolidSphere
(
TextureBase normal_depth_target,
TextureBase uv_colorindex_target,
TextureBase depth_texture,
BufferObject<Vector4> sprite_pos_buffer,
BufferObject<Vector4> sprite_color_buffer,
BufferObject<Vector4> sprite_dimensions_buffer,
IValueProvider<int> particles_count,
IValueProvider<float> particle_scale_factor,
ModelViewProjectionParameters mvp,
UniformState subroutineMapping,
IEnumerable<Shader> subroutines
)
{
var viewport = ValueProvider.Create (() => new Vector2 (depth_texture.Width, depth_texture.Height));
var mode = ValueProvider.Create (() => 0);
return CreateSolidSphere
(
new FramebufferBindingSet(
new DrawFramebufferBinding { Attachment = FramebufferAttachment.DepthAttachment, Texture = depth_texture },
new DrawFramebufferBinding { VariableName = "Fragdata.uv_colorindex_none", Texture = uv_colorindex_target },
new DrawFramebufferBinding { VariableName = "Fragdata.normal_depth", Texture = normal_depth_target }
),
sprite_pos_buffer, sprite_color_buffer, sprite_dimensions_buffer,
viewport,
particles_count, particle_scale_factor, mode,
mvp,
subroutineMapping,
subroutines
);
}*/
/// <summary>
/// given color and depth textures, render them.
/// </summary>
public static RenderPass CreateSolidSphere(
TextureBase normal_depth_target,
TextureBase uv_colorindex_target,
TextureBase depth_texture,
BufferObject<Vector4> sprite_pos_buffer,
BufferObject<Vector4> sprite_color_buffer,
BufferObject<Vector4> sprite_dimensions_buffer,
IValueProvider<int> particles_count,
IValueProvider<float> particle_scale_factor,
ModelViewProjectionParameters mvp
)
{
var viewport = ValueProvider.Create (() => new Vector2 (depth_texture.Width, depth_texture.Height));
var fragdepthroutine = ValueProvider.Create (() => "FragDepthDefault");
var outputroutine = ValueProvider.Create (() => "SetOutputsDefault");
return CreateSolidSphere
(
new FramebufferBindingSet(
new DrawFramebufferBinding { Attachment = FramebufferAttachment.DepthAttachment, Texture = depth_texture },
new DrawFramebufferBinding { VariableName = "uv_colorindex_none", Texture = uv_colorindex_target },
new DrawFramebufferBinding { VariableName = "normal_depth", Texture = normal_depth_target }
),
sprite_pos_buffer, sprite_color_buffer, sprite_dimensions_buffer,
viewport,
particles_count, particle_scale_factor, fragdepthroutine, outputroutine,
mvp,
null,
null
);
}
public OverrideValueProvider(IValueProvider originalValueProvider, IDictionary<string, string> values)
{
OriginalValueProvider = originalValueProvider;
HardcodedValues = values.ToDictionary(
x => x.Key,
x => new ValueProviderResult(x.Value, x.Value, System.Globalization.CultureInfo.InvariantCulture));
}
/// <summary>
/// given color and depth textures, render them.
/// </summary>
public static RenderPass CreateRenderTextureToBuffer(
TextureBase source,
TextureBase depth_source,
IValueProvider<Vector2> viewportSize,
Action<GameWindow> beforeState,
Action<GameWindow> beforeRender,
params StatePart[] stateParts
)
{
//TODO: BUG see System21.State.cs: line 351. Order of states has also some influence
var states = new StatePart[]{
new TextureBindingSet
(
new TextureBinding { VariableName = "source_texture", Texture = source },
new TextureBinding { VariableName = "depth_texture", Texture = depth_source }
)
};
states = stateParts.Concat(states).ToArray();
return CreateFullscreenQuad
(
"rendertexture", "RenderPassFactory",
viewportSize,
beforeState,
beforeRender,
states);
}
public dynamic Bind(dynamic formShape, IValueProvider valueProvider, string prefix = "")
{
Action<object> process = shape => BindValue(shape, valueProvider, prefix);
FormNodesProcessor.ProcessForm(formShape, process);
return formShape;
}
public virtual System.Object eval(IValueProvider provider, System.Object corr)
{
System.Object oLhs = lhs_.eval(provider, corr);
System.Object oRhs = rhs_.eval(provider, corr);
return eval(oLhs, oRhs);
}
private bool QuestionSelected(IValueProvider provider, int idx)
{
var valResult = provider.GetValue(ResultName(idx));
return ((valResult != null)
&& !string.IsNullOrEmpty(valResult.AttemptedValue)
&& valResult.AttemptedValue.Contains("true"));
}
/// <summary>
/// given color and depth textures, render them.
/// </summary>
public static RenderPass CreateSolidBox(
TextureBase depth_texture,
BufferObject<Vector4> sprite_pos_buffer,
BufferObject<Vector4> sprite_color_buffer,
BufferObject<Vector4> sprite_dimensions_buffer,
BufferObject<Matrix4> sprite_rotation_local_buffer,
BufferObject<Matrix4> sprite_rotation_buffer,
IValueProvider<int> particles_count,
IValueProvider<float> particle_scale_factor,
IValueProvider<string> fragdepthroutine,
ModelViewProjectionParameters mvp
)
{
var viewport = ValueProvider.Create (() => new Vector2 (depth_texture.Width, depth_texture.Height));
var outputroutine = ValueProvider.Create (() => "SetOutputsNone");
return CreateSolidBox
(
new FramebufferBindingSet(
new DrawFramebufferBinding { Attachment = FramebufferAttachment.DepthAttachment, Texture = depth_texture }
),
sprite_pos_buffer, sprite_color_buffer, sprite_dimensions_buffer, sprite_rotation_local_buffer, sprite_rotation_buffer,
viewport,
particles_count, particle_scale_factor, fragdepthroutine, outputroutine,
mvp,
null,
null
);
}
private ODataQueryCriteria Desrialize(IValueProvider values)
{
var criteria = new ODataQueryCriteria();
var orderBy = values.GetValue("$orderby");
if (orderBy != null)
{
criteria.OrderBy = orderBy.AttemptedValue;
}
var filter = values.GetValue("$filter");
if (filter != null)
{
criteria.Filter = filter.AttemptedValue;
}
ParsePagingInfo(values, criteria);
var expand = values.GetValue("$expand");
if (expand != null)
{
criteria.Expand = expand.AttemptedValue;
}
return criteria;
}
public SchoolIdValueProvider(ControllerContext controllerContext, IRouteValueResolutionService schoolRouteValueResolutionService,
IValueProvider localEducationAgencyIdValueProvider)
{
this.controllerContext = controllerContext;
this.schoolRouteValueResolutionService = schoolRouteValueResolutionService;
this.localEducationAgencyIdValueProvider = localEducationAgencyIdValueProvider;
}
public object GetModel(ControllerContext controllerContext, Type modelType, IValueProvider valueProvider, string key)
{
if (!valueProvider.ContainsPrefix(key))
{
return null;
}
ModelMetadata modelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, modelType);
if (!modelMetadata.IsComplexType)
{
return valueProvider.GetValue(key).ConvertTo(modelType);
}
if (modelType.IsArray)
{
return GetArrayModel(controllerContext, modelType, valueProvider,key);
}
Type enumerableType = ExtractGenericInterface(modelType, typeof(IEnumerable<>));
if (null != enumerableType)
{
return GetCollectionModel(controllerContext, modelType, valueProvider, key);
}
if (modelMetadata.IsComplexType)
{
return GetComplexModel(controllerContext, modelType, valueProvider, key);
}
return null;
}
public void Merge(IValueProvider valueProvider)
{
if (valueProvider.CanMerge)
{
valueProvider.Values.ToList().ForEach(x => Values.Add(x));
}
}
/// <summary>
/// Validation function for WrapNumericModelValidator.
/// </summary>
/// <param name="container"></param>
/// <param name="conditionPropertyName"></param>
/// <param name="validateIfNot"></param>
/// <param name="propertyName"></param>
/// <param name="containerName"></param>
/// <param name="valueProvider"></param>
/// <param name="modelState"></param>
/// <param name="baseFunction"></param>
/// <returns></returns>
internal static IEnumerable<ModelValidationResult> CValidate(object container, string conditionPropertyName, bool validateIfNot, string propertyName, string containerName, IValueProvider valueProvider, ModelStateDictionary modelState, Func<object, IEnumerable<ModelValidationResult>> baseFunction)
{
// default to regular behavior if we don't have model.
if (container == null)
{
return baseFunction(container);
}
var property = container.GetType().GetProperty(propertyName);
var shouldValidate = ShouldValidate(conditionPropertyName, validateIfNot, propertyName, containerName, container, property, valueProvider, modelState);
if (shouldValidate == null)
{
// value for condition property is not supplied.
return new ModelValidationResult[]
{
new ModelValidationResult()
{
Message = PropertyNotFound(conditionPropertyName)
}
};
}
else if (shouldValidate.Value)
{
return baseFunction(container);
}
else
{
return Enumerable.Empty<ModelValidationResult>();
}
}
protected virtual object GetDictionaryModel(ControllerContext controllerContext, Type modelType, IValueProvider valueProvider, string prefix)
{
List<KeyValuePair<object, object>> list = new List<KeyValuePair<object, object>>();
bool numericIndex;
IEnumerable<string> indexes = GetIndexes(prefix, valueProvider, out numericIndex);
Type[] genericArguments = modelType.GetGenericArguments();
Type keyType = genericArguments[0];
Type valueType = genericArguments[1];
foreach (var index in indexes)
{
string indexPrefix = prefix + "[" + index + "]";
if (!valueProvider.ContainsPrefix(indexPrefix) && numericIndex)
{
break;
}
string keyPrefix = indexPrefix + ".Key";
string valulePrefix = indexPrefix + ".Value";
object key = GetModel(controllerContext, keyType,
valueProvider, keyPrefix);
object value = GetModel(controllerContext, valueType,
valueProvider, valulePrefix);
list.Add(new KeyValuePair<object, object>(key, value));
}
object model = CreateModel(modelType);
ReplaceHelper.ReplaceDictionary(keyType, valueType, model, list);
return model;
}
public virtual System.Object eval(IValueProvider provider, System.Object corr)
{
System.Object oLhs = lhs_.eval(provider, corr);
if (!(oLhs is System.String))
return Result.RESULT_UNKNOWN;
return (rhs_.Contains(oLhs))?Result.RESULT_TRUE:Result.RESULT_FALSE;
}
public IValueProvider Handle(IValueProvider provider, Parameter parameter, ParameterValue parameterValue)
{
if (parameter.Translator == SerializeStringToValueTranslatorProvider.ProviderKey)
{
return new EagerLoadValueProviderDecorator(provider,_settings);
}
return provider;
}
protected virtual object GetCollectionModel(ControllerContext controllerContext, Type modelType,IValueProvider valueProvider, string prefix)
{
Type elementType = modelType.GetGenericArguments()[0];
List<object> list = GetListModel(controllerContext, modelType, elementType, valueProvider, prefix);
object model = CreateModel(modelType);
ReplaceHelper.ReplaceCollection(elementType, model, list);
return model;
}
public static QueriableItem Create(IValueProvider valueProvider, IFilterCondition[] conditions)
{
return new QueriableItem
{
Conditions = conditions,
ValueProvider = valueProvider
};
}
public static EntityRecord CreateRecord(
this Entity entity,
IValueProvider valueProvider,
HttpFileCollectionBase files,
Func<Property, object> defaultValueResolver = null)
{
return EntityRecordCreator.CreateRecord(entity, valueProvider, files, defaultValueResolver);
}
/// <summary> Evaluate the expression.</summary>
/// <param name="provider">Value provider. During the evaluation of the selector a callback
/// is made to the value provider to get identifier values.
/// </param>
/// <param name="corr">Correlation data. This data is as-is passed to the provider.
/// </param>
/// <returns> Returns the result of the expression evaluation.
/// </returns>
public virtual System.Object eval(IValueProvider provider, System.Object corr)
{
System.Object oVal = val_.eval(provider, corr);
System.Object oLower = lower_.eval(provider, corr);
System.Object oUpper = lower_.eval(provider, corr);
return eval(oVal, oLower, oUpper);
}
public GenericDataValueProvider(System.Reflection.MemberInfo member, IValueProvider inner, IEnumerable<string> sensitiveProperties)
{
if (member == null) throw new ArgumentNullException("member");
if (inner == null) throw new ArgumentNullException("inner");
Member = member;
Inner = inner;
SensitiveProperties = sensitiveProperties?.Select(p => p.ToLowerInvariant());
}
public object GetModel(ControllerContext controllerContext, Type modelType, IValueProvider valueProvider, string key)
{
if (!valueProvider.ContainsPrefix(key))
{
return null;
}
return valueProvider.GetValue(key).ConvertTo(modelType);
}
public override QuestionResult GetResult(IValueProvider provider)
{
string answer;
if (!(TryGetValue(provider, ResultName, out answer) && !string.IsNullOrEmpty(answer)))
answer = null;
return new QuestionResult { Answer = answer, Value = 0 };
}
public OverrideValueProvider(string name, IValueProvider first, IValueProvider second, IValueProvider third = null, IValueProvider fourth = null)
{
Name = name;
Providers.Add(first);
Providers.Add(second);
if(third != null) Providers.Add(third);
if(fourth != null) Providers.Add(fourth);
}
private IValuable <G> Or(IValue <G, bool> booleanValue, IValueProvider <G> valueProvider)
{
return(valueProvider.GetBoolean(Data | booleanValue.Data));
}
private IValuable <G> IsLessThanOrEqualTo(int value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetBoolean(Data <= value));
}
public IValuable <G> Or(IValuable <G> value, IValueProvider <G> valueProvider)
{
throw new EngineRuntimeException("Invalid values for or");
}
private IValuable <G> Add(string value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetString(Data + value));
}
public void Execute(ExecutionState <G> executionState, IValueProvider <G> valueProvider)
{
throw new EngineRuntimeException("Value is not executable");
}
public EmptyDictionaryValueProvider(IValueProvider innerProvider)
{
_innerProvider = innerProvider;
_defaultValue = new Dictionary <string, object>();
}
public EmptyListValueProvider(IValueProvider innerProvider, Type elementType)
{
_innerProvider = innerProvider;
_defaultValue = Array.CreateInstance(elementType, 0);
}
private IValuable <G> IsNotEqualTo(IValue <G, bool> booleanValue, IValueProvider <G> valueProvider)
{
return(valueProvider.GetBoolean(Data != booleanValue.Data));
}
private IValuable <G> IsLessThan(long value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetBoolean(Data < value));
}
private IValuable <G> Add(IValue <G, string> stringValue, IValueProvider <G> valueProvider)
{
return(valueProvider.GetString(Data.ToString().ToLower() + stringValue.Data));
}
public LongValueProvider(IEncryptedConverter <long> encryptedConverter, IValueProvider innerProvider)
: base(encryptedConverter, innerProvider)
{
}
private IValuable <G> IsGreaterThan(double value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetBoolean(Data > value));
}
private IValuable <G> Remainder(long value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetReducedValue(Data % value));
}
private IValuable <G> DivideBy(double value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetReducedValue(Data / value));
}
private IValuable <G> IsGreaterThanOrEqualTo(long value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetBoolean(Data >= value));
}
private IValuable <G> MultiplyBy(long value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetReducedValue(Data * value));
}
public void SetText(int textKeyId, IValueProvider valueProvider = null)
{
m_textKeyId = textKeyId;
m_valueProvider = valueProvider;
RefreshText();
}
public ValuePointer <G> GetAt(IValuable <G> value, IValueProvider <G> valueProvider)
{
throw new EngineRuntimeException("Value is not indexed");
}
public DataModifier(IRaftCluster cluster, IValueProvider provider)
{
this.cluster = cluster;
valueProvider = provider;
}
private IValuable <G> Add(long value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetReducedValue(Data + value));
}
public override Task <bool> TryUpdateModelAsync <TModel>(TModel model, string prefix, IValueProvider valueProvider)
{
return(base.TryUpdateModelAsync(model, prefix, valueProvider));
}
public ValuePointer <G> Get(IValuable <G> value, bool createNonExistent, IValueProvider <G> valueProvider)
{
throw new EngineRuntimeException("Value is not keyed");
}
/// <summary>
/// Replaces the format item in a specified <see cref="String" /> with the values from the given value provider.
/// </summary>
/// <exception cref="ArgumentNullException">The format string can not be null.</exception>
/// <exception cref="FormatException">Format is invalid, or value provider failed to provide a value.</exception>
/// <param name="format">The <see cref="String" /> containing the format items.</param>
/// <param name="valueProvider">A value provider.</param>
/// <returns>
/// A copy of format in which the format items have been replaced by the <see cref="String"></see> representation
/// of the corresponding objects from the value provider.
/// </returns>
private static String FormatWithValueProvider(this String format, IValueProvider valueProvider)
{
format.ThrowIfNull(nameof(format));
var result = new StringBuilder(format.Length * 2);
using (var reader = new StringReader(format))
{
var expression = new StringBuilder();
Int32 currentChar;
var currentState = StringFormatState.OutsideExpression;
do
{
// ReSharper disable once SwitchStatementMissingSomeCases
switch (currentState)
{
case StringFormatState.OutsideExpression:
// We are not in a expression => normal string literal
currentChar = reader.Read();
switch (currentChar)
{
case -1:
// End of string reached
currentState = StringFormatState.End;
break;
case BracketOpen:
// Start of new expression (or an escaped open bracket)
currentState = StringFormatState.OnOpenBracket;
break;
case BracketClose:
// Close bracket => must be escaped with the next character
currentState = StringFormatState.OnCloseBracket;
break;
default:
// Normal string content
result.Append((Char)currentChar);
break;
}
break;
case StringFormatState.OnOpenBracket:
// Last character was an open bracket (only one bracket; yet)
currentChar = reader.Read();
switch (currentChar)
{
case -1:
// End of string => unescaped bracket without a valid expression
throw new FormatException($"Invalid format, format ends with an unescaped open bracket; '{format}'.");
case BracketOpen:
// Must be an escaped open bracket
result.Append(BracketOpen);
currentState = StringFormatState.OutsideExpression;
break;
default:
// Part of expression
expression.Append((Char)currentChar);
currentState = StringFormatState.InsideExpression;
break;
}
break;
case StringFormatState.InsideExpression:
// We are inside of an expression
currentChar = reader.Read();
switch (currentChar)
{
case -1:
// End of string => unclosed expression
throw new FormatException($"Invalid format, format ends with an unclosed expression; '{format}'.");
case BracketClose:
// End of expression
result.Append(valueProvider.GetValue(expression.ToString()));
expression.Length = 0;
currentState = StringFormatState.OutsideExpression;
break;
default:
// Part of expression
expression.Append((Char)currentChar);
break;
}
break;
case StringFormatState.OnCloseBracket:
// Last character was a close bracket
currentChar = reader.Read();
switch (currentChar)
{
case BracketClose:
// Must be an escaped close bracket
result.Append(BracketClose);
currentState = StringFormatState.OutsideExpression;
break;
default:
throw new FormatException(BuildErrorMessageCloseNotEscaped(format, reader));
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(currentState), currentState, $"Invalid state: '{format}'.");
}
} while (currentState != StringFormatState.End);
}
return(result.ToString());
}
public StringProvider(MemberInfo memberInfo, Type underlyingType)
{
_underlyingValueProvider = new DynamicValueProvider(memberInfo);
}
private IValuable <G> Minus(double value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetReducedValue(Data - value));
}
public IValuable <G> RightShift(IValuable <G> value, IValueProvider <G> valueProvider)
{
throw new EngineRuntimeException("Invalid values for right shift");
}
public NullableValueProvider(MemberInfo memberInfo, Type underlyingType)
{
_underlyingValueProvider = new DynamicValueProvider(memberInfo);
_defaultValue = Activator.CreateInstance(underlyingType);
}
private IValuable <G> IsNotEqualTo(int value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetBoolean(Data != value));
}
private IValuable <G> IsEqualTo(long value, IValueProvider <G> valueProvider)
{
return(valueProvider.GetBoolean(Data == value));
}
public IValuable <G> Not(IValueProvider <G> valueProvider)
{
throw new EngineRuntimeException("Invalid value for negation");
}
