/// <summary>
/// Gets the virtual container.
/// </summary>
/// <param name="level">The level of Virtual Container</param>
/// <param name="index">The index.</param>
/// <returns></returns>
public IContent GetVirtualContainer(VirtualContainerLevel level, int index)
{
IContent returnContent = null;
if (level == VirtualContainerLevel.VC4)
{
if (this.Content.Count >= index + 1)
{
returnContent = this.Content[index];
}
}
else
{
int higherIndex = GetHigherContainerIndex(level, index);
if (this.Content.Count >= higherIndex + 1)
{
returnContent = this.Content[higherIndex];
if (VirtualContainer.isVirtualContainer(returnContent))
{
returnContent = ((VirtualContainer)returnContent).GetVirtualContainerAtIndex(level, index); //Get specific virtual container lower level
}
}
}
return(returnContent);
}
/// <summary>
/// Gets the IContent from VirtualContainer at the index.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
public IContent GetVirtualContainerAtIndex(VirtualContainerLevel level, int index)
{
IContent returnValue;
returnValue = this.Content[GetContainerIndex(level, index)];
return(returnValue);
}
/// <summary>
/// Gets the index of the higher level container.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
private int GetHigherContainerIndex(VirtualContainerLevel level, int index)
{
int returnIndex = -1;
switch (level)
{
case VirtualContainerLevel.VC12:
returnIndex = index / 63;
break;
case VirtualContainerLevel.VC21:
returnIndex = index / 21;
break;
case VirtualContainerLevel.VC32:
returnIndex = index / 3;
break;
case VirtualContainerLevel.VC4:
returnIndex = index;
break;
case VirtualContainerLevel.UNDEF:
break;
}
return(returnIndex);
}
/// <summary>
/// Gets the virtual container.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="hiIndex">Index of the hi.</param>
/// <param name="lowIndex">Index of the low.</param>
/// <returns></returns>
public IContent GetVirtualContainer(VirtualContainerLevel level, int hiIndex, int?lowIndex)
{
IContent returnContent = null;
if (level == VirtualContainerLevel.VC4)
{
if (this.Content.Count >= hiIndex + 1)
{
returnContent = this.Content[hiIndex];
}
}
else
{
if (this.Content.Count >= hiIndex + 1 && lowIndex != null)
{
int lowerIndex = (int)lowIndex;
returnContent = this.Content[hiIndex];
if (VirtualContainer.isVirtualContainer(returnContent))
{
returnContent = ((VirtualContainer)returnContent).GetVirtualContainerAtIndex(level, lowerIndex); //Get specific virtual container lower level
}
}
}
return(returnContent);
}
public StreamData(int port, StmLevel stm, VirtualContainerLevel vcLevel, int hpo, int? lpo)
{
Port = port;
Stm = stm;
VcLevel = vcLevel;
HigherPath = hpo;
LowerPath = lpo;
}
/// <summary>
/// Initializes a new instance of the <see cref="VirtualContainer" /> class.
/// </summary>
/// <param name="level">The level.</param>
public VirtualContainer(VirtualContainerLevel level)
{
this.Level = level;
this.Type = ContentType.VICONTAINER;
this.POH = new POH();
this.Pointer = string.Empty;
this.Content = this.GenerateContentList();
}
/// <summary>
/// Initializes a new instance of the <see cref="VirtualContainer" /> class.
/// </summary>
/// <param name="level">The level.</param>
public VirtualContainer(VirtualContainerLevel level)
{
this.Level = level;
this.Type = ContentType.VICONTAINER;
this.POH = new POH();
this.Pointer = string.Empty;
this.Content = this.GenerateContentList();
}
/// <summary>
/// Gets the index of the container. This convert user index for Frame index.
/// VC12 has user index multiplied by 1
/// VC2 has user index multiplied by 3
/// VC3 has user index multiplied by 21
/// VC4 has user index multiplied by 63
/// </summary>
/// <param name="level">The level of Virtual Container</param>
/// <param name="index">The index.</param>
/// <returns></returns>
private int GetContainerIndex(VirtualContainerLevel level, int index)
{
int counter = 0;
int returnValue = -1;
switch (level)
{
case VirtualContainerLevel.VC12:
for (int i = 0; i < Content.Count; i++)
{
if (counter == index)
{
returnValue = i;
}
counter++;
}
break;
case VirtualContainerLevel.VC21:
for (int i = 0; i < Content.Count; i += 3)
{
if (counter == index)
{
returnValue = i;
}
counter++;
}
break;
case VirtualContainerLevel.VC32:
for (int i = 0; i < Content.Count; i += 21)
{
if (counter == index)
{
returnValue = i;
}
counter++;
}
break;
case VirtualContainerLevel.VC4:
for (int i = 0; i < Content.Count; i += 63)
{
if (counter == index)
{
returnValue = i;
}
counter++;
}
break;
case VirtualContainerLevel.UNDEF:
break;
}
return(returnValue);
}
public ForwardingRecord(int inputPort, int outputPort, VirtualContainerLevel containerLevel, int vcNumberIn, int vcNumberOut, int hPathIn, int hPathOut)
{
OutputPort = outputPort;
InputPort = inputPort;
ContainerLevel = containerLevel;
VcNumberIn = vcNumberIn;
VcNumberOut = vcNumberOut;
InputPort = inputPort;
HigherPathIn = hPathIn;
HigherPathOut = hPathOut;
}
/// <summary>
/// Tests adding the container to frame space.
/// Check if Virtual Container have TU-space for itself
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
public bool TryAddContainer(VirtualContainerLevel level, int index)
{
bool testUp = false;
bool testDown = false;
switch (level)
{
case VirtualContainerLevel.VC12:
if (this.CheckContainerUp(level, index))
{
testUp = true;
}
testDown = true;
break;
case VirtualContainerLevel.VC21:
if (this.CheckContainerUp(level, index))
{
testUp = true;
}
if (this.CheckContainerDown(level, index))
{
testDown = true;
}
break;
case VirtualContainerLevel.VC32:
if (this.CheckContainerUp(level, index))
{
testUp = true;
}
if (this.CheckContainerDown(level, index))
{
testDown = true;
}
break;
case VirtualContainerLevel.VC4:
if (this.CheckContainerDown(level, index))
{
testDown = true;
}
testUp = true;
break;
}
if (testUp && testDown)
{
return(true);
}
else
{
return(false);
}
}
private StreamData CreateRecord(List <string> literalRecord)
{
int outPort = int.Parse(literalRecord[0]);
int?lowerPath = literalRecord[4].Equals("") ? null : (int?)int.Parse(literalRecord[4]);
int higherPath = int.Parse(literalRecord[3]);
VirtualContainerLevel level = VirtualContainerLevelExt.GetContainer(literalRecord[2]);
StmLevel stm = StmLevelExt.GetContainer(literalRecord[1]);
StreamData record = new StreamData(outPort, stm, level, higherPath, lowerPath);
return(record);
}
/// <summary>
/// Sets the virtual container. This overwrite the <see cref="Content" /> list member.
/// Content must by VirtualContainer!
/// </summary>
/// <param name="level">The level.</param>
/// <param name="hiIndex">Index of the higher level virtual container (VC-4).</param>
/// <param name="lowIndex">Index of the lower level virtual container.</param>
/// <param name="content">The content. Virtual Container</param>
/// <returns>
/// True - success, False - fail
/// </returns>
public bool SetVirtualContainer(VirtualContainerLevel level, int hiIndex, int?lowIndex, IContent content)
{
if (VirtualContainer.isVirtualContainer(content))
{
VirtualContainer contentVC = (VirtualContainer)content;
if (level == contentVC.Level && this.CalculateFreeSpace() >= Frame.ContainerSpaceConverter(level))
{
if (level == VirtualContainerLevel.VC4)
{
if (this.Content.Count >= hiIndex + 1)
{
this.Content[hiIndex] = content;
return(true);
}
else
{
return(false);
}
}
else
{
//int higherIndex = GetHigherContainerIndex(level, index);
if (this.Content.Count >= hiIndex + 1 && lowIndex != null)
{
int lowerIndex = (int)lowIndex;
IContent tempVirtualContainer = this.Content[hiIndex];
if (VirtualContainer.isVirtualContainer(tempVirtualContainer) && ((VirtualContainer)tempVirtualContainer).TryAddContainer(level, lowerIndex))
{
((VirtualContainer)tempVirtualContainer).SetVirtualContainerAtIndex(level, lowerIndex, content);
}
else if (tempVirtualContainer == null) //Frame does not have VC4 to keep lower virtual container levels
{
this.Content[hiIndex] = new VirtualContainer(VirtualContainerLevel.VC4);
tempVirtualContainer = this.Content[hiIndex];
((VirtualContainer)tempVirtualContainer).SetVirtualContainerAtIndex(level, lowerIndex, content);
}
return(true);
}
else
{
return(false);
}
}
}
else
{
return(false);
}
}
return(false);
}
/// <summary>
/// Clears the virtual container.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The number.</param>
/// <returns></returns>
public bool ClearVirtualContainer(VirtualContainerLevel level, int index)
{
if (level == VirtualContainerLevel.VC4)
{
this.Content[index] = null;
}
else
{
IContent tempContainer = this.Content[GetHigherContainerIndex(level, index)];
if (VirtualContainer.isVirtualContainer(tempContainer))
{
((VirtualContainer)tempContainer).SetVirtualContainerAtIndex(level, index, null); //Get specific virtual container lower level
}
}
return(true);
}
private List <ForwardingRecord> createRecord(List <string> literalRecord)
{
int port1 = int.Parse(literalRecord[0]);
int port2 = int.Parse(literalRecord[1]);
int lPath1 = int.Parse(literalRecord[3].Equals("") ? "-1" : literalRecord[3]);
int lPath2 = int.Parse(literalRecord[5].Equals("") ? "-1" : literalRecord[5]);
int hPath1 = int.Parse(literalRecord[4]);
int hPath2 = int.Parse(literalRecord[6]);
VirtualContainerLevel level = VirtualContainerLevelExt.GetContainer(literalRecord[2]);
//StmLevel stm = StmLevelExt.GetContainer(literalRecord[5]);
List <ForwardingRecord> forwardingRecords = new List <ForwardingRecord>();
forwardingRecords.Add(new ForwardingRecord(port1, port2, level, lPath1, lPath2, hPath1, hPath2));
forwardingRecords.Add(new ForwardingRecord(port2, port1, level, lPath2, lPath1, hPath2, hPath1));
return(forwardingRecords);
}
/// <summary>
/// Clears the virtual container.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="hiIndex">The number.</param>
/// <param name="lowIndex">The number.</param>
/// <returns></returns>
public bool ClearVirtualContainer(VirtualContainerLevel level, int hiIndex, int?lowIndex)
{
if (level == VirtualContainerLevel.VC4)
{
this.Content[hiIndex] = null;
}
else
{
if (this.Content.Count >= hiIndex + 1 && lowIndex != null)
{
int lowerIndex = (int)lowIndex;
IContent tempContainer = this.Content[hiIndex];
if (VirtualContainer.isVirtualContainer(tempContainer))
{
((VirtualContainer)tempContainer).SetVirtualContainerAtIndex(level, lowerIndex, null); //Get specific virtual container lower level
}
}
}
return(true);
}
/// <summary>
/// Convert <see cref="ContainerLevel"/> enum to space occupied in <see cref="Frame"/>
/// </summary>
/// <param name="value">The value.</param>
/// <returns></returns>
public static int ContainerSpaceConverter(VirtualContainerLevel value)
{
switch (value)
{
case VirtualContainerLevel.VC12:
return(1);
case VirtualContainerLevel.VC21:
return(3);
case VirtualContainerLevel.VC32:
return(21);
case VirtualContainerLevel.VC4:
return(63);
default:
return(63);
}
}
/// <summary>
/// Gets the relative index for virtual container index position.
/// </summary>
/// <param name="index">The index.</param>
/// <returns></returns>
private int GetRelativeIndex(VirtualContainerLevel level, int index)
{
int returnIndex = -1;
switch (level)
{
case VirtualContainerLevel.VC12:
returnIndex = index - 21 * (GetHigherContainerIndex(level, index));
break;
case VirtualContainerLevel.VC21:
returnIndex = index - 7 * (GetHigherContainerIndex(level, index));
break;
case VirtualContainerLevel.VC32:
returnIndex = index - 3 * (GetHigherContainerIndex(level, index));
break;
default:
returnIndex = index;
break;
}
return(returnIndex);
}
/// <summary>
/// Checks the lower virtual container exists and has lower virtual containers.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
private bool CheckContainerDown(VirtualContainerLevel level, int index)
{
bool returnVal = false;
int contentPosition = GetContainerIndex(level, index);
int childPosition;
if (contentPosition == -1)
{
return false;
}
switch (level)
{
case VirtualContainerLevel.VC12:
if (this.Content[index] != null && ((VirtualContainer)this.Content[index]).Level == VirtualContainerLevel.VC12)
returnVal = false;
else returnVal = true;
break;
case VirtualContainerLevel.VC21:
childPosition = index * 3;
for (int i = childPosition; i < childPosition + 3; i++)
{
if (CheckContainerDown(VirtualContainerLevel.VC12, i))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC21)
returnVal = false;
else returnVal = true;
}
else
{
returnVal = false;
break;
}
}
break;
case VirtualContainerLevel.VC32:
childPosition = index * 7;
for (int i = childPosition; i < childPosition + 7; i++)
{
if (CheckContainerDown(VirtualContainerLevel.VC21, i))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC32)
returnVal = false;
else returnVal = true;
}
else
{
returnVal = false;
break;
}
}
break;
case VirtualContainerLevel.VC4:
childPosition = index * 3;
for (int i = childPosition; i < childPosition + 3; i++)
{
if (CheckContainerDown(VirtualContainerLevel.VC32, i))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC4)
returnVal = false;
else returnVal = true;
}
else
{
returnVal = false;
break;
}
}
break;
}
return returnVal;
}
/// <summary>
/// Checks if upper virtual container exists and has higher level.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
private bool CheckContainerUp(VirtualContainerLevel level, int index)
{
bool returnVal = false;
int contentPosition = contentPosition = GetContainerIndex(level, index);
int parentPostion;
if (contentPosition == -1)
{
return false;
}
switch (level)
{
case VirtualContainerLevel.VC12:
parentPostion = index / 3;
if (CheckContainerUp(VirtualContainerLevel.VC21, parentPostion))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC12)
returnVal = false;
else returnVal = true;
}
else returnVal = false;
break;
case VirtualContainerLevel.VC21:
parentPostion = index / 7;
if (CheckContainerUp(VirtualContainerLevel.VC32, parentPostion))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC21)
returnVal = false;
else returnVal = true;
}
else returnVal = false;
break;
case VirtualContainerLevel.VC32:
parentPostion = index / 3;
if (CheckContainerUp(VirtualContainerLevel.VC4, parentPostion))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC32)
returnVal = false;
else returnVal = true;
}
else returnVal = false;
break;
case VirtualContainerLevel.VC4:
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC4)
returnVal = false;
else returnVal = true;
break;
}
return returnVal;
}
/// <summary>
/// Checks if upper virtual container exists and has higher level.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
private bool CheckContainerUp(VirtualContainerLevel level, int index)
{
bool returnVal = false;
int contentPosition = contentPosition = GetContainerIndex(level, index);
int parentPostion;
if (contentPosition == -1)
{
return(false);
}
switch (level)
{
case VirtualContainerLevel.VC12:
parentPostion = index / 3;
if (CheckContainerUp(VirtualContainerLevel.VC21, parentPostion))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC12)
{
returnVal = false;
}
else
{
returnVal = true;
}
}
else
{
returnVal = false;
}
break;
case VirtualContainerLevel.VC21:
parentPostion = index / 7;
if (CheckContainerUp(VirtualContainerLevel.VC32, parentPostion))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC21)
{
returnVal = false;
}
else
{
returnVal = true;
}
}
else
{
returnVal = false;
}
break;
case VirtualContainerLevel.VC32:
parentPostion = index / 3;
if (CheckContainerUp(VirtualContainerLevel.VC4, parentPostion))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC32)
{
returnVal = false;
}
else
{
returnVal = true;
}
}
else
{
returnVal = false;
}
break;
case VirtualContainerLevel.VC4:
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC4)
{
returnVal = false;
}
else
{
returnVal = true;
}
break;
}
return(returnVal);
}
/// <summary>
/// Tests adding the container to frame space.
/// Check if Virtual Container have TU-space for itself
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
public bool TryAddContainer(VirtualContainerLevel level, int index)
{
bool testUp = false;
bool testDown = false;
switch (level)
{
case VirtualContainerLevel.VC12:
if (this.CheckContainerUp(level, index))
testUp = true;
testDown = true;
break;
case VirtualContainerLevel.VC21:
if (this.CheckContainerUp(level, index))
testUp = true;
if (this.CheckContainerDown(level, index))
testDown = true;
break;
case VirtualContainerLevel.VC32:
if (this.CheckContainerUp(level, index))
testUp = true;
if (this.CheckContainerDown(level, index))
testDown = true;
break;
case VirtualContainerLevel.VC4:
if (this.CheckContainerDown(level, index))
testDown = true;
testUp = true;
break;
}
if (testUp && testDown)
return true;
else return false;
}
/// <summary>
/// Gets the IContent from VirtualContainer at the index.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
public IContent GetVirtualContainerAtIndex(VirtualContainerLevel level, int index)
{
IContent returnValue;
returnValue = this.Content[GetContainerIndex(level, index)];
return returnValue;
}
/// <summary>
/// Sets the content of the content list at index.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <param name="content">The content.</param>
public void SetVirtualContainerAtIndex(VirtualContainerLevel level, int index, IContent content)
{
this.Content[GetContainerIndex(level, index)] = content;
}
/// <summary>
/// Sets the virtual container. This overwrite the <see cref="Content" /> list member.
/// Content must by VirtualContainer!
/// </summary>
/// <param name="level">The level.</param>
/// <param name="hiIndex">Index of the higher level virtual container (VC-4).</param>
/// <param name="lowIndex">Index of the lower level virtual container.</param>
/// <param name="content">The content. Virtual Container</param>
/// <returns>
/// True - success, False - fail
/// </returns>
public bool SetVirtualContainer(VirtualContainerLevel level, int hiIndex, int? lowIndex , IContent content)
{
if (VirtualContainer.isVirtualContainer(content))
{
VirtualContainer contentVC = (VirtualContainer)content;
if (level == contentVC.Level && this.CalculateFreeSpace() >= Frame.ContainerSpaceConverter(level))
{
if (level == VirtualContainerLevel.VC4)
{
if (this.Content.Count >= hiIndex + 1)
{
this.Content[hiIndex] = content;
return true;
}
else return false;
}
else
{
//int higherIndex = GetHigherContainerIndex(level, index);
if (this.Content.Count >= hiIndex + 1 && lowIndex != null)
{
int lowerIndex = (int)lowIndex;
IContent tempVirtualContainer = this.Content[hiIndex];
if (VirtualContainer.isVirtualContainer(tempVirtualContainer) && ((VirtualContainer)tempVirtualContainer).TryAddContainer(level, lowerIndex))
{
((VirtualContainer)tempVirtualContainer).SetVirtualContainerAtIndex(level, lowerIndex, content);
}
else if (tempVirtualContainer == null) //Frame does not have VC4 to keep lower virtual container levels
{
this.Content[hiIndex] = new VirtualContainer(VirtualContainerLevel.VC4);
tempVirtualContainer = this.Content[hiIndex];
((VirtualContainer)tempVirtualContainer).SetVirtualContainerAtIndex(level, lowerIndex, content);
}
return true;
}
else return false;
}
}
else return false;
}
return false;
}
/// <summary>
/// Gets the virtual container.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="hiIndex">Index of the hi.</param>
/// <param name="lowIndex">Index of the low.</param>
/// <returns></returns>
public IContent GetVirtualContainer(VirtualContainerLevel level, int hiIndex, int? lowIndex)
{
IContent returnContent = null;
if (level == VirtualContainerLevel.VC4)
{
if (this.Content.Count >= hiIndex + 1)
{
returnContent = this.Content[hiIndex];
}
}
else
{
if (this.Content.Count >= hiIndex + 1 && lowIndex != null)
{
int lowerIndex = (int)lowIndex;
returnContent = this.Content[hiIndex];
if (VirtualContainer.isVirtualContainer(returnContent))
{
returnContent = ((VirtualContainer)returnContent).GetVirtualContainerAtIndex(level, lowerIndex); //Get specific virtual container lower level
}
}
}
return returnContent;
}
/// <summary>
/// Gets the index of the higher level container.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
private int GetHigherContainerIndex(VirtualContainerLevel level, int index)
{
int returnIndex = -1;
switch (level)
{
case VirtualContainerLevel.VC12:
returnIndex = index / 63;
break;
case VirtualContainerLevel.VC21:
returnIndex = index / 21;
break;
case VirtualContainerLevel.VC32:
returnIndex = index / 3;
break;
case VirtualContainerLevel.VC4:
returnIndex = index;
break;
case VirtualContainerLevel.UNDEF:
break;
}
return returnIndex;
}
/// <summary>
/// Checks the lower virtual container exists and has lower virtual containers.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <returns></returns>
private bool CheckContainerDown(VirtualContainerLevel level, int index)
{
bool returnVal = false;
int contentPosition = GetContainerIndex(level, index);
int childPosition;
if (contentPosition == -1)
{
return(false);
}
switch (level)
{
case VirtualContainerLevel.VC12:
if (this.Content[index] != null && ((VirtualContainer)this.Content[index]).Level == VirtualContainerLevel.VC12)
{
returnVal = false;
}
else
{
returnVal = true;
}
break;
case VirtualContainerLevel.VC21:
childPosition = index * 3;
for (int i = childPosition; i < childPosition + 3; i++)
{
if (CheckContainerDown(VirtualContainerLevel.VC12, i))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC21)
{
returnVal = false;
}
else
{
returnVal = true;
}
}
else
{
returnVal = false;
break;
}
}
break;
case VirtualContainerLevel.VC32:
childPosition = index * 7;
for (int i = childPosition; i < childPosition + 7; i++)
{
if (CheckContainerDown(VirtualContainerLevel.VC21, i))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC32)
{
returnVal = false;
}
else
{
returnVal = true;
}
}
else
{
returnVal = false;
break;
}
}
break;
case VirtualContainerLevel.VC4:
childPosition = index * 3;
for (int i = childPosition; i < childPosition + 3; i++)
{
if (CheckContainerDown(VirtualContainerLevel.VC32, i))
{
if (this.Content[contentPosition] != null && ((VirtualContainer)this.Content[contentPosition]).Level == VirtualContainerLevel.VC4)
{
returnVal = false;
}
else
{
returnVal = true;
}
}
else
{
returnVal = false;
break;
}
}
break;
}
return(returnVal);
}
/// <summary>
/// Gets the virtual container.
/// </summary>
/// <param name="level">The level of Virtual Container</param>
/// <param name="index">The index.</param>
/// <returns></returns>
public IContent GetVirtualContainer(VirtualContainerLevel level, int index)
{
IContent returnContent = null;
if (level == VirtualContainerLevel.VC4)
{
if (this.Content.Count >= index + 1)
{
returnContent = this.Content[index];
}
}
else
{
int higherIndex = GetHigherContainerIndex(level, index);
if (this.Content.Count >= higherIndex + 1)
{
returnContent = this.Content[higherIndex];
if (VirtualContainer.isVirtualContainer(returnContent))
{
returnContent = ((VirtualContainer)returnContent).GetVirtualContainerAtIndex(level, index); //Get specific virtual container lower level
}
}
}
return returnContent;
}
/// <summary>
/// Gets the index of the container. This convert user index for Frame index.
/// VC12 has user index multiplied by 1
/// VC2 has user index multiplied by 3
/// VC3 has user index multiplied by 21
/// VC4 has user index multiplied by 63
/// </summary>
/// <param name="level">The level of Virtual Container</param>
/// <param name="index">The index.</param>
/// <returns></returns>
private int GetContainerIndex(VirtualContainerLevel level, int index)
{
int counter = 0;
int returnValue = -1;
switch (level)
{
case VirtualContainerLevel.VC12:
for (int i = 0; i < Content.Count; i++)
{
if (counter == index)
{
returnValue = i;
}
counter++;
}
break;
case VirtualContainerLevel.VC21:
for (int i = 0; i < Content.Count; i += 3)
{
if (counter == index)
{
returnValue = i;
}
counter++;
}
break;
case VirtualContainerLevel.VC32:
for (int i = 0; i < Content.Count; i += 21)
{
if (counter == index)
{
returnValue = i;
}
counter++;
}
break;
case VirtualContainerLevel.VC4:
for (int i = 0; i < Content.Count; i += 63)
{
if (counter == index)
{
returnValue = i;
}
counter++;
}
break;
case VirtualContainerLevel.UNDEF:
break;
}
return returnValue;
}
/// <summary>
/// Gets the relative index for virtual container index position.
/// </summary>
/// <param name="index">The index.</param>
/// <returns></returns>
private int GetRelativeIndex(VirtualContainerLevel level, int index)
{
int returnIndex = -1;
switch (level)
{
case VirtualContainerLevel.VC12:
returnIndex = index - 21 * (GetHigherContainerIndex(level, index));
break;
case VirtualContainerLevel.VC21:
returnIndex = index - 7 * (GetHigherContainerIndex(level, index));
break;
case VirtualContainerLevel.VC32:
returnIndex = index - 3 * (GetHigherContainerIndex(level, index));
break;
default:
returnIndex = index;
break;
}
return returnIndex;
}
/// <summary>
/// Convert <see cref="ContainerLevel"/> enum to space occupied in <see cref="Frame"/>
/// </summary>
/// <param name="value">The value.</param>
/// <returns></returns>
public static int ContainerSpaceConverter(VirtualContainerLevel value)
{
switch (value)
{
case VirtualContainerLevel.VC12:
return 1;
case VirtualContainerLevel.VC21:
return 3;
case VirtualContainerLevel.VC32:
return 21;
case VirtualContainerLevel.VC4:
return 63;
default:
return 63;
}
}
/// <summary>
/// Clears the virtual container.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The number.</param>
/// <returns></returns>
public bool ClearVirtualContainer(VirtualContainerLevel level, int index)
{
if (level == VirtualContainerLevel.VC4)
{
this.Content[index] = null;
}
else
{
IContent tempContainer = this.Content[GetHigherContainerIndex(level, index)];
if (VirtualContainer.isVirtualContainer(tempContainer))
{
((VirtualContainer)tempContainer).SetVirtualContainerAtIndex(level, index, null); //Get specific virtual container lower level
}
}
return true;
}
/// <summary>
/// Sets the content of the content list at index.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The index.</param>
/// <param name="content">The content.</param>
public void SetVirtualContainerAtIndex(VirtualContainerLevel level, int index, IContent content)
{
this.Content[GetContainerIndex(level, index)] = content;
}
/// <summary>
/// Clears the virtual container.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="hiIndex">The number.</param>
/// <param name="lowIndex">The number.</param>
/// <returns></returns>
public bool ClearVirtualContainer(VirtualContainerLevel level, int hiIndex, int? lowIndex)
{
if (level == VirtualContainerLevel.VC4)
{
this.Content[hiIndex] = null;
}
else
{
if (this.Content.Count >= hiIndex + 1 && lowIndex != null)
{
int lowerIndex = (int)lowIndex;
IContent tempContainer = this.Content[hiIndex];
if (VirtualContainer.isVirtualContainer(tempContainer))
{
((VirtualContainer)tempContainer).SetVirtualContainerAtIndex(level, lowerIndex, null); //Get specific virtual container lower level
}
}
}
return true;
}
