private void UpdateField(UpdateField command) { Raise(command, new FieldUpdated()); }
private static int FillList() { int i = 0; string old_s = String.Empty; string s = String.Empty; gr.BaseStream.Position = start_ofs; do { uint p1 = gr.ReadUInt32(); if (p1 < 0x9999) { p1 = gr.ReadUInt32(); } uint p2 = gr.ReadUInt32(); uint p3 = gr.ReadUInt32(); uint p4 = gr.ReadUInt32(); uint p5 = gr.ReadUInt32(); str_ofs = p1 - str_ofs_delta; long oldpos = gr.BaseStream.Position; gr.BaseStream.Position = str_ofs; s = gr.ReadStringNull(); gr.BaseStream.Position = oldpos; StringBuilder sb = new StringBuilder(); sb.Append("Size: "); sb.Append(p3); sb.Append(", Type: "); UpdateFieldType type = (UpdateFieldType)p4; sb.Append(type); sb.Append(", Flags: "); UpdatafieldFlags flags = (UpdatafieldFlags)p5; sb.Append(flags); UpdateField uf = new UpdateField(s, p2, p3, sb.ToString()); list.Add(uf); if (!old_s.Equals("CORPSE_FIELD_PAD") && s.Equals("CORPSE_FIELD_PAD")) break; old_s = s; i++; } while (true); return i; }
public override IReadOnlyList <FlowControlBlock> OnOptionalFieldInitUpdate(string name, UpdateField updateField, IReadOnlyList <FlowControlBlock> previousControlFlow) { name = RenameField(name); var flowControl = new List <FlowControlBlock>(); var nameUsedToWrite = name; var arrayLoopBlockIndex = -1; if (updateField.Type.IsArray) { flowControl.Add(new FlowControlBlock { Statement = $"for (var i = 0; i < {updateField.Size}; ++i)" }); nameUsedToWrite += "[i]"; arrayLoopBlockIndex = flowControl.Count; } if (_writeUpdateMasks) { GenerateBitIndexConditions(updateField, name, flowControl, previousControlFlow, arrayLoopBlockIndex); flowControl.RemoveAt(1); // bit generated but not checked for is_initialized } _fieldWrites.Add((name, true, (pcf) => { WriteControlBlocks(_source, flowControl, pcf); _source.WriteLine($"{GetIndent()}var has{name} = packet.ReadBit(\"Has{name}\", indexes);"); _indent = 3; return(flowControl); } )); return(flowControl); }
public void UpdateField(UpdateField command) { RaiseEvent(command, new FieldUpdated()); }
public override IReadOnlyList <FlowControlBlock> OnField(string name, UpdateField updateField, IReadOnlyList <FlowControlBlock> previousControlFlow) { name = RenameField(name); var flowControl = new List <FlowControlBlock>(); if (_create && updateField.Flag != UpdateFieldFlag.None) { flowControl.Add(new FlowControlBlock { Statement = $"if ((flags & {updateField.Flag.ToFlagsExpression(" | ", "UpdateFieldFlag.", "", "(", ")")}) != UpdateFieldFlag.None)" }); } var type = updateField.Type; var outputFieldName = name; var nextIndex = string.Empty; var declarationType = updateField.Type; var declarationSettable = true; var arrayLoopBlockIndex = -1; var indexLetter = 'i'; if (type.IsArray) { flowControl.Add(new FlowControlBlock { Statement = $"for (var {indexLetter} = 0; {indexLetter} < {updateField.Size}; ++{indexLetter})" }); outputFieldName += $"[{indexLetter}]"; type = type.GetElementType(); nextIndex += ", " + indexLetter; declarationSettable = false; arrayLoopBlockIndex = flowControl.Count; ++indexLetter; } if (typeof(DynamicUpdateField).IsAssignableFrom(type)) { flowControl.Add(new FlowControlBlock { Statement = $"for (var {indexLetter} = 0; {indexLetter} < data.{outputFieldName}.Count; ++{indexLetter})" }); if (!_create) { flowControl.Add(new FlowControlBlock { Statement = $"if (data.{outputFieldName}.UpdateMask[{indexLetter}])" }); } outputFieldName += $"[{indexLetter}]"; type = type.GenericTypeArguments[0]; nextIndex += ", " + indexLetter; declarationSettable = false; ++indexLetter; } if (typeof(BlzVectorField).IsAssignableFrom(type)) { flowControl.Add(new FlowControlBlock { Statement = $"for (var {indexLetter} = 0; {indexLetter} < data.{outputFieldName}.Length; ++{indexLetter})" }); outputFieldName += $"[{indexLetter}]"; type = type.GenericTypeArguments[0]; nextIndex += ", " + indexLetter; declarationType = type.MakeArrayType(); ++indexLetter; } if (typeof(BlzOptionalField).IsAssignableFrom(type)) { flowControl.Add(new FlowControlBlock { Statement = $"if (has{name})" }); type = type.GenericTypeArguments[0]; declarationType = type; } if (typeof(Bits).IsAssignableFrom(type)) { declarationType = typeof(uint); } if (!_create && _writeUpdateMasks) { GenerateBitIndexConditions(updateField, name, flowControl, previousControlFlow, arrayLoopBlockIndex); if (name.EndsWith("is_initialized()")) { flowControl.RemoveAt(1); // bit generated but not checked for is_initialized } } Type interfaceType = null; if (updateField.SizeForField != null) { type = (updateField.SizeForField.GetValue(null) as UpdateField).Type; type = type.GenericTypeArguments[0]; interfaceType = TypeHandler.ConvertToInterfaces(type, rawName => RenameType(rawName)); } RegisterDynamicChangesMaskFieldType(type); _fieldWrites.Add((name, false, (pcf) => { WriteControlBlocks(_source, flowControl, pcf); WriteField(name, outputFieldName, type, updateField.BitSize, nextIndex, interfaceType); _indent = 3; return(flowControl); } )); if (_create && updateField.SizeForField == null) { WriteFieldDeclaration(name, updateField, declarationType, declarationSettable); } return(flowControl); }
public override IReadOnlyList <FlowControlBlock> OnDynamicFieldSizeUpdate(string name, UpdateField updateField, IReadOnlyList <FlowControlBlock> previousControlFlow) { name = RenameField(name); var flowControl = new List <FlowControlBlock>(); if (_create && updateField.Flag != UpdateFieldFlag.None) { flowControl.Add(new FlowControlBlock { Statement = $"if ((flags & {updateField.Flag.ToFlagsExpression(" | ", "UpdateFieldFlag.", "", "(", ")")}) != UpdateFieldFlag.None)" }); } var nameUsedToWrite = name; var arrayLoopBlockIndex = -1; if (updateField.Type.IsArray) { flowControl.Add(new FlowControlBlock { Statement = $"for (var i = 0; i < {updateField.Size}; ++i)" }); nameUsedToWrite += "[i]"; arrayLoopBlockIndex = flowControl.Count; } if (_writeUpdateMasks) { GenerateBitIndexConditions(updateField, name, flowControl, previousControlFlow, arrayLoopBlockIndex); } _fieldWrites.Add((name, true, (pcf) => { WriteControlBlocks(_source, flowControl, pcf); var bitCountArgument = updateField.BitSize > 0 ? ", " + updateField.BitSize : ""; _source.WriteLine($"{GetIndent()}data.{nameUsedToWrite}.ReadUpdateMask(packet{bitCountArgument});"); _indent = 3; return(flowControl); } )); return(flowControl); }
public UpdateField <U> ModifyValue <U>(UpdateField <U> updateField) where U : new() { MarkChanged(updateField); return(updateField); }
/// <summary> /// Request to update an app field. /// </summary> /// <param name="_appSecret">The application secret.</param> /// <param name="_field">The field to update.</param> /// <param name="_appSession">The application session.</param> public UpdateAppRequest(string _appSecret, UpdateField _field, string _appSession) { AppSecret = _appSecret; FieldInfo = _field; ApplicationSession = _appSession; }
private static void ReadAndDumpField(UpdateField uf, StringBuilder sb, GenericReader gr, UpdateTypes updatetype, StreamWriter data, WoWObject obj) { MemoryStream ms = new MemoryStream(gr.ReadBytes(4)); GenericReader gr2 = new GenericReader(ms); if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) { obj.SetUInt32Value(uf.Identifier, gr2.ReadUInt32()); gr2.BaseStream.Position -= 4; } switch (uf.Type) { // TODO: add data writing /*case 3: * string val1 = gr.ReadSingle().ToString().Replace(",", "."); * if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) * data.WriteLine(uf.Name + " (" + uf.Identifier + "): " + val1); * sb.AppendLine(uf.Name + " (" + index + "): " + val1); * break; * default: * uint val2 = gr.ReadUInt32(); * if (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) * data.WriteLine(uf.Name + " (" + uf.Identifier + "): " + val2); * sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + val2); * break;*/ case 1: // uint32 sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + gr2.ReadUInt32().ToString("X8")); break; case 2: // uint16+uint16 ushort value1 = gr2.ReadUInt16(); ushort value2 = gr2.ReadUInt16(); sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + "first " + value1.ToString("X4") + ", second " + value2.ToString("X4")); if (uf.Name.StartsWith("PLAYER_SKILL_INFO_1_")) { int num = uf.Identifier - 858; if ((num % 3) == 0) { ushort skill = value1; ushort flag = value2; string str = String.Format("skill {0}, flag {1}", skill, (ProfessionFlags)flag); sb.AppendLine(str); } else if (((num - 1) % 3) == 0) { ushort minskill = value1; ushort maxskill = value2; string str = String.Format("minskill {0}, maxskill {1}", minskill, maxskill); sb.AppendLine(str); } else { ushort minbonus = value1; ushort maxbonus = value2; string str = String.Format("minbonus {0}, maxbonus {1}", minbonus, maxbonus); sb.AppendLine(str); } } break; case 3: // float sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + gr2.ReadSingle()); //sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + gr.ReadSingle().ToString().Replace(",", ".")); break; case 4: // uint64 (can be only low part) sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + gr2.ReadUInt32().ToString("X8")); break; case 5: // bytes uint value = gr2.ReadUInt32(); sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + value.ToString("X8")); if (uf.Identifier == 36) // UNIT_FIELD_BYTES_0 { byte[] bytes = BitConverter.GetBytes(value); Races race = (Races)bytes[0]; Class class_ = (Class)bytes[1]; Gender gender = (Gender)bytes[2]; Powers powertype = (Powers)bytes[3]; string str = String.Format("Race: {0}, class: {1}, gender: {2}, powertype: {3}", race, class_, gender, powertype); sb.AppendLine(str); } break; default: sb.AppendLine(uf.Name + " (" + uf.Identifier + "): " + "unknown type " + gr2.ReadUInt32().ToString("X8")); break; } gr2.Close(); }
public void ClearChanged <U>(UpdateField <U> updateField) where U : new() { _changesMask.Reset(updateField.Bit); }
private static bool ParseValuesUpdateBlock(GenericReader gr, StringBuilder sb, StreamWriter swe, StreamWriter data, ObjectTypes objectTypeId, UpdateTypes updatetype, WoWObject obj) { sb.AppendLine("=== values_update_block_start ==="); byte blocks_count = gr.ReadByte(); // count of update blocks (4 bytes for each update block) sb.AppendLine("Bit mask blocks count: " + blocks_count); int[] updatemask = new int[blocks_count]; // create array of update blocks for (int j = 0; j < blocks_count; j++) { updatemask[j] = gr.ReadInt32(); // populate array of update blocks with data } Mask = new BitArray(updatemask); int reallength = Mask.Count; // bitmask size (bits) int bitmask_max_size = 0; uint values_end = 0; switch (objectTypeId) { case ObjectTypes.TYPEID_ITEM: bitmask_max_size = 64; values_end = UpdateFieldsLoader.ITEM_END; break; case ObjectTypes.TYPEID_CONTAINER: bitmask_max_size = 160; values_end = UpdateFieldsLoader.CONTAINER_END; break; case ObjectTypes.TYPEID_UNIT: bitmask_max_size = 256; values_end = UpdateFieldsLoader.UNIT_END; break; case ObjectTypes.TYPEID_PLAYER: bitmask_max_size = 1536; // 2.3.2 - 1472 values_end = UpdateFieldsLoader.PLAYER_END; break; case ObjectTypes.TYPEID_GAMEOBJECT: bitmask_max_size = 32; values_end = UpdateFieldsLoader.GO_END; break; case ObjectTypes.TYPEID_DYNAMICOBJECT: bitmask_max_size = 32; values_end = UpdateFieldsLoader.DO_END; break; case ObjectTypes.TYPEID_CORPSE: bitmask_max_size = 64; values_end = UpdateFieldsLoader.CORPSE_END; break; } if (reallength > bitmask_max_size) { long pos = gr.BaseStream.Position; swe.WriteLine("error position {0}", pos.ToString("X2")); swe.WriteLine("error while parsing {0} values update block, count {1}", objectTypeId, reallength); return(false); } for (int index = 0; index < reallength; index++) { if (index > values_end) { break; } if (Mask[index]) { UpdateField uf = new UpdateField(); switch (objectTypeId) { case ObjectTypes.TYPEID_ITEM: case ObjectTypes.TYPEID_CONTAINER: uf = UpdateFieldsLoader.item_uf[index]; break; case ObjectTypes.TYPEID_UNIT: case ObjectTypes.TYPEID_PLAYER: uf = UpdateFieldsLoader.unit_uf[index]; break; case ObjectTypes.TYPEID_GAMEOBJECT: uf = UpdateFieldsLoader.go_uf[index]; break; case ObjectTypes.TYPEID_DYNAMICOBJECT: uf = UpdateFieldsLoader.do_uf[index]; break; case ObjectTypes.TYPEID_CORPSE: uf = UpdateFieldsLoader.corpse_uf[index]; break; } ReadAndDumpField(uf, sb, gr, updatetype, data, obj); } } if ((objectTypeId == ObjectTypes.TYPEID_GAMEOBJECT || objectTypeId == ObjectTypes.TYPEID_UNIT) && (updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT || updatetype == UpdateTypes.UPDATETYPE_CREATE_OBJECT2) && obj.IsNew) { obj.Save(); } sb.AppendLine("=== values_update_block_end ==="); return(true); }
public static void TriggerUpdate(Cord cord) { UpdateField?.Invoke(cord); }
public async Task <IActionResult> Put(Guid id, UpdateField command) => await SendAsync(command.Bind(c => c.Id, id), resourceId : command.Id, resource : "fields");
public override IReadOnlyList <FlowControlBlock> OnOptionalFieldInitCreate(string name, UpdateField updateField, IReadOnlyList <FlowControlBlock> previousControlFlow) { name = RenameField(name); var flowControl = new List <FlowControlBlock>(); if (_create && updateField.Flag != UpdateFieldFlag.None) { flowControl.Add(new FlowControlBlock { Statement = $"if (fieldVisibilityFlags.HasFlag({updateField.Flag.ToFlagsExpression(" | ", "UpdateFieldFlag::")}))" }); } var nameUsedToWrite = name; if (updateField.Type.IsArray) { flowControl.Add(new FlowControlBlock { Statement = $"for (std::size_t i = 0; i < {updateField.Size}; ++i)" }); nameUsedToWrite += "[i]"; } _fieldWrites.Add((name, true, (pcf) => { WriteControlBlocks(_source, flowControl, pcf); _source.WriteLine($"{GetIndent()}data.WriteBit({nameUsedToWrite}.is_initialized());"); _indent = 1; return(flowControl); } )); return(flowControl); }
public void MarkChanged <U>(UpdateField <U> updateField) where U : new() { _changesMask.Set(updateField.BlockBit); _changesMask.Set(updateField.Bit); }
private void WriteFieldDeclaration(string name, UpdateField declarationType) { var fieldGeneratedType = CppTypes.GetCppType(declarationType.Type); string typeName; string line; if (_writeUpdateMasks) { var bit = CppTypes.CreateConstantForTemplateParameter(_fieldBitIndex[name][0]); if (fieldGeneratedType.IsArray) { if (typeof(DynamicUpdateField).IsAssignableFrom(fieldGeneratedType.GetElementType())) { var elementType = PrepareFieldType(fieldGeneratedType.GetElementType().GenericTypeArguments[0]); typeName = TypeHandler.GetFriendlyName(elementType); fieldGeneratedType = _arrayUpdateFieldType.MakeGenericType( _dynamicUpdateFieldBaseType.MakeGenericType(elementType), CppTypes.CreateConstantForTemplateParameter(declarationType.Size), bit, CppTypes.CreateConstantForTemplateParameter(_fieldBitIndex[name][1])); } else { var elementType = PrepareFieldType(fieldGeneratedType.GetElementType()); typeName = TypeHandler.GetFriendlyName(elementType); fieldGeneratedType = _arrayUpdateFieldType.MakeGenericType(elementType, CppTypes.CreateConstantForTemplateParameter(declarationType.Size), bit, CppTypes.CreateConstantForTemplateParameter(_fieldBitIndex[name][1])); } } else if (typeof(DynamicUpdateField).IsAssignableFrom(declarationType.Type)) { var elementType = PrepareFieldType(fieldGeneratedType.GenericTypeArguments[0]); typeName = TypeHandler.GetFriendlyName(elementType); fieldGeneratedType = _dynamicUpdateFieldType.MakeGenericType(PrepareFieldType(fieldGeneratedType.GenericTypeArguments[0]), CppTypes.CreateConstantForTemplateParameter(_fieldBitIndex[name][1]), bit); } else if (typeof(BlzOptionalField).IsAssignableFrom(declarationType.Type)) { var elementType = PrepareFieldType(fieldGeneratedType.GenericTypeArguments[0]); typeName = TypeHandler.GetFriendlyName(elementType); fieldGeneratedType = _optionalUpdateFieldType.MakeGenericType(elementType, CppTypes.CreateConstantForTemplateParameter(_fieldBitIndex[name][1]), bit); } else { var elementType = PrepareFieldType(declarationType.Type); typeName = TypeHandler.GetFriendlyName(elementType); fieldGeneratedType = _updateFieldType.MakeGenericType(PrepareFieldType(declarationType.Type), CppTypes.CreateConstantForTemplateParameter(_fieldBitIndex[name][1]), bit); } line = $" {TypeHandler.GetFriendlyName(fieldGeneratedType)} {name};"; } else if (fieldGeneratedType.IsArray) { typeName = TypeHandler.GetFriendlyName(fieldGeneratedType.GetElementType()); line = $" {typeName} {name}[{declarationType.Size}];"; } else { typeName = TypeHandler.GetFriendlyName(PrepareFieldType(fieldGeneratedType)); line = $" {typeName} {name};"; } _header.Write(line); if (declarationType.Comment != null) { _header.Write($"{new string(' ', Math.Max(1, 80 - line.Length))}// {declarationType.Comment}"); } _header.WriteLine(); if ((declarationType.CustomFlag & CustomUpdateFieldFlag.ViewerDependent) != CustomUpdateFieldFlag.None) { _header.WriteLine($" struct {name}Tag : ViewerDependentValueTag<{typeName}> {{}};"); } }
public UpdateFieldWriter(UpdateField[][] fields) { m_fields = fields; }
protected Task On(UpdateField command, CommandContext context) { return(handler.UpdateAsync <SchemaDomainObject>(context, s => s.UpdateField(command))); }
public RedirectToActionResult UpdateFieldAction(UpdateField field) { InitialSystemInfo(); if (!ModelState.IsValid) { ProcessModelState(); return(RedirectToAction("AddField")); } var checkInDatabase = _context.Fields.Where(a => a.Id == field.Id); //Check if field id is not in database if (!checkInDatabase.Any()) { if ((string)TempData["Error"] != "") { TempData["Error"] += "\n"; } TempData["Error"] += "Please enter correct field id!"; return(RedirectToAction("AddField")); } //Check if duplicate field name with other field name var checkDuplication = _context.Fields .Where(a => a.NormalizedName == field.Name.ToUpper()); if (checkDuplication.Any() && checkDuplication.First().Id != field.Id) { if ((string)TempData["Error"] != "") { TempData["Error"] += "\n"; } TempData["Error"] += "Entered duplicate field name " + "\"" + field.Name + "\" " + "!"; return(RedirectToAction("AddField")); } var oldField = checkInDatabase.First(); //Prepare to change status if (oldField.Status != field.Status) { string oldStatus; string newStatus; switch (oldField.Status) { case FieldStatus.InUse: oldStatus = "\"In Use\""; break; case FieldStatus.InRequest: oldStatus = "\"In Request\""; break; default: oldStatus = "\"No Longer Used\""; break; } switch (field.Status) { case FieldStatus.InUse: newStatus = "\"In Use\""; break; case FieldStatus.InRequest: newStatus = "\"In Request\""; break; default: newStatus = "\"No Longer Used\""; break; } oldField.Status = field.Status; _context.Fields.Update(oldField); _context.SaveChanges(); if ((string)TempData["Inform"] != "") { TempData["Inform"] += "\n"; } TempData["Inform"] += "Field " + "\"" + field.Name + "\" " + "'s status changed from " + oldStatus + " to " + newStatus; } //Prepare to change field name if (oldField.Name != field.Name) { var newName = field.Name; var oldName = oldField.Name; oldField.Name = field.Name; oldField.NormalizedName = field.Name.ToUpper(); _context.Fields.Update(oldField); _context.SaveChanges(); if ((string)TempData["Inform"] != "") { TempData["Inform"] += "\n"; } TempData["Inform"] += "Field" + "\"" + field.Name + "\" " + "'s name changed from " + oldName + " to " + newName; } TempData["Success"] = "Field \"" + field.Name + "\" updated!"; return(RedirectToAction("AddField")); }
public override IReadOnlyList <FlowControlBlock> OnDynamicFieldSizeCreate(string name, UpdateField updateField, IReadOnlyList <FlowControlBlock> previousControlFlow) { name = RenameField(name); var flowControl = new List <FlowControlBlock>(); if (_create && updateField.Flag != UpdateFieldFlag.None) { flowControl.Add(new FlowControlBlock { Statement = $"if ((flags & {updateField.Flag.ToFlagsExpression(" | ", "UpdateFieldFlag.", "", "(", ")")}) != UpdateFieldFlag.None)" }); } var nameUsedToWrite = name; if (updateField.Type.IsArray) { flowControl.Add(new FlowControlBlock { Statement = $"for (var i = 0; i < {updateField.Size}; ++i)" }); nameUsedToWrite += "[i]"; } _fieldWrites.Add((name, true, (pcf) => { WriteControlBlocks(_source, flowControl, pcf); if (updateField.BitSize > 0) { _source.WriteLine($"{GetIndent()}data.{nameUsedToWrite}.Resize(packet.ReadBits({updateField.BitSize}));"); } else { _source.WriteLine($"{GetIndent()}data.{nameUsedToWrite}.Resize(packet.ReadUInt32());"); } _indent = 3; return(flowControl); } )); return(flowControl); }
public override void Map(ByteSlice row, MapOutput output) { if (null == TableName) { InitFields(); } // Operate on values! ByteSlice key; bool keep = null == filter || filter.TestRow(row); if (DeleteFromFilter) { keep = !keep; } if (keep) { if (KeyOn != null) { orderbuf.Clear(); for (int iob = 0; iob < KeyOn.Count; iob++) { GetKeyPart gkp = KeyOn[iob]; gkp(row, orderbuf); } #if DEBUG string KeyOnStringValue = "<not evaluated yet>"; if (0 != ((orderbuf.Count - 1) % 2)) { KeyOnStringValue = "<not a string>"; } else { //KeyOnStringValue = System.Text.Encoding.Unicode.GetString(ByteSlice.Prepare(orderbuf, 1, orderbuf.Count - 1).ToBytes()); { System.Text.Encoding ue = new System.Text.UnicodeEncoding(false, false, true); // throwOnInvalidBytes=true try { KeyOnStringValue = ue.GetString(ByteSlice.Prepare(orderbuf, 1, orderbuf.Count - 1).ToBytes()); } catch { KeyOnStringValue = "<not a string>"; } } } #endif while (orderbuf.Count < DSpace_KeyLength) { orderbuf.Add(0); } key = ByteSlice.Prepare(orderbuf); } else // Use default key. { orderbuf.Clear(); Entry.ToBytesAppend(defkey, orderbuf); key = ByteSlice.Prepare(orderbuf); defkey = unchecked (defkey + DSpace_ProcessCount); } if (null != Updates) { updatebuf.Clear(); row.AppendTo(updatebuf); for (int ui = 0; ui < Updates.Count; ui++) { UpdateField uf = Updates[ui]; DbColumn ci = cols[uf.FieldIndex]; for (int i = 0; i < ci.Type.Size; i++) { updatebuf[ci.RowOffset + i] = uf.NewValue[i]; } } row = ByteSlice.Prepare(updatebuf); } } else { if (null == Updates) { if (null != ftools) { ftools.ResetBuffers(); } return; } if (KeyOn != null) { key = row; #if DEBUG throw new Exception("DEBUG: (!keep) && (KeyOn != null)"); #endif } else { // Use default key. orderbuf.Clear(); Entry.ToBytesAppend(defkey, orderbuf); key = ByteSlice.Prepare(orderbuf); defkey = unchecked (defkey + DSpace_ProcessCount); } } // If WhatFunctions, might need all input fields, so keep them here and filter out unwanted stuff in reduce. if (null != Whats && !WhatFunctions) { newfieldsbuf.Clear(); for (int iww = 0; iww < Whats.Count; iww++) { int wi = Whats[iww]; if (-1 == wi) { DbTypeID ltype; if (null == ftools) { ftools = new DbFunctionTools(); } List <byte> lbuf = ftools.AllocBuffer(); ByteSlice cval = Types.LiteralToValueBuffer(awhat[iww], out ltype, lbuf); int Size = cval.Length; #if DEBUG if (Size != OutputColumnSizes[iww]) { throw new Exception("DEBUG: " + awhat[iww] + ": (Size{" + Size + "} != OutputColumnSizes[iww]{" + OutputColumnSizes[iww] + "})"); } #endif cval.AppendTo(newfieldsbuf); } else { DbColumn ci = cols[wi]; int StartOffset = ci.RowOffset; int Size = ci.Type.Size; #if DEBUG if (Size != OutputColumnSizes[iww]) { throw new Exception("DEBUG: (Size != OutputColumnSizes[iww])"); } #endif ByteSlice cval = ByteSlice.Prepare(row, StartOffset, Size); cval.AppendTo(newfieldsbuf); } } row = ByteSlice.Prepare(newfieldsbuf); } output.Add(key, row); if (null != ftools) { ftools.ResetBuffers(); } }
public override IReadOnlyList <FlowControlBlock> OnOptionalFieldInitCreate(string name, UpdateField updateField, IReadOnlyList <FlowControlBlock> previousControlFlow) { name = RenameField(name); var flowControl = new List <FlowControlBlock>(); if (_create && updateField.Flag != UpdateFieldFlag.None) { flowControl.Add(new FlowControlBlock { Statement = $"if ((flags & {updateField.Flag.ToFlagsExpression(" | ", "UpdateFieldFlag.", "", "(", ")")}) != UpdateFieldFlag.None)" }); } var nameUsedToWrite = name; if (updateField.Type.IsArray) { flowControl.Add(new FlowControlBlock { Statement = $"for (var i = 0; i < {updateField.Size}; ++i)" }); nameUsedToWrite += "[i]"; } _fieldWrites.Add((name, true, (pcf) => { WriteControlBlocks(_source, flowControl, pcf); _source.WriteLine($"{GetIndent()}var has{name} = packet.ReadBit(\"Has{name}\", indexes);"); _indent = 3; return(flowControl); } )); return(flowControl); }
public void UpdateField(UpdateField command) { RaiseEvent(command, SimpleMapper.Map(command, new FieldUpdated())); }
private void GenerateBitIndexConditions(UpdateField updateField, string name, List <FlowControlBlock> flowControl, IReadOnlyList <FlowControlBlock> previousControlFlow, int arrayLoopBlockIndex) { var newField = false; var nameForIndex = updateField.SizeForField != null?RenameField(updateField.SizeForField.Name) : name; if (!_fieldBitIndex.TryGetValue(nameForIndex, out var bitIndex)) { bitIndex = new List <int>(); if (flowControl.Count == 0 || !FlowControlBlock.AreChainsAlmostEqual(previousControlFlow, flowControl)) { if (!updateField.Type.IsArray) { ++_nonArrayBitCounter; if (_nonArrayBitCounter == 32) { _blockGroupBit = ++_bitCounter; _nonArrayBitCounter = 1; } } bitIndex.Add(++_bitCounter); if (!updateField.Type.IsArray) { bitIndex.Add(_blockGroupBit); } } else { if (_previousFieldCounters == null || _previousFieldCounters.Count == 1) { throw new Exception("Expected previous field to have been an array"); } bitIndex.Add(_previousFieldCounters[0]); } _fieldBitIndex[nameForIndex] = bitIndex; newField = true; } if (updateField.Type.IsArray) { flowControl.Insert(0, new FlowControlBlock { Statement = $"if (changesMask[{bitIndex[0]}])" }); if (newField) { bitIndex.AddRange(Enumerable.Range(_bitCounter + 1, updateField.Size)); _bitCounter += updateField.Size; } flowControl.Insert(arrayLoopBlockIndex + 1, new FlowControlBlock { Statement = $"if (changesMask[{bitIndex[1]} + i])" }); } else { flowControl.Insert(0, new FlowControlBlock { Statement = $"if (changesMask[{_blockGroupBit}])" }); flowControl.Insert(1, new FlowControlBlock { Statement = $"if (changesMask[{bitIndex[0]}])" }); } _previousFieldCounters = bitIndex; }
public override IReadOnlyList <FlowControlBlock> OnField(string name, UpdateField updateField, IReadOnlyList <FlowControlBlock> previousControlFlow) { _allUsedFlags |= updateField.Flag; name = RenameField(name); var flowControl = new List <FlowControlBlock>(); if (_create && updateField.Flag != UpdateFieldFlag.None) { flowControl.Add(new FlowControlBlock { Statement = $"if (fieldVisibilityFlags.HasFlag({updateField.Flag.ToFlagsExpression(" | ", "UpdateFieldFlag::")}))" }); } var type = updateField.Type; var access = _writeUpdateMasks ? "->" : "."; var nameUsedToWrite = updateField.SizeForField != null?string.Format(name, access) : name; var arrayLoopBlockIndex = -1; var indexLetter = 'i'; var allIndexes = ""; if (type.IsArray) { flowControl.Add(new FlowControlBlock { Statement = $"for (std::size_t {indexLetter} = 0; {indexLetter} < {updateField.Size}; ++{indexLetter})" }); nameUsedToWrite += $"[{indexLetter}]"; access = "."; type = type.GetElementType(); arrayLoopBlockIndex = flowControl.Count; allIndexes += ", " + indexLetter; ++indexLetter; } if (typeof(DynamicUpdateField).IsAssignableFrom(type)) { flowControl.Add(new FlowControlBlock { Statement = $"for (std::size_t {indexLetter} = 0; {indexLetter} < {nameUsedToWrite}.size(); ++{indexLetter})" }); if (!_create) { flowControl.Add(new FlowControlBlock { Statement = $"if ({nameUsedToWrite}.HasChanged({indexLetter}) || {(_isRoot ? "ignoreNestedChangesMask" : "ignoreChangesMask")})" }); } nameUsedToWrite += $"[{indexLetter}]"; access = "."; type = type.GenericTypeArguments[0]; allIndexes += ", " + indexLetter; ++indexLetter; } if (typeof(BlzVectorField).IsAssignableFrom(type)) { flowControl.Add(new FlowControlBlock { Statement = $"for (std::size_t {indexLetter} = 0; {indexLetter} < {name}{access}size(); ++{indexLetter})" }); if (_writeUpdateMasks) { nameUsedToWrite = $"(*{nameUsedToWrite})"; } nameUsedToWrite += $"[{indexLetter}]"; access = "."; type = type.GenericTypeArguments[0]; allIndexes += ", " + indexLetter; ++indexLetter; } if (typeof(BlzOptionalField).IsAssignableFrom(type)) { flowControl.Add(new FlowControlBlock { Statement = $"if ({name}.is_initialized())" }); type = type.GenericTypeArguments[0]; } if ((updateField.CustomFlag & CustomUpdateFieldFlag.ViewerDependent) != CustomUpdateFieldFlag.None) { nameUsedToWrite = $"ViewerDependentValue<{name}Tag>::GetValue(this{allIndexes}, owner, receiver)"; } if (!_create && _writeUpdateMasks) { GenerateBitIndexConditions(updateField, name, flowControl, previousControlFlow, arrayLoopBlockIndex); if (name.EndsWith("is_initialized()")) { flowControl.RemoveAt(1); // bit generated but not checked for is_initialized } } RegisterDynamicChangesMaskFieldType(type); _fieldWrites.Add((name, false, (pcf) => { WriteControlBlocks(_source, flowControl, pcf); WriteField(nameUsedToWrite, access, type, updateField.BitSize); _indent = 1; return(flowControl); } )); if (!_create && updateField.SizeForField == null) { _delayedHeaderWrites.Add(() => { WriteFieldDeclaration(name, updateField); }); if (_writeUpdateMasks) { _changesMaskClears.Add($" Base::ClearChangesMask({name});"); } else { _equalityComparisonFields.Add($"{name} == right.{name}"); } } return(flowControl); }
public void PIK_UpdateFieldsInObjects() { CommandStart.Start(doc => UpdateField.UpdateInSelected()); }
public override IReadOnlyList <FlowControlBlock> OnDynamicFieldSizeUpdate(string name, UpdateField updateField, IReadOnlyList <FlowControlBlock> previousControlFlow) { name = RenameField(name); var flowControl = new List <FlowControlBlock>(); if (_create && updateField.Flag != UpdateFieldFlag.None) { flowControl.Add(new FlowControlBlock { Statement = $"if (fieldVisibilityFlags.HasFlag({updateField.Flag.ToFlagsExpression(" | ", "UpdateFieldFlag::")}))" }); } var nameUsedToWrite = name; var arrayLoopBlockIndex = -1; if (updateField.Type.IsArray) { flowControl.Add(new FlowControlBlock { Statement = $"for (std::size_t i = 0; i < {updateField.Size}; ++i)" }); nameUsedToWrite += "[i]"; arrayLoopBlockIndex = flowControl.Count; } if (_writeUpdateMasks) { GenerateBitIndexConditions(updateField, name, flowControl, previousControlFlow, arrayLoopBlockIndex); } _fieldWrites.Add((name, true, (pcf) => { WriteControlBlocks(_source, flowControl, pcf); var bitCountArgument = updateField.BitSize > 0 ? ", " + updateField.BitSize : ""; _source.WriteLine($"{GetIndent()}if (!{(_isRoot ? "ignoreNestedChangesMask" : "ignoreChangesMask")})"); _source.WriteLine($"{GetIndent()} {nameUsedToWrite}.WriteUpdateMask(data{bitCountArgument});"); _source.WriteLine($"{GetIndent()}else"); _source.WriteLine($"{GetIndent()} WriteCompleteDynamicFieldUpdateMask({nameUsedToWrite}.size(), data{bitCountArgument});"); _indent = 1; return(flowControl); })); return(flowControl); }
public void MarkSelectedPublished(Guid siteID, List<Guid> lstUpd, UpdateField selField) { IQueryable<carrot_RootContent> queryCont = null; Guid gContent = ContentPageType.GetIDByType(ContentPageType.PageType.ContentEntry); if (selField == UpdateField.MarkActive || selField == UpdateField.MarkAsIndexable || selField == UpdateField.MarkInactive || selField == UpdateField.MarkAsIndexableNo) { queryCont = (from r in db.carrot_RootContents where r.SiteID == siteID && lstUpd.Contains(r.Root_ContentID) select r); } else { queryCont = (from r in db.carrot_RootContents where r.SiteID == siteID && r.ContentTypeID == gContent && lstUpd.Contains(r.Root_ContentID) select r); } switch (selField) { case UpdateField.MarkActive: db.carrot_RootContents.BatchUpdate(queryCont, p => new carrot_RootContent { PageActive = true }); break; case UpdateField.MarkInactive: db.carrot_RootContents.BatchUpdate(queryCont, p => new carrot_RootContent { PageActive = false }); break; case UpdateField.MarkAsIndexable: db.carrot_RootContents.BatchUpdate(queryCont, p => new carrot_RootContent { BlockIndex = false }); break; case UpdateField.MarkAsIndexableNo: db.carrot_RootContents.BatchUpdate(queryCont, p => new carrot_RootContent { BlockIndex = true }); break; case UpdateField.MarkIncludeInSiteMap: db.carrot_RootContents.BatchUpdate(queryCont, p => new carrot_RootContent { ShowInSiteMap = true }); break; case UpdateField.MarkIncludeInSiteMapNo: db.carrot_RootContents.BatchUpdate(queryCont, p => new carrot_RootContent { ShowInSiteMap = false }); break; case UpdateField.MarkIncludeInSiteNav: db.carrot_RootContents.BatchUpdate(queryCont, p => new carrot_RootContent { ShowInSiteNav = true }); break; case UpdateField.MarkIncludeInSiteNavNo: db.carrot_RootContents.BatchUpdate(queryCont, p => new carrot_RootContent { ShowInSiteNav = false }); break; } db.SubmitChanges(); }
public override IReadOnlyList <FlowControlBlock> OnOptionalFieldInitUpdate(string name, UpdateField updateField, IReadOnlyList <FlowControlBlock> previousControlFlow) { name = RenameField(name); var flowControl = new List <FlowControlBlock>(); if (_create && updateField.Flag != UpdateFieldFlag.None) { flowControl.Add(new FlowControlBlock { Statement = $"if ({updateField.Flag.ToFlagsExpression(" || ", "fieldVisibilityFlags.HasFlag(UpdateFieldFlag::", ")")})" }); } var nameUsedToWrite = name; var arrayLoopBlockIndex = -1; if (updateField.Type.IsArray) { flowControl.Add(new FlowControlBlock { Statement = $"for (std::size_t i = 0; i < {updateField.Size}; ++i)" }); nameUsedToWrite += "[i]"; arrayLoopBlockIndex = flowControl.Count; } if (_writeUpdateMasks) { GenerateBitIndexConditions(updateField, name, flowControl, previousControlFlow, arrayLoopBlockIndex); flowControl.RemoveAt(1); // bit generated but not checked for is_initialized } _fieldWrites.Add((name, true, (pcf) => { WriteControlBlocks(_source, flowControl, pcf); _source.WriteLine($"{GetIndent()}data.WriteBit({nameUsedToWrite}.is_initialized());"); _indent = 1; return(flowControl); } )); return(flowControl); }