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 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()); }