public override bool ExtractFrom(string aLine, bool aForceExtractionOfThreadIdentifier)
{
// First pass identification stage
string line = aLine;
bool handled = (iPrefix.Length == 0);
if (!handled)
{
// Check for prefix match
handled = aLine.Contains(iPrefix);
if (handled)
{
// Check that it's not the start of a new data set
if (!aForceExtractionOfThreadIdentifier && aLine.Contains(KHeapDataDataSetStartMarker)) // "HEAP INFO FOR THREAD"
{
handled = false;
}
else
{
int pos = aLine.IndexOf(iPrefix);
line = aLine.Substring(pos + iPrefix.Length);
}
}
}
// Data processing stage
if (handled)
{
ExtractedData data = PrepareExtractedData(line, aLine);
base.Interpreter.Interpret(data);
}
// Done
return(handled);
}
/// <summary>
/// Initializes a new instance of the <see cref="ClangLibCpp"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public ClangLibCpp(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
ulong stringAddress = data.Process.ReadPointer(address + (uint)data.PointerOffset);
bool localData = stringAddress == 0;
if (localData)
{
stringAddress = address + (uint)data.BufferOffset;
}
bool bigEndian = true; // TODO:
if (localData)
{
length = data.ReadShortDataLength(address);
if (bigEndian)
{
length = length >> 1;
}
}
else
{
length = data.ReadLongDataLength(address);
}
if (localData)
{
reserved = data.BufferLength;
}
else
{
reserved = data.ReadCapacity(address);
}
text = UserMember.Create(() => data.Process.ReadString(stringAddress, data.CharSize, length));
}
/// <summary>
/// Initializes a new instance of the <see cref="VisualStudio"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VisualStudio(Variable variable, object savedData)
{
ExtractedData data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
list = UserMember.Create(() => new list <pair <TKey, TValue> >(Variable.Create(data.ListCodeType, address + (uint)data.ListOffset)));
}
/// <summary>
/// Initializes a new instance of the <see cref="ArrayBase"/> class.
/// </summary>
/// <param name="variable">The value.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public ArrayBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
firstElementAddress = address + (uint)data.FirstElementOffset;
}
/// <summary>
/// Initializes a new instance of the <see cref="ListBase"/> class.
/// </summary>
/// <param name="variable">The value.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public ListBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
length = data.ReadLength(address);
headAddress = data.Process.ReadPointer(address + (uint)data.HeadOffset);
}
/// <summary>
/// Initializes a new instance of the <see cref="OptionalBase"/> class.
/// </summary>
/// <param name="variable">The value.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public OptionalBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
valueAddress = address + (uint)data.ValueOffset;
HasValue = data.Process.ReadByte(address + (uint)data.HasValueOffset) != 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="VisualStudio"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VisualStudio(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
length = data.ReadSize(address);
reserved = data.ReadReserved(address);
text = UserMember.Create(() => GetText());
}
/// <summary>
/// Initializes a new instance of the <see cref="VectorBase"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VectorBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
firstAddress = data.Process.ReadPointer(address + (uint)data.FirstOffset);
lastAddress = data.Process.ReadPointer(address + (uint)data.LastOffset);
endAddress = data.Process.ReadPointer(address + (uint)data.EndOffset);
}
/// <summary>
/// Initializes a new instance of the <see cref="SharedPtrBase"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public SharedPtrBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
pointerAddress = data.Process.ReadPointer(address + (uint)data.PointerOffset);
referenceCountAddress = data.Process.ReadPointer(address + (uint)data.ReferenceCountPointerOffset);
isCreatedWithMakeShared = UserMember.Create(() => data.TestCreatedWithMakeShared(Variable.Create(data.ReferenceCountCodeType, referenceCountAddress).DowncastInterface().GetCodeType()));
}
/// <summary>
/// Initializes a new instance of the <see cref="VisualStudioBool" /> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VisualStudioBool(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
Variable vectorVariable = Variable.Create(data.CompressedVectorCodeType, address + (uint)data.CompressedVectorOffset);
compressedVector = new vector <uint>(vectorVariable);
Count = data.ReadLength(address);
}
/// <summary>
/// Initializes a new instance of the <see cref="LibStdCpp6_NoAbi"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public LibStdCpp6_NoAbi(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
ulong stringAddress = data.Process.ReadPointer(address + (uint)data.PointerOffset);
length = data.ReadLength(stringAddress);
reserved = data.ReadCapacity(stringAddress);
text = UserMember.Create(() => data.Process.ReadString(stringAddress, data.CharSize, length));
}
// ConvertBack method is from Target to Source
public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
try
{
return(ExtractedData.ParseTime((string)value));
}
catch
{
return(null);
}
}
private ExtractedData PrepareExtractedData(string aLine, string aOriginalLine)
{
ExtractedData ret = null;
// We need the heap base address before we are able to start
// extracting binary data.
DataSource ds = Interpreter.DataSource;
Elements.MetaData metaData = ds.MetaData;
Elements.Groups.GpHeap heapInfo = metaData.Heap;
uint baseAddress = heapInfo.HeapBaseAddress;
if (baseAddress != 0)
{
// We can now work out the next expected address
uint nextExpectedAddress = baseAddress + (uint)metaData.HeapData.Count;
// Build our regex string that will match the binary heap data.
string prefix = string.Format("{0:x8}: ", nextExpectedAddress);
int pos = aLine.IndexOf(prefix);
if (pos >= 0)
{
Match m = KHeapDataRegEx.Match(aLine);
if (m.Success)
{
List <byte> bytes = new List <byte>();
//
CaptureCollection data = m.Groups["Data"].Captures;
foreach (Capture dataItem in data)
{
string hexValue = dataItem.Value.Trim();
uint byteVal = System.Convert.ToUInt32(hexValue, KBaseHex);
bytes.Add((byte)byteVal);
}
//
ret = ExtractedData.NewBinaryData(bytes.ToArray(), aOriginalLine);
}
}
//
if (ret == null)
{
ret = ExtractedData.NewText(aLine, aOriginalLine);
}
}
else
{
ret = ExtractedData.NewText(aLine, aOriginalLine);
}
//
return(ret);
}
/// <summary>
/// Initializes a new instance of the <see cref="ClangLibCpp"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public ClangLibCpp(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
ulong managerAddress = data.Process.ReadPointer(address + (uint)data.ManagerPointerOffset);
if (managerAddress != 0)
{
Tuple <string, ulong> nameAndOffset = Context.SymbolProvider.GetSymbolNameByAddress(data.Process, managerAddress);
if (nameAndOffset != null)
{
managerName = nameAndOffset.Item1;
}
}
if (HasValue)
{
string codeTypeName;
string handlerCodeTypeName;
if (IsSmall)
{
string moduleName = managerName.Substring(0, managerName.IndexOf('!') + 1);
codeTypeName = moduleName + managerName.Substring(moduleName.Length + SmallHandlerNameStart.Length, managerName.Length - moduleName.Length - SmallHandlerNameStart.Length - SmallHandlerNameEnd.Length);
handlerCodeTypeName = $"{moduleName}std::__1::__any_imp::_SmallHandler<{codeTypeName.Substring(moduleName.Length)}>";
}
else if (IsLarge)
{
string moduleName = managerName.Substring(0, managerName.IndexOf('!') + 1);
codeTypeName = moduleName + managerName.Substring(moduleName.Length + LargeHandlerNameStart.Length, managerName.Length - moduleName.Length - LargeHandlerNameStart.Length - LargeHandlerNameEnd.Length);
handlerCodeTypeName = $"{moduleName}std::__1::__any_imp::_LargeHandler<{codeTypeName.Substring(moduleName.Length)}>";
}
else
{
throw new NotImplementedException();
}
CodeType handlerCodeType = CodeType.Create(handlerCodeTypeName);
valueCodeType = handlerCodeType.TemplateArguments[0] as CodeType ?? CodeType.Create(codeTypeName.Trim());
}
}
public static void WriteFile(ExtractedData item, string path)
{
StreamWriter sw = File.AppendText(path);
try
{
sw.WriteLine(item.VIN + "|" + item.Engine + "||" + item.Customer.Remove(0, 3) + "|" + item.Colour + "|8185|" + item.Folio + "|" +
item.BillingDate.ToShortDateString() + "|" + item.Pedimento.Remove(0, 34) + "|" +
item.PedimentoDate + "||");
sw.Close();
count += 1;
}
catch (Exception ex)
{
sw.Close();
Logger.WriteLog("Error: " + ex.Message + "\nPila de llamadas: " + ex.StackTrace);
Console.WriteLine("Error: " + ex.Message + "\nPila de llamadas: " + ex.StackTrace);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="item"/> class.
/// </summary>
/// <param name="address">The address of item.</param>
/// <param name="data">Data returned from VerifyCodeType function.</param>
public item(ulong address, ExtractedData data)
{
isnil = UserMember.Create(() => data.ReadItemIsNil != null && data.ReadItemIsNil(address) != 0);
left = UserMember.Create(() =>
{
ulong leftAddress = data.Process.ReadPointer(address + (uint)data.ItemLeftOffset);
if (leftAddress == 0)
{
return(null);
}
return(new item(leftAddress, data));
});
right = UserMember.Create(() =>
{
ulong rightAddress = data.Process.ReadPointer(address + (uint)data.ItemRightOffset);
if (rightAddress == 0)
{
return(null);
}
return(new item(rightAddress, data));
});
parent = UserMember.Create(() =>
{
ulong parentAddress = data.Process.ReadPointer(address + (uint)data.ItemParentOffset);
if (parentAddress == 0)
{
return(null);
}
return(new item(parentAddress, data));
});
pair = UserMember.Create(() =>
{
ulong pairAddress = address + (uint)data.ItemValueOffset;
Variable pairVariable = Variable.Create(data.ItemValueCodeType, pairAddress);
return(new pair <TKey, TValue>(pairVariable));
});
}
/// <summary>
/// Initializes a new instance of the <see cref="item"/> class.
/// </summary>
/// <param name="address">The address of item.</param>
/// <param name="data">Data returned from VerifyCodeType function.</param>
public item(ulong address, ExtractedData data)
{
next = UserMember.Create(() =>
{
ulong nextAddress = data.Process.ReadPointer(address + (uint)data.ItemNextOffset);
return(new item(nextAddress, data));
});
previous = UserMember.Create(() =>
{
ulong previousAddress = data.Process.ReadPointer(address + (uint)data.ItemPreviousOffset);
return(new item(previousAddress, data));
});
value = UserMember.Create(() =>
{
ulong valueAddress = address + (uint)data.ItemValueOffset;
return(Variable.Create(data.ItemValueCodeType, valueAddress).CastAs <T>());
});
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="extractionRequest"></param>
/// <param name="parent"></param>
public PlotWindowViewModel(ExtractionRequestModel extractionRequest, MainWindowViewModel parent)
{
model = new ExtractedData(extractionRequest);
startDateTime = model.DateTimes[0];
endDateTime = model.DateTimes[model.pointCount - 1];
resolution = extractionRequest.Resolution;
UpdatePoints();
cursor1Values = new float[model.Tags.Length];
plotRanges.Add(new PlotRange(startDateTime, endDateTime, yMin, yMax));
currentZoomIndex = 0;
if (parent != null)
{
// Subscribe the plotwindow to the plotRangeChanged event transmitted by the main window
WeakEventManager <MainWindowViewModel, PlotRangeChangedEventArgs> .AddHandler(parent, "TransmitPlotRangeChanged", OnPlotWindowRangeChanged);
}
view = new PlotWindowView(this);
view.Closed += (object source, EventArgs args) => PlotWindowClosed(this, args);
view.Show();
}
/// <summary>
/// Initializes a new instance of the <see cref="VisualStudio"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VisualStudio(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
typeData = data.Process.ReadPointer(address + (uint)data.TypeDataOffset);
if (HasValue)
{
Tuple <string, ulong> nameAndOffset = Context.SymbolProvider.GetSymbolNameByAddress(data.Process, TypeInfoAddress);
if (nameAndOffset != null)
{
string name = nameAndOffset.Item1;
if (name.EndsWith(rttiSignature))
{
name = name.Substring(0, name.Length - rttiSignature.Length);
valueCodeType = CodeType.Create(name);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="VectorBoolBase" /> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VectorBoolBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
ulong bufferAddress = data.Process.ReadPointer(address + (uint)data.CompressedBufferOffset);
Variable vectorVariable = Variable.CreatePointer(data.CompressedElementCodeType.PointerToType, bufferAddress);
int compressedLength = data.ReadCompressedLength(address);
if (data.CompressedElementCodeType.Size == 4)
{
compressedBuffer32 = new CodeArray <uint>(vectorVariable, compressedLength);
}
else if (data.CompressedElementCodeType.Size == 8)
{
compressedBuffer64 = new CodeArray <ulong>(vectorVariable, compressedLength);
}
else
{
throw new NotImplementedException();
}
Count = data.ReadLength(address);
}
/// <summary>
/// Initializes a new instance of the <see cref="LibStdCpp7"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public LibStdCpp7(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
ulong managerAddress = data.Process.ReadPointer(address + (uint)data.ManagerPointerOffset);
if (managerAddress != 0)
{
Tuple <string, ulong> nameAndOffset = Context.SymbolProvider.GetSymbolNameByAddress(data.Process, managerAddress);
if (nameAndOffset != null)
{
managerName = nameAndOffset.Item1;
}
}
if (HasValue)
{
string codeTypeName;
if (IsInternal)
{
string moduleName = managerName.Substring(0, managerName.IndexOf('!') + 1);
codeTypeName = moduleName + managerName.Substring(moduleName.Length + InternalManagerNameStart.Length, managerName.Length - moduleName.Length - InternalManagerNameStart.Length - InternalManagerNameEnd.Length);
}
else if (IsExternal)
{
string moduleName = managerName.Substring(0, managerName.IndexOf('!') + 1);
codeTypeName = moduleName + managerName.Substring(moduleName.Length + ExternalManagerNameStart.Length, managerName.Length - moduleName.Length - ExternalManagerNameStart.Length - ExternalManagerNameEnd.Length);
}
else
{
throw new NotImplementedException();
}
valueCodeType = CodeType.Create(codeTypeName.Trim());
}
}
public override void Interpret(ExtractedData aItem)
{
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - HEAP INFO FOR THREAD 'EComServer::!ecomserver'
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - ==============================================
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - HeapInfo - heapBaseAddress: 0x00700074
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - HeapInfo - heapSize: 745352
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - HeapInfo - heapChunkSize: 745472
// ...
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - 00700084: 00 00 00 00 03 03 03 03 03 03 03 03 03 03 03 03 ................
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - 00700094: 03 03 03 03 03 03 03 03 28 00 00 00 ec 47 28 80 ........(....G(.
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - 007000a4: d8 0c 70 00 58 0d 70 00 f8 0c 70 00 03 03 03 03 ..p.X.p...p.....
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - 007000b4: 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 ................
// [15:21:32.719] xti2:MCU_ASCII_PRINTF; channel:0xE0; msg:HeapData - EComServer::!ecomserver - 007000c4: 48 00 00 00 e8 2b 30 80 00 2c 30 80 ec 02 70 00 H....+0..,0...p.
//
// or
//
// HEAP INFO FOR THREAD 'ecomserver::!ecomserver'
// ==============================================
// HeapInfo - heapBaseAddress: 0x0f8c0074
// HeapInfo - heapSize: 262028
// Save the line - we must do this in order to be able to write a zip file
// containing the original source data for this data source.
DataSource.AddLine(aItem.OriginalLine);
if (aItem.Type == ExtractedData.TType.EBinaryData)
{
DataSource.MetaData.HeapData.Add(aItem.BinaryData);
}
else if (aItem.Type == ExtractedData.TType.EText)
{
if (CheckForKnownElement(aItem.Text))
{
}
}
}
public abstract void Interpret(ExtractedData aItem);
/// <summary>
/// Initializes a new instance of the <see cref="MapBase"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public MapBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
size = data.ReadSize(address);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void moveDataNotSameInstanceAppendProjects() throws Exception
private void moveDataNotSameInstanceAppendProjects()
{
this.progress.Indeterminate = true;
initialize();
try
{
createMappingTable();
System.Collections.IList list1 = this.helper.listEntities();
System.Collections.IList list2 = this.helper.listEntitiesWithForeignKeys();
this.progress.Indeterminate = false;
this.progress.TotalTimes = list1.Count * 3 + list2.Count;
logger.trace("SOURCE ID: " + this.source.ProjectUrlId + " DEST ID: " + this.dest.ProjectUrlId);
foreach (ProjectEntityMetadataKeeper projectEntityMetadataKeeper in list1)
{
if (projectEntityMetadataKeeper.TableName.Equals("PROJECTWBS") || projectEntityMetadataKeeper.TableName.Equals("PROJECTWBS2"))
{
continue;
}
try
{
executeUpdateQuery(this.destConnection, projectEntityMetadataKeeper.getAlterIdRefColumnStatement(this.dest));
}
catch (Exception)
{
logger.trace("COULD NOT EXECUTE ALTER: " + projectEntityMetadataKeeper.getAlterIdRefColumnStatement(this.dest));
}
if (projectEntityMetadataKeeper.TableName.Equals("PRJPROP", StringComparison.OrdinalIgnoreCase) || projectEntityMetadataKeeper.TableName.Equals("PRJUSERPROP", StringComparison.OrdinalIgnoreCase))
{
continue;
}
setProgress(this.progress, "Selecting [" + projectEntityMetadataKeeper.TableName + "]");
ResultSet resultSet = executeSelectQuery(this.sourceConnection, projectEntityMetadataKeeper.SelectEverythingStatementAppendProjects);
long l = executeCountQuery(this.sourceConnection, projectEntityMetadataKeeper.CountStatement);
resultSet.FetchSize = 2000;
sbyte b1 = 0;
List <object> arrayList1 = new List <object>(2000);
List <object> arrayList2 = projectEntityMetadataKeeper.hasForeignKeys() ? new List <object>(2000) : null;
string str1 = projectEntityMetadataKeeper.getInsertDataStatementAppendProjects(this.dest);
string str2 = projectEntityMetadataKeeper.getInsertForeignKeysToMappingTableStatement(this.dest);
setProgress(this.progress, "INSERT [" + projectEntityMetadataKeeper.TableName + "] ");
this.progress.incrementProgress(1);
sbyte b2 = 0;
while (resultSet.next())
{
ExtractedData extractedData = projectEntityMetadataKeeper.extractRow(this.dest, resultSet);
arrayList1.Add(extractedData.DataValues);
if (projectEntityMetadataKeeper.hasForeignKeys())
{
ExtractedData.ExtractedFKData[] arrayOfExtractedFKData = extractedData.FkValues;
foreach (ExtractedData.ExtractedFKData extractedFKData in arrayOfExtractedFKData)
{
arrayList2.Add(extractedFKData.DataValues);
}
}
b1++;
b2++;
if (b1 % 'ߐ' == '\x0000')
{
setProgress(this.progress, "INSERT DATA [" + projectEntityMetadataKeeper.TableName + "] " + b2);
executeInsertStatement(this.destConnection, str1, arrayList1);
arrayList1.Clear();
if (projectEntityMetadataKeeper.hasForeignKeys())
{
setProgress(this.progress, "INSERT FOREIGN KEYS [" + projectEntityMetadataKeeper.TableName + "] " + b2);
logger.trace("FK STATEMENT: " + str2);
executeInsertStatement(this.destConnection, str2, arrayList2);
arrayList2.Clear();
}
b1 = 0;
}
}
if (b1 != 0)
{
setProgress(this.progress, "INSERT DATA [" + projectEntityMetadataKeeper.TableName + "] " + b2);
executeInsertStatement(this.destConnection, str1, arrayList1);
arrayList1.Clear();
if (projectEntityMetadataKeeper.hasForeignKeys())
{
setProgress(this.progress, "INSERT FOREIGN KEYS [" + projectEntityMetadataKeeper.TableName + "] " + b2);
logger.trace("FK STATEMENT: " + str2);
executeInsertStatement(this.destConnection, str2, arrayList2);
arrayList2.Clear();
}
}
resultSet.close();
this.progress.incrementProgress(1);
}
foreach (ProjectEntityMetadataKeeper projectEntityMetadataKeeper in list2)
{
logger.trace("\nFK UPDATE: " + projectEntityMetadataKeeper.getUpdateBySelectForeignKeysMappingTableStatement(this.dest));
setProgress(this.progress, "UPDATE FOREIGN KEYS [" + projectEntityMetadataKeeper.TableName + "]");
executeUpdateQuery(this.destConnection, projectEntityMetadataKeeper.getUpdateBySelectForeignKeysMappingTableStatement(this.dest));
this.progress.incrementProgress(1);
}
this.progress.Indeterminate = true;
setProgress(this.progress, "CLEANING UP");
updateFixedReferences(this.destConnection);
dropMappingTable();
}
catch (Exception exception)
{
logger.error("An error occured while doing stuff", exception);
cleanUp();
throw exception;
}
cleanUp();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private System.Nullable<long> moveModelsToCEP() throws Exception
private long?moveModelsToCEP()
{
this.progress.Indeterminate = true;
long?long = null;
try
{
createMappingTable();
System.Collections.IList list1 = this.helper.listEntities();
System.Collections.IList list2 = this.helper.listEntitiesWithForeignKeys();
this.progress.Indeterminate = false;
this.progress.TotalTimes = list1.Count * 3 + list2.Count;
foreach (BaseEntityMetadataKeeper baseEntityMetadataKeeper in list1)
{
string str1 = baseEntityMetadataKeeper.TableName;
try
{
long?long1 = Convert.ToInt64(executeCountQuery(this.destConnection, baseEntityMetadataKeeper.getIdRefColumnExistsStatement(this.destDbms)));
if (long1.Value == 0L)
{
executeUpdateQuery(this.destConnection, baseEntityMetadataKeeper.getAlterIdRefColumnStatement(this.destDbms));
long?long2 = Convert.ToInt64(executeCountQuery(this.destConnection, baseEntityMetadataKeeper.getIdRefColumnIndexExistsStatement(this.destDbms, true)));
if (long2.Value == 0L)
{
executeUpdateQuery(this.destConnection, baseEntityMetadataKeeper.getIdRefColumnIndexCreateStatement(this.destDbms, true));
}
}
}
catch (Exception exception)
{
logger.error("COULD NOT EXECUTE ALTER: " + baseEntityMetadataKeeper.getAlterIdRefColumnStatement(this.destDbms), exception);
}
if (str1.Equals("BC_MODEL", StringComparison.OrdinalIgnoreCase))
{
ResultSet resultSet1 = executeSelectQuery(this.sourceConnection, baseEntityMetadataKeeper.SelectEverythingStatement);
resultSet1.next();
ExtractedData extractedData = baseEntityMetadataKeeper.extractRow(null, resultSet1);
string str = baseEntityMetadataKeeper.getInsertDataStatement(this.destDbms);
long = executeInsertStatement(this.destConnection, str, extractedData.DataValues);
continue;
}
setProgress(this.progress, "Selecting [" + str1 + "]");
ResultSet resultSet = executeSelectQuery(this.sourceConnection, baseEntityMetadataKeeper.SelectEverythingStatement);
long l = executeCountQuery(this.sourceConnection, baseEntityMetadataKeeper.CountStatement);
resultSet.FetchSize = 2000;
sbyte b1 = 0;
List <object> arrayList1 = new List <object>(2000);
List <object> arrayList2 = baseEntityMetadataKeeper.hasForeignKeys() ? new List <object>(2000) : null;
string str2 = baseEntityMetadataKeeper.getInsertDataStatement(this.destDbms);
string str3 = baseEntityMetadataKeeper.getInsertForeignKeysToMappingTableStatement(Convert.ToInt32(this.destDbms));
setProgress(this.progress, "INSERT [" + str1 + "] ");
this.progress.incrementProgress(1);
sbyte b2 = 0;
while (resultSet.next())
{
ExtractedData extractedData = baseEntityMetadataKeeper.extractRow(long, resultSet);
arrayList1.Add(extractedData.DataValues);
if (baseEntityMetadataKeeper.hasForeignKeys())
{
ExtractedData.ExtractedFKData[] arrayOfExtractedFKData = extractedData.FkValues;
foreach (ExtractedData.ExtractedFKData extractedFKData in arrayOfExtractedFKData)
{
arrayList2.Add(extractedFKData.DataValues);
}
}
b1++;
b2++;
if (b1 % 'ߐ' == '\x0000')
{
setProgress(this.progress, "INSERT DATA [" + str1 + "] " + b2);
executeInsertStatement(this.destConnection, str2, arrayList1);
arrayList1.Clear();
if (baseEntityMetadataKeeper.hasForeignKeys())
{
setProgress(this.progress, "INSERT FOREIGN KEYS [" + str1 + "] " + b2);
logger.debug("FK STATEMENT: " + str3);
executeInsertStatement(this.destConnection, str3, arrayList2);
arrayList2.Clear();
}
b1 = 0;
}
}
if (b1 != 0)
{
setProgress(this.progress, "INSERT DATA [" + str1 + "] " + b2);
executeInsertStatement(this.destConnection, str2, arrayList1);
arrayList1.Clear();
if (baseEntityMetadataKeeper.hasForeignKeys())
{
setProgress(this.progress, "INSERT FOREIGN KEYS [" + str1 + "] " + b2);
logger.debug("FK STATEMENT: " + str3);
executeInsertStatement(this.destConnection, str3, arrayList2);
arrayList2.Clear();
}
}
resultSet.close();
save(this.destSession);
this.progress.incrementProgress(1);
}
foreach (BaseEntityMetadataKeeper baseEntityMetadataKeeper in list2)
{
string str = baseEntityMetadataKeeper.getUpdateBySelectForeignKeysMappingTableStatement(Convert.ToInt32(this.destDbms), long);
if (string.ReferenceEquals(str, null))
{
continue;
}
logger.debug("\nFK UPDATE: " + str);
setProgress(this.progress, "UPDATE FOREIGN KEYS [" + baseEntityMetadataKeeper.TableName + "]");
executeUpdateQuery(this.destConnection, str);
this.progress.incrementProgress(1);
}
this.progress.Indeterminate = true;
setProgress(this.progress, "CLEANING UP");
BimDataMoverUtils.fixSerializedData(this.destConnection, long);
}
catch (Exception exception)
{
logger.error("An error occured while doing stuff", exception);
throw exception;
}
return(long);
}
public override void ExtractData(int NumSearch)
{
var maxmin = new TireDataMaxmin();
ExtractedData.Clear();
NotExtractedData.Clear();
IndexHolder.Clear();
IndexHolder.Add(0);
for (int i = 0; i < IndexHolderParent.Count - 1; ++i)
{
if (NumSearch > 0 && i >= NumSearch)
{
break;
}
var list = SplitedTransientTable(i);
bool add = true;
foreach (var data in list)
{
foreach (TireDataColumn column in Enum.GetValues(typeof(TireDataColumn)))
{
if (column == TireDataColumn.NT)
{
continue;
}
bool remove = false;
foreach (var constrain in Constrains[column])
{
if (!constrain.Not)
{
continue;
}
if (!constrain.Evaluate(data))
{
remove = true;
break;
}
}
if (remove == true)
{
add = false;
break;
}
if (!remove)
{
remove = true;
int counttemp = 0;
if (column == TireDataColumn.NT)
{
continue;
}
foreach (var constrain in Constrains[column])
{
if (constrain.Not)
{
continue;
}
++counttemp;
if (constrain.Evaluate(data))
{
remove = false;
break;
}
else
{
}
}
if (counttemp == 0)
{
remove = false;
}
}
add = add && !remove;
}
}
if (add)
{
ExtractedData.AddRange(list);
IndexHolder.Add(ExtractedData.Count);
}
else
{
NotExtractedData.AddRange(list);
}
}
State = TireDataSelectorState.Changed;
ExtractedDataMaxmin = StaticFunctions.GetLimitData(ExtractedData);
}
public static ExtractedData Extract(string html, Uri domain, string pattern)
{
var customRegexUsed = !string.IsNullOrEmpty(pattern);
var primedPattern = customRegexUsed ? "|" + pattern : "";
var combinedRegexPatterns = linkRegex + primedPattern;
var regex = new Regex(combinedRegexPatterns);
var matches = regex.Matches(html);
var data = new ExtractedData();
foreach (Match m in matches)
{
if (m.Success)
{
var link = m.Groups[LINK_REGEX_GROUP_NAME];
if (link != null)
{
var value = link.Value;
// false links go here
if (value.Contains("#") || value.Contains("javascript:void(0)"))
{
continue;
}
// full URLs sometimes hide behind "//"
if (value.StartsWith("//"))
{
value = value.Substring(2);
}
// add the link if:
// it starts with the whole domain
// it starts with the domain (without the host)
if (value.StartsWith(domain.OriginalString))
{
data.Links.Add(new Uri(value));
}
else if (value.StartsWith(domain.AbsolutePath))
{
data.Links.Add(new Uri($"{domain.Scheme}://" + domain.Host + value));
}
}
// try to add data if the user has set a regex
if (customRegexUsed)
{
foreach (var groupName in regex.GetGroupNames())
{
// don't add the yaclinks to the data and group 0 is the entire string (expect the custom regex has a capture group)
if (groupName == LINK_REGEX_GROUP_NAME || groupName == "0")
{
continue;
}
var value = m.Groups[groupName];
if (value.Success)
{
data.Data.Add(new Tuple <string, string>(groupName, value.Value));
}
}
}
}
}
return(data);
}
/// <summary>
/// Initializes a new instance of the <see cref="VariantBase"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VariantBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
Index = data.ReadIndex(address);
}
private void PlotButton_Click(object sender, RoutedEventArgs e)
{
ExtractedData extractedData = new ExtractedData(StartDateTime, EndDateTime, SelectedTags, SelectedFiles);
}