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