public static T GetValue <T>(this DataRow dataRow, string name, T outputNullValue)
{
Assert.IsNotNull(dataRow, nameof(dataRow));
var valueObject = dataRow[name];
return(ValueReader.GetValue(valueObject, outputNullValue));
}
public static T GetValueOrDefault <T>(this DataRow dataRow, int columnIndex)
{
Assert.IsNotNull(dataRow, nameof(dataRow));
var value = dataRow[columnIndex];
return(ValueReader.GetValueOrDefault <T>(value));
}
/// <summary>
/// Pulls all event types for a group
/// </summary>
/// <param name="eventGroupKey">Group to pull</param>
public static IQueryable <EventType> GetByEventGroup(Guid eventGroupKey)
{
var reader = new ValueReader <EventType>();
return(reader.GetByWhere(x => x.EventGroupKey == eventGroupKey ||
x.Key == Defaults.Guid).OrderBy(y => y.Name));
}
public ObjectSerializer(Type type)
{
if (type == null)
throw new ArgumentNullException(nameof(type));
Type = type;
var typeName = type.GetShortAssemblyQualifiedName();
// ReSharper disable once PossibleNullReferenceException
// ReSharper disable once AssignNullToNotNullAttribute
var typeNameBytes = Encoding.UTF8.GetBytes(typeName);
//precalculate the entire manifest for this serializer
//this helps us to minimize calls to Stream.Write/WriteByte
_manifest =
new[] {ManifestFull}
.Concat(BitConverter.GetBytes(typeNameBytes.Length))
.Concat(typeNameBytes)
.ToArray(); //serializer id 255 + assembly qualified name
//initialize reader and writer with dummy handlers that wait until the serializer is fully initialized
_writer = (stream, o, session) =>
{
SpinWait.SpinUntil(() => _isInitialized);
WriteValue(stream, o, session);
};
_reader = (stream, session) =>
{
SpinWait.SpinUntil(() => _isInitialized);
return ReadValue(stream, session);
};
}
public static ValueReader <T> ReadValue <T>(this IEnumerable <T> source, out T value)
{
var result = new ValueReader <T>(source);
result.ReadValue(out value);
return(result);
}
public static T GetValueOrDefault <T>(this DataRow dataRow, string name)
{
Assert.IsNotNull(dataRow, nameof(dataRow));
var value = dataRow[name];
return(ValueReader.GetValueOrDefault <T>(value));
}
public ReadResult Read(string treeName, Slice key, WriteBatch writeBatch = null)
{
Tree tree = null;
if (writeBatch != null && writeBatch.IsEmpty == false)
{
WriteBatch.InBatchValue result;
if (writeBatch.TryGetValue(treeName, key, out result))
{
if (!result.Version.HasValue)
{
tree = GetTree(treeName);
}
switch (result.OperationType)
{
case WriteBatch.BatchOperationType.Add:
{
var reader = new ValueReader(result.Stream);
return(new ReadResult(reader, result.Version.HasValue ? (ushort)(result.Version.Value + 1) : tree.ReadVersion(key)));
}
case WriteBatch.BatchOperationType.Delete:
return(null);
}
}
}
if (tree == null)
{
tree = GetTree(treeName);
}
return(tree.Read(key));
}
public override decimal Read(Reader reader, int tag)
{
var stream = reader.Stream;
if (tag >= '0' && tag <= '9')
{
return(tag - '0');
}
switch (tag)
{
case TagInteger:
case TagLong:
return(ValueReader.ReadIntAsDecimal(stream));
case TagDouble:
return(ValueReader.ReadDecimal(stream));
case TagTrue:
return(1);
case TagFalse:
case TagEmpty:
return(0);
case TagUTF8Char:
return(Converter <decimal> .Convert(ValueReader.ReadUTF8Char(stream)));
case TagString:
return(Converter <decimal> .Convert(ReferenceReader.ReadString(reader)));
default:
return(base.Read(reader, tag));
}
}
private async Task HandleContextAsync(HttpListenerContext listenerContext)
{
//request handling
using (_processingTimer.NewContext())
{
var time = ValueReader.GetCurrentValue(_processingTimer)
.Scale(TimeUnit.Milliseconds, TimeUnit.Milliseconds)
.Histogram.Percentile95;
if (time < _acceptableTimeOfService)
{
string paramString = listenerContext.Request.RawUrl;
if (listenerContext.Request.HttpMethod == "POST")
{
if (paramString.StartsWith("/process/"))
{
var result = ProcessImage(listenerContext);
using (var writer = new BinaryWriter(result.Item1.Response.OutputStream))
writer.Write(result.Item2);
return;
}
}
listenerContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
using (var writer = new StreamWriter(listenerContext.Response.OutputStream))
await writer.WriteLineAsync();
}
else
{
listenerContext.Response.StatusCode = (int)HttpStatusCode.ServiceUnavailable;
using (var writer = new StreamWriter(listenerContext.Response.OutputStream))
await writer.WriteLineAsync();
}
}
}
private static T Read(Reader reader)
{
Stream stream = reader.Stream;
int index = ValueReader.ReadInt(stream, TagOpenbrace);
return(Read(reader, reader.GetTypeInfo(index).key));
}
private object Read(Reader reader)
{
Stream stream = reader.Stream;
int index = ValueReader.ReadInt(stream, TagOpenbrace);
var typeInfo = reader.GetTypeInfo(index);
var type = typeInfo.type;
if (type != null)
{
return(((IObjectDeserializer)GetInstance(type)).ReadObject(reader, typeInfo.key));
}
var obj = new ExpandoObject();
reader.AddReference(obj);
var dict = (IDictionary <string, object>)obj;
string[] names = typeInfo.names;
int count = names.Length;
for (int i = 0; i < count; ++i)
{
dict.Add(Accessor.TitleCaseName(names[i]), Deserialize(reader));
}
stream.ReadByte();
return(obj);
}
public static T GetValueOrDefault <T>(this DataRow dataRow, string name)
{
ArgumentNullException.ThrowIfNull(dataRow, nameof(dataRow));
var value = dataRow[name];
return(ValueReader.GetValueOrDefault <T>(value));
}
public override ValueSerializer BuildSerializer(Serializer serializer, Type type,
ConcurrentDictionary <Type, ValueSerializer> typeMapping)
{
var x = new ObjectSerializer(type);
typeMapping.TryAdd(type, x);
var elementType = GetEnumerableType(type);
var arrType = elementType.MakeArrayType();
var listModule = type.Assembly.GetType("Microsoft.FSharp.Collections.ListModule");
var ofArray = listModule.GetMethod("OfArray");
var ofArrayConcrete = ofArray.MakeGenericMethod(elementType);
var ofArrayCompiled = CodeGenerator.CompileToDelegate(ofArrayConcrete, arrType);
var toArray = listModule.GetMethod("ToArray");
var toArrayConcrete = toArray.MakeGenericMethod(elementType);
var toArrayCompiled = CodeGenerator.CompileToDelegate(toArrayConcrete, type);
ValueWriter writer = (stream, o, session) =>
{
var arr = toArrayCompiled(o);
var arrSerializer = serializer.GetSerializerByType(arrType);
arrSerializer.WriteValue(stream, arr, session);
};
ValueReader reader = (stream, session) =>
{
var arrSerializer = serializer.GetSerializerByType(arrType);
var items = (Array)arrSerializer.ReadValue(stream, session);
var res = ofArrayCompiled(items);
return(res);
};
x.Initialize(reader, writer);
return(x);
}
public static T GetValue <T>(this DataRow dataRow, string name, T outputNullValue)
{
ArgumentNullException.ThrowIfNull(dataRow, nameof(dataRow));
var valueObject = dataRow[name];
return(ValueReader.GetValue(valueObject, outputNullValue));
}
public static T GetValueOrDefault <T>(this DataRow dataRow, int columnIndex)
{
ArgumentNullException.ThrowIfNull(dataRow, nameof(dataRow));
var value = dataRow[columnIndex];
return(ValueReader.GetValueOrDefault <T>(value));
}
public override T Read(Reader reader, int tag)
{
var stream = reader.Stream;
switch (tag)
{
case TagBytes:
return(Converter <T> .Convert(ReferenceReader.ReadBytes(reader)));
case TagEmpty:
return(Converter <T> .Convert(empty));
case TagList:
return(Converter <T> .Convert(ReferenceReader.ReadArray <byte>(reader)));
case TagUTF8Char:
return(Converter <T> .Convert(ValueReader.ReadUTF8Char(stream)));
case TagString:
return(Converter <T> .Convert(ReferenceReader.ReadChars(reader)));
default:
return(base.Read(reader, tag));
}
}
public ObjectSerializer(Type type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
Type = type;
var typeName = type.GetShortAssemblyQualifiedName();
// ReSharper disable once PossibleNullReferenceException
// ReSharper disable once AssignNullToNotNullAttribute
var typeNameBytes = Encoding.UTF8.GetBytes(typeName);
//precalculate the entire manifest for this serializer
//this helps us to minimize calls to Stream.Write/WriteByte
_manifest =
new[] { ManifestFull }
.Concat(BitConverter.GetBytes(typeNameBytes.Length))
.Concat(typeNameBytes)
.ToArray(); //serializer id 255 + assembly qualified name
//initialize reader and writer with dummy handlers that wait until the serializer is fully initialized
_writer = (stream, o, session) =>
{
SpinWait.SpinUntil(() => _isInitialized);
WriteValue(stream, o, session);
};
_reader = (stream, session) =>
{
SpinWait.SpinUntil(() => _isInitialized);
return(ReadValue(stream, session));
};
}
public override bool Read()
{
bool read;
if (_command.Cancelled)
{
read = false;
}
else
{
if (_first)
{
_first = false;
var parameters = _command.Parameters;
var path = ValueReader.GetValueOrDefault <string>(parameters["path"].Value);
var recursionString = ValueReader.GetValueOrDefault <string>(parameters["recursion"].Value);
var recursion = recursionString != null
? Enum <RecursionType> .Parse(recursionString)
: RecursionType.Full;
var workspace = ValueReader.GetValueOrDefault <string>(parameters["workspace"].Value);
var user = ValueReader.GetValueOrDefault <string>(parameters["user"].Value);
_pendingSets = _command.Connection.VersionControlServer.QueryPendingSets(new[] { path }, recursion, workspace, user);
_enumerator = AsEnumerable(_pendingSets).GetEnumerator();
}
var moveNext = _enumerator.MoveNext();
if (moveNext)
{
var pair = _enumerator.Current;
var pendingSet = _pendingSets[pair.Item1];
var pendingChange = pendingSet.PendingChanges[pair.Item2];
var values = new object[]
{
pendingSet.Computer,
pendingSet.Name,
pendingSet.OwnerName,
pendingSet.Type.ToString(),
pendingChange.ChangeType.ToString(),
pendingChange.CreationDate,
pendingChange.FileName,
pendingChange.ItemType.ToString(),
pendingChange.LockLevelName,
pendingChange.ServerItem,
pendingChange.LocalItem
};
Values = values;
read = true;
}
else
{
read = false;
}
}
return(read);
}
public void Data_EntityReader_GetAll()
{
var reader = new ValueReader <CustomerType>();
var typeResults = reader.GetAll().Take(1);
Assert.IsTrue(typeResults.Count() > 0);
}
public void Data_EntityReader_CountAny()
{
var reader = new ValueReader <CustomerType>();
// GetAll() count and any
var resultsAll = reader.GetAll();
Assert.IsTrue(resultsAll.Count() > 0);
Assert.IsTrue(resultsAll.Any());
// GetAll().Take(1) count and any
var resultsTake = reader.GetAll().Take(1);
Assert.IsTrue(resultsTake.Count() == 1);
Assert.IsTrue(resultsTake.Any());
// Get an Id to test
var key = reader.GetAllExcludeDefault().FirstOrDefaultSafe().Key;
Assert.IsTrue(key != TypeExtension.DefaultGuid);
// GetAll().Where count and any
var resultsWhere = reader.GetAll().Where(x => x.Key == key);
Assert.IsTrue(resultsWhere.Count() > 0);
Assert.IsTrue(resultsWhere.Any());
}
public override char Read(Reader reader, int tag)
{
var stream = reader.Stream;
switch (tag)
{
case TagUTF8Char:
return(ValueReader.ReadChar(stream));
case TagEmpty:
return('\0');
case TagInteger:
return((char)ValueReader.ReadInt(stream));
case TagLong:
return((char)ValueReader.ReadLong(stream));
case TagDouble:
return((char)ValueReader.ReadDouble(stream));
case TagString:
return(Converter <char> .Convert(ReferenceReader.ReadString(reader)));
default:
if (tag >= '0' && tag <= '9')
{
return((char)(tag - '0'));
}
return(base.Read(reader, tag));
}
}
/// <summary>
/// Helper method used to build a <see cref="TrackingWorkflowInstance" />
/// from the specified <see cref="IDataRecord" />.
/// </summary>
/// <param name="dataRecord">
/// An <see cref="IDataRecord" />.
/// </param>
/// <returns>
/// An instance of <see cref="TrackingWorkflowInstance" />.
/// </returns>
private TrackingWorkflowInstance buildTrackingWorkflowInstance(IDataRecord dataRecord, TrackingCommandName commandName)
{
String assemblyName = ValueReader.GetString(dataRecord,
_nameResolver.ResolveParameterName(commandName,
TrackingParameterName.AssemblyFullName));
String typeName = ValueReader.GetString(dataRecord,
_nameResolver.ResolveParameterName(commandName,
TrackingParameterName.TypeFullName));
return(new TrackingWorkflowInstance(
WorkflowInstanceHelper.DeserialiseActivity(ValueReader.GetString(
dataRecord, _nameResolver.ResolveParameterName(commandName,
TrackingParameterName.ActivityXoml))),
ValueReader.GetGuid(dataRecord, _nameResolver.ResolveParameterName(
commandName, TrackingParameterName.InstanceId)),
ValueReader.GetDateTime(dataRecord, _nameResolver.ResolveParameterName(
commandName, TrackingParameterName.InitialisedDateTime)),
ValueReader.GetValue(dataRecord, _nameResolver.ResolveParameterName(
commandName, TrackingParameterName.WorkflowInstanceId)),
ValueReader.GetGuid(dataRecord, _nameResolver.ResolveParameterName(
commandName, TrackingParameterName.CallerInstanceId)),
ValueReader.GetEnum <WorkflowStatus>(dataRecord,
_nameResolver.ResolveParameterName(commandName,
TrackingParameterName.WorkflowInstanceStatusId)),
Type.GetType(String.Format("{0}, {1}", assemblyName, typeName), false)));
}
public ReadResult Read(string treeName, Slice key, WriteBatch writeBatch = null)
{
Tree tree = null;
if (writeBatch != null)
{
WriteBatch.BatchOperationType operationType;
Stream stream;
ushort? version;
if (writeBatch.TryGetValue(treeName, key, out stream, out version, out operationType))
{
if (!version.HasValue)
tree = GetTree(treeName);
switch (operationType)
{
case WriteBatch.BatchOperationType.Add:
{
var reader = new ValueReader(stream);
return new ReadResult(reader, version.HasValue ? (ushort)(version.Value + 1) : tree.ReadVersion(key));
}
case WriteBatch.BatchOperationType.Delete:
return null;
}
}
}
if (tree == null)
tree = GetTree(treeName);
return tree.Read(key);
}
private static IDeserializer[] ReadObjectAsFirstRow(Reader reader, DataTable table)
{
var columns = table.Columns;
var row = table.NewRow();
reader.AddReference(row);
var stream = reader.Stream;
int index = ValueReader.ReadInt(stream, TagOpenbrace);
TypeInfo typeInfo = reader.GetTypeInfo(index);
table.TableName = typeInfo.name;
var names = typeInfo.names;
var deserializer = Deserializer.Instance;
var count = names.Length;
IDeserializer[] deserializers = new IDeserializer[count];
if (typeInfo.type != null)
{
var members = Accessor.GetMembers(typeInfo.type, reader.Mode);
for (int i = 0; i < count; ++i)
{
var name = names[i];
var member = members[name];
if (member != null)
{
var type = Accessor.GetMemberType(member);
deserializers[i] = Deserializer.GetInstance(type);
var value = deserializers[i].Deserialize(reader);
var column = new DataColumn(member.Name, type);
columns.Add(column);
row[column] = value ?? DBNull.Value;
}
else
{
var value = deserializer.Deserialize(reader);
var type = value?.GetType() ?? typeof(string);
deserializers[i] = Deserializer.GetInstance(type);
var column = new DataColumn(name, type);
columns.Add(column);
row[column] = value ?? DBNull.Value;
}
}
}
else
{
for (int i = 0; i < count; ++i)
{
var name = names[i];
var value = deserializer.Deserialize(reader);
var type = value?.GetType() ?? typeof(string);
deserializers[i] = Deserializer.GetInstance(type);
var column = new DataColumn(name, type);
columns.Add(column);
row[column] = value ?? DBNull.Value;
}
}
table.Rows.Add(row);
stream.ReadByte();
return(deserializers);
}
private static IDeserializer[] ReadMapAsFirstRow(Reader reader, DataTable table, Deserializer <string> strDeserializer)
{
var columns = table.Columns;
var row = table.NewRow();
reader.AddReference(row);
var stream = reader.Stream;
var deserializer = Deserializer.Instance;
int count = ValueReader.ReadCount(stream);
IDeserializer[] deserializers = new IDeserializer[count];
for (int i = 0; i < count; ++i)
{
var name = strDeserializer.Deserialize(reader);
var value = deserializer.Deserialize(reader);
var type = value?.GetType() ?? typeof(string);
deserializers[i] = Deserializer.GetInstance(type);
var column = new DataColumn(name, type);
columns.Add(column);
row[column] = value ?? DBNull.Value;
}
table.Rows.Add(row);
stream.ReadByte();
return(deserializers);
}
private ValueReader binOpCreate(KinectitudeGrammar.OpCode op, ValueReader left, ValueReader right)
{
switch (op)
{
case KinectitudeGrammar.OpCode.And: return new AndOpReader(left, right);
case KinectitudeGrammar.OpCode.Div: return new DivOpReader(left, right);
case KinectitudeGrammar.OpCode.Eql: return new EqlOpReader(left, right);
case KinectitudeGrammar.OpCode.Ge: return new GeOpReader(left, right);
case KinectitudeGrammar.OpCode.Gt: return new GtOpReader(left, right);
case KinectitudeGrammar.OpCode.Le: return new GeOpReader(right, left);
case KinectitudeGrammar.OpCode.LeftShift: return new LeftShiftOpReader(left, right);
case KinectitudeGrammar.OpCode.Lt: return new GtOpReader(right, left);
case KinectitudeGrammar.OpCode.Minus: return new MinusOpReader(left, right);
case KinectitudeGrammar.OpCode.Mult: return new MultOpReader(left, right);
case KinectitudeGrammar.OpCode.Neq: return new NeqOpReader(left, right);
case KinectitudeGrammar.OpCode.Or: return new OrOpReader(left, right);
case KinectitudeGrammar.OpCode.Plus: return new PlusOpReader(left, right);
case KinectitudeGrammar.OpCode.Pow: return new PowOpReader(left, right);
case KinectitudeGrammar.OpCode.Rem: return new RemOpReader(left, right);
case KinectitudeGrammar.OpCode.RightShift: return new RightShiftOpReader(left, right);
case KinectitudeGrammar.OpCode.Becomes: return right;
default:
Game.CurrentGame.Die("Error with implementation of operator " + op);
return null;
}
}
public static Array ReadArray <K>(JArray jArray, ValueReader <K> reader, Type type)
{
if (jArray == null)
{
return(null);
}
var elemType = type.GetElementType();
var array = Array.CreateInstance(elemType, jArray.Count);
for (int i = 0; i < array.Length; i++)
{
if (elemType.IsArray)
{
array.SetValue(ReadArray <K>(GetJToken <JArray>(jArray[i]), reader, elemType), i);
}
else
{
array.SetValue(reader(jArray[i]), i);
}
}
return(array);
}
public void WrittenValuesCanBeReadBackCorrectly()
{
var values = new[] { 4, 8, 1.5, 1.6, 1.7, 1.7, 2.3, 22.0 / 7.0, 653.2, 653.02 };
var buffer = new BitBuffer();
var writer = new ValueWriter(buffer);
foreach (var value in values)
{
writer.AppendValue(value);
}
var reader = new ValueReader(buffer);
var actual = new List <double>();
while (reader.HasMoreValues)
{
actual.Add(reader.ReadNextValue());
}
actual.Count.Should().Be(values.Length);
for (int i = 0; i < actual.Count; ++i)
{
actual[i].Should().Be(values[i]);
}
}
public static T ExecuteScalarValueOrDefault <T>(this IDbCommand command)
{
ArgumentNullException.ThrowIfNull(command);
var scalar = command.ExecuteScalar();
return(ValueReader.GetValueOrDefault <T>(scalar));
}
public StreamBitArray(ValueReader reader)
{
SetCount = reader.ReadLittleEndianInt32();
for (var i = 0; i < _inner.Length; i++)
{
_inner[i] = reader.ReadLittleEndianInt32();
}
}
public void Core_Data_ValueReader_GetAll()
{
using (var typeDB = new ValueReader <CustomerType>(new ConnectionStringFactory().GetDefaultConnection()))
{
var typeResults = typeDB.GetAll().Take(1);
Assert.IsTrue(typeResults.Count() > 0);
}
}
public StreamBitArray(ValueReader reader)
{
SetCount = reader.ReadLittleEndianInt32();
for (var i = 0; i < _inner.Length; i++)
{
_inner[i] = reader.ReadLittleEndianInt32();
}
}
public static T ExecuteScalarValueOrDefault <T>(this IDbCommand command)
{
Assert.IsNotNull(command);
var scalar = command.ExecuteScalar();
return(ValueReader.GetValueOrDefault <T>(scalar));
}
public async Task Option_OptionInfo_Get()
{
var reader = new ValueReader <OptionInfo>();
var ItemToTest = new OptionInfo();
ItemToTest = reader.GetAll().FirstOrDefaultSafe();
Assert.IsTrue(ItemToTest != null, "Item constructed and did not fail.");
}
public void ReadUtf8Codepoint_RejectsContinuationBytesInInitialPosition()
{
var continuations = Enumerable.Range(0x80, 64).Select(i => (byte)i).ToArray();
var stream = new MemoryStream(continuations);
var reader = new ValueReader(stream);
for (var i = 0; i < continuations.Length; ++i) {
Assert.AreEqual(0xFFFD, reader.ReadUtf8Codepoint());
}
}
public void Peek_DoesNotConsumeData()
{
var stream = new MemoryStream(new byte[] {1, 2});
var reader = new ValueReader(stream);
var b0 = reader.Peek();
Assert.IsTrue(b0.HasValue);
Assert.AreEqual(1, b0.Value);
Assert.AreEqual(b0, reader.ReadByte());
}
public StreamBitArray(ValueReader reader)
{
if (!BitConverter.IsLittleEndian)
throw new NotSupportedException("Big endian conversion is not supported yet.");
SetCount = reader.ReadLittleEndianInt32();
unsafe
{
fixed (int* i = _inner)
{
int read = reader.Read((byte*)i, _inner.Length * sizeof(int));
if (read < _inner.Length * sizeof(int))
throw new EndOfStreamException();
}
}
}
protected UniOpReader(ValueReader reader)
{
Reader = reader;
}
private uint ReadCodepoint(params byte[] data)
{
var stream = new MemoryStream(data);
var reader = new ValueReader(stream);
return reader.ReadUtf8Codepoint();
}
public static double Sin(ValueReader value)
{
return (int)System.Math.Sin(value.GetDoubleValue());
}
public ValueReader MakeAssignmentValue(ValueReader ls, ParseTreeNode binOpNode, ValueReader rs)
{
if (binOpNode == null) return rs;
KinectitudeGrammar.OpCode opCode = grammar.OpLookup[binOpNode.Term];
return binOpCreate(opCode, ls, rs);
}
internal void setComponentValue(string comopnentName, string param, ValueReader value)
{
if (Entity == null) Game.CurrentGame.Die("Can't write from an unmatched entity");
Component component = Entity.GetComponent(comopnentName);
ParameterValueReader.GetParameterValueReader(component, param, Entity.Scene).GetValueWriter().SetValue(value);
}
internal Condition(ValueReader expr, Condition elseCond)
{
Expression = expr;
ElseCond = elseCond;
}
public static int Truncate(ValueReader value)
{
return (int)System.Math.Truncate(value.GetDoubleValue());
}
public static double Log(ValueReader value)
{
return System.Math.Log10(value.GetDoubleValue());
}
public static long Floor(ValueReader value)
{
return value.GetLongValue();
}
public static double Cosh(ValueReader value)
{
return System.Math.Cosh(value.GetDoubleValue());
}
internal OrOpReader(ValueReader left, ValueReader right)
: base(left, right)
{
}
public static double Sqrt(ValueReader value)
{
return System.Math.Sqrt(value.GetDoubleValue());
}
public NullWriter(ValueReader reader)
: base(reader)
{
}
private ValueReader uniOpCreate(BnfTerm op, ValueReader value)
{
if (grammar.Not == op) return new NotOpReader(value);
if (grammar.Minus == op) return new NegOpReader(value);
Game.CurrentGame.Die("Error with implementation of operator " + op.Name);
return null;
}
public override void SetValue(ValueReader value)
{
Game.CurrentGame.Die("The target of a write must be a single attribute or property name");
}
public static double Round(ValueReader value, ValueReader digits)
{
return (int)System.Math.Round(value.GetDoubleValue(), digits.GetIntValue());
}
internal RightShiftOpReader(ValueReader left, ValueReader right)
: base(left, right)
{
}
public static double ATan2(ValueReader y, ValueReader x)
{
return System.Math.Atan2(y.GetDoubleValue(), x.GetDoubleValue());
}
public static double ATan(ValueReader value)
{
return System.Math.Atan(value.GetDoubleValue());
}
public static double Abs(ValueReader value)
{
double val = value.GetDoubleValue();
if (val >= 0) return val;
return -val;
}
public static long Ceiling(ValueReader value)
{
return (long)System.Math.Ceiling(value.GetDoubleValue());
}
public override void SetValue(ValueReader value)
{
reader.Watcher.GetTypeMatcher()[reader.Param] = value;
}
public static double ACos(ValueReader value)
{
return System.Math.Acos(value.GetDoubleValue());
}
