public static int GetSharedPathIndex(int startIndexForNewPath, List <InstancePathItem> oldPath, List <InstancePathItem> newPath, bool returnPreviousIndex, out bool identicalPaths)
{
identicalPaths = false;
int result = -1;
int num = -1;
if (null == oldPath != (null == newPath))
{
return(num);
}
if (oldPath == null && newPath == null)
{
return(num);
}
int count = oldPath.Count;
int count2 = newPath.Count;
int i = startIndexForNewPath;
int j = startIndexForNewPath;
if (startIndexForNewPath >= 0 && startIndexForNewPath < count && startIndexForNewPath < count2)
{
while (i < count && j < count2)
{
for (; i < count && oldPath[i].IsEmpty; i++)
{
}
for (; j < count2 && newPath[j].IsEmpty; j++)
{
}
if (returnPreviousIndex && i < count && j + 1 == count2)
{
return(result);
}
if (i < count != j < count2)
{
return(num);
}
if (i == count && j == count2)
{
break;
}
InstancePathItem instancePathItem = oldPath[i];
InstancePathItem instancePathItem2 = newPath[j];
if (instancePathItem.m_indexType != instancePathItem2.m_indexType || instancePathItem.m_indexInCollection != instancePathItem2.m_indexInCollection || instancePathItem.m_instanceIndex != instancePathItem2.m_instanceIndex)
{
return(num);
}
result = num;
num = j;
i++;
j++;
}
if (i == count && j == count2)
{
identicalPaths = true;
}
return(num);
}
return(num);
}
public static string GenerateUniqueNameString(string idString, List <InstancePathItem> instancePath)
{
if (instancePath != null && instancePath.Count != 0)
{
return(idString + 'i' + InstancePathItem.GenerateInstancePathString(instancePath, -1));
}
return(idString);
}
private static void AppendInteger(ref ReverseStringBuilder builder, int value)
{
while (value > 9)
{
builder.Append(InstancePathItem.GetIntegerChar(value % 10));
value /= 10;
}
builder.Append(InstancePathItem.GetIntegerChar(value));
}
public static string GenerateUniqueNameString(int id, List <InstancePathItem> instancePath, int parentInstanceIndex)
{
string text = id.ToString(CultureInfo.InvariantCulture);
if (instancePath != null && instancePath.Count != 0)
{
return(text + 'i' + InstancePathItem.GenerateInstancePathString(instancePath, parentInstanceIndex));
}
return(text);
}
public static bool IsValidContext(List <InstancePathItem> path)
{
for (int i = 0; i < path.Count; i++)
{
InstancePathItem instancePathItem = path[i];
if (instancePathItem.IsDynamicMember && instancePathItem.InstanceIndex < 0)
{
return(false);
}
}
return(true);
}
public static void DeepCopyPath(List <InstancePathItem> instancePath, ref List <InstancePathItem> copy)
{
if (instancePath != null)
{
int i = 0;
int count = instancePath.Count;
if (copy == null)
{
copy = new List <InstancePathItem>(count);
for (; i < count; i++)
{
copy.Add(new InstancePathItem(instancePath[i]));
}
}
else
{
int num = copy.Count;
if (count == 0)
{
if (num > 0)
{
copy.Clear();
}
}
else
{
if (num > count)
{
int num2 = num - count;
copy.RemoveRange(count, num2);
num -= num2;
}
for (; i < num; i++)
{
InstancePathItem instancePathItem = copy[i];
InstancePathItem instancePathItem2 = instancePath[i];
instancePathItem.m_hash = 0;
instancePathItem.m_indexInCollection = instancePathItem2.m_indexInCollection;
instancePathItem.m_indexType = instancePathItem2.m_indexType;
instancePathItem.m_instanceIndex = instancePathItem2.m_instanceIndex;
}
for (; i < count; i++)
{
copy.Add(new InstancePathItem(instancePath[i]));
}
}
}
}
}
public static bool IsSameScopePath(IInstancePath originalRIFObject, IInstancePath lastRIFObject)
{
if (null == originalRIFObject != (null == lastRIFObject))
{
return(false);
}
if (originalRIFObject == null && lastRIFObject == null)
{
return(true);
}
if (originalRIFObject.Equals(lastRIFObject))
{
return(true);
}
List <InstancePathItem> instancePath = originalRIFObject.InstancePath;
List <InstancePathItem> instancePath2 = lastRIFObject.InstancePath;
bool flag = default(bool);
int sharedPathIndex = InstancePathItem.GetSharedPathIndex(0, instancePath, instancePath2, false, out flag);
if (flag)
{
return(true);
}
if (sharedPathIndex < 0)
{
return(false);
}
int count = instancePath.Count;
int count2 = instancePath2.Count;
int i = sharedPathIndex + 1;
int j = sharedPathIndex + 1;
for (; i < count && !instancePath[i].IsScope; i++)
{
}
if (i + 1 == count && instancePath[i].m_indexType == InstancePathItemType.SubReport)
{
i = count;
}
for (; j < count2 && !instancePath2[j].IsScope; j++)
{
}
if (i == count && j == count2)
{
return(true);
}
return(false);
}
public static bool IsSamePath(List <InstancePathItem> path1, List <InstancePathItem> path2)
{
if (null == path1 != (null == path2))
{
return(false);
}
if (path1 == null && path2 == null)
{
return(true);
}
if (path1.Count != path2.Count)
{
return(false);
}
bool result = default(bool);
InstancePathItem.GetSharedPathIndex(0, path1, path2, false, out result);
return(result);
}
public static List <InstancePathItem> CombineRowColPath(List <InstancePathItem> rowPath, List <InstancePathItem> columnPath)
{
int parentDataRegionIndex = InstancePathItem.GetParentDataRegionIndex(rowPath);
int parentDataRegionIndex2 = InstancePathItem.GetParentDataRegionIndex(columnPath);
Global.Tracer.Assert(rowPath[parentDataRegionIndex].m_indexInCollection == columnPath[parentDataRegionIndex2].m_indexInCollection && parentDataRegionIndex == parentDataRegionIndex2);
int num = columnPath.Count - parentDataRegionIndex2 - 1;
List <InstancePathItem> list = new List <InstancePathItem>(rowPath.Count + num);
list.AddRange(rowPath);
if (0 < num)
{
columnPath[parentDataRegionIndex2 + 1].m_indexType = InstancePathItemType.ColumnMemberInstanceIndexTopMost;
for (int i = 0; i < num; i++)
{
list.Add(columnPath[parentDataRegionIndex2 + 1 + i]);
}
}
return(list);
}
public string GetRecursiveUniqueName(int parentInstanceIndex)
{
return(InstancePathItem.GenerateUniqueNameString(base.ID, this.InstancePath, parentInstanceIndex));
}
private static string GenerateInstancePathString(List <InstancePathItem> instancePath, int parentInstanceIndex)
{
if (instancePath != null && instancePath.Count != 0)
{
int count = instancePath.Count;
ReverseStringBuilder reverseStringBuilder = new ReverseStringBuilder(count * 2 + 4);
bool flag = true;
bool flag2 = true;
bool flag3 = parentInstanceIndex >= 0;
for (int num = count - 1; num >= 0; num--)
{
InstancePathItem instancePathItem = instancePath[num];
switch (instancePathItem.m_indexType)
{
case InstancePathItemType.ColumnMemberInstanceIndexTopMost:
case InstancePathItemType.ColumnMemberInstanceIndex:
if (flag3)
{
flag3 = false;
InstancePathItem.AppendInteger(ref reverseStringBuilder, parentInstanceIndex);
}
else
{
InstancePathItem.AppendInteger(ref reverseStringBuilder, instancePathItem.m_instanceIndex);
}
if (flag)
{
flag = false;
reverseStringBuilder.Append('x');
InstancePathItem.AppendInteger(ref reverseStringBuilder, instancePathItem.m_indexInCollection);
}
reverseStringBuilder.Append('C');
break;
case InstancePathItemType.RowMemberInstanceIndex:
if (flag3)
{
flag3 = false;
InstancePathItem.AppendInteger(ref reverseStringBuilder, parentInstanceIndex);
}
else
{
InstancePathItem.AppendInteger(ref reverseStringBuilder, instancePathItem.m_instanceIndex);
}
if (flag2)
{
flag2 = false;
reverseStringBuilder.Append('x');
InstancePathItem.AppendInteger(ref reverseStringBuilder, instancePathItem.m_indexInCollection);
}
reverseStringBuilder.Append('R');
break;
case InstancePathItemType.DataRegion:
InstancePathItem.AppendInteger(ref reverseStringBuilder, instancePathItem.m_indexInCollection);
reverseStringBuilder.Append('T');
break;
case InstancePathItemType.SubReport:
InstancePathItem.AppendInteger(ref reverseStringBuilder, instancePathItem.m_indexInCollection);
reverseStringBuilder.Append('S');
break;
}
}
return(reverseStringBuilder.ToString());
}
return("");
}
public static string GenerateInstancePathString(List <InstancePathItem> instancePath)
{
return(InstancePathItem.GenerateInstancePathString(instancePath, -1));
}
public static string GenerateUniqueNameString(int id, List <InstancePathItem> instancePath)
{
return(InstancePathItem.GenerateUniqueNameString(id.ToString(CultureInfo.InvariantCulture), instancePath));
}
public static int GetSharedPathIndex(int startIndexForNewPath, List <InstancePathItem> oldPath, List <InstancePathItem> newPath)
{
bool flag = default(bool);
return(InstancePathItem.GetSharedPathIndex(startIndexForNewPath, oldPath, newPath, false, out flag));
}
public InstancePathItem(InstancePathItem original)
{
this.m_indexType = original.m_indexType;
this.m_instanceIndex = original.m_instanceIndex;
this.m_indexInCollection = original.m_indexInCollection;
}
