static public int GetEnumerator(IntPtr l)
{
try {
System.Collections.Queue self = (System.Collections.Queue)checkSelf(l);
var ret = self.GetEnumerator();
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static int GetEnumerator(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 1);
System.Collections.Queue obj = (System.Collections.Queue)ToLua.CheckObject(L, 1, typeof(System.Collections.Queue));
System.Collections.IEnumerator o = obj.GetEnumerator();
ToLua.Push(L, o);
return(1);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
public override void Draw(Microsoft.DirectX.Direct3D.Device device, Matrix worldMatrix)
{
base.Draw(device, worldMatrix);
device.Transform.World = worldMatrix;
if (points.Count > 1)
{
IEnumerator j = points.GetEnumerator();
j.MoveNext();
Vector3 temp = (Vector3)j.Current;
for (int i = 0; i < points.Count - 1; ++i)
{
j.MoveNext();
MainForm.LineTo(ref device, (Vector3)temp, (Vector3)j.Current, Color.Pink);
temp = (Vector3)j.Current;
}
}
}
///////////////////////////////////////////////////////////////////////////
// IDataStore implementation
public void GetElements(String aContainerID, out IEnumerator aElements)
{
XmlElement container = GetElementById(aContainerID);
if (container == null)
container = mBookmarksDocument.DocumentElement.FirstChild as XmlElement;
int itemCount = container.ChildNodes.Count;
Queue items = new Queue();
for (int i = 0; i < itemCount; ++i)
{
XmlElement currElt = container.ChildNodes[i] as XmlElement;
// If the bookmark does not have an ID, generate one and set it.
if (!currElt.HasAttribute("id") || currElt.GetAttribute("id") == "")
currElt.SetAttribute("id", Bookmarks.GenerateID());
CommandTarget target = new CommandTarget();
target.Label = currElt.GetAttribute("label");
target.AccessKey = currElt.GetAttribute("accesskey");
target.Data = currElt.GetAttribute("id");
target.IsContainer = currElt.HasChildNodes;
target.IconURL = currElt.GetAttribute("icon");
target.IsOpen = currElt.GetAttribute("open") == "true";
items.Enqueue(target);
}
aElements = items.GetEnumerator();
}
// Finds identical subtrees in both trees and skrinks them into XmlDiffShrankNode instances
private void MatchIdenticalSubtrees()
{
Hashtable sourceUnmatchedNodes = new Hashtable( 16 );
Hashtable targetUnmatchedNodes = new Hashtable( 16 );
Queue sourceNodesToExpand = new Queue( 16 );
Queue targetNodesToExpand = new Queue( 16 );
sourceNodesToExpand.Enqueue( _sourceDoc );
targetNodesToExpand.Enqueue( _targetDoc );
AddNodeToHashTable( sourceUnmatchedNodes, _sourceDoc );
AddNodeToHashTable( targetUnmatchedNodes, _targetDoc );
while ( sourceNodesToExpand.Count > 0 ||
targetNodesToExpand.Count > 0 )
{
// Expand next level of source nodes and add them to the sourceUnmatchedNodes hashtable.
// Leave the parents of expanded nodes in the sourceNodesToExpand queue for later use.
{
IEnumerator en = sourceNodesToExpand.GetEnumerator();
while ( en.MoveNext() )
{
XmlDiffParentNode sourceParentNode = (XmlDiffParentNode) en.Current;
Debug.Assert( !sourceParentNode._bExpanded );
sourceParentNode._bExpanded = true;
if ( !sourceParentNode.HasChildNodes )
continue;
XmlDiffNode curSourceNode = sourceParentNode._firstChildNode;
while ( curSourceNode != null )
{
AddNodeToHashTable( sourceUnmatchedNodes, curSourceNode );
curSourceNode = curSourceNode._nextSibling;
}
}
}
// Expand next level of target nodes and try to match them against the sourceUnmatchedNodes hashtable.
// to find matching node.
int count = targetNodesToExpand.Count;
for ( int i = 0; i < count; i++ )
{
XmlDiffParentNode targetParentNode = (XmlDiffParentNode) targetNodesToExpand.Dequeue();
Debug.Assert( !targetParentNode._bExpanded );
if ( !NodeInHashTable( targetUnmatchedNodes, targetParentNode ) ) {
continue;
}
targetParentNode._bExpanded = true;
if ( !targetParentNode.HasChildNodes )
continue;
XmlDiffNode curTargetNode = targetParentNode._firstChildNode;
while ( curTargetNode != null )
{
Debug.Assert( !( curTargetNode is XmlDiffAttributeOrNamespace ) );
// try to match
XmlDiffNode firstSourceNode = null;
XmlDiffNodeListHead matchingSourceNodes = (XmlDiffNodeListHead) sourceUnmatchedNodes[ curTargetNode.HashValue ];
if ( matchingSourceNodes != null ) {
// find matching node and remove it from the hashtable
firstSourceNode = HTFindAndRemoveMatchingNode( sourceUnmatchedNodes, matchingSourceNodes, curTargetNode );
}
// no match
if ( firstSourceNode == null ||
// do not shrink xml declarations and DTD
(int)curTargetNode.NodeType < 0 )
{
if ( curTargetNode.HasChildNodes )
targetNodesToExpand.Enqueue( curTargetNode );
else
curTargetNode._bExpanded = true;
AddNodeToHashTable( targetUnmatchedNodes, curTargetNode );
curTargetNode = curTargetNode._nextSibling;
continue;
}
HTRemoveAncestors( sourceUnmatchedNodes, firstSourceNode );
HTRemoveDescendants( sourceUnmatchedNodes, firstSourceNode );
HTRemoveAncestors( targetUnmatchedNodes, curTargetNode );
// there are no target node descendants in the hash table
// find matching interval - starts at startSourceNode and startTargetNode
XmlDiffNode firstTargetNode = curTargetNode;
XmlDiffNode lastSourceNode = firstSourceNode;
XmlDiffNode lastTargetNode = firstTargetNode;
curTargetNode = curTargetNode._nextSibling;
XmlDiffNode curSourceNode = firstSourceNode._nextSibling;
while ( curTargetNode != null &&
curSourceNode != null &&
curSourceNode.NodeType != XmlDiffNodeType.ShrankNode )
{
// still matches and the nodes has not been matched elsewhere
if ( IdenticalSubtrees( curSourceNode, curTargetNode ) &&
sourceUnmatchedNodes.Contains( curSourceNode.HashValue ) )
{
HTRemoveNode( sourceUnmatchedNodes, curSourceNode );
HTRemoveDescendants( sourceUnmatchedNodes, curSourceNode );
}
// no match -> end of interval
else
break;
lastSourceNode = curSourceNode;
curSourceNode = curSourceNode._nextSibling;
//Debug.Assert( curSourceNode == null || curSourceNode.NodeType != XmlDiffNodeType.ShrankNode );
lastTargetNode = curTargetNode;
curTargetNode = curTargetNode._nextSibling;
//Debug.Assert( curTargetNode == null || curTargetNode.NodeType != XmlDiffNodeType.ShrankNode );
}
if ( firstSourceNode != lastSourceNode ||
firstSourceNode.NodeType != XmlDiffNodeType.Element ) {
ShrinkNodeInterval( firstSourceNode, lastSourceNode, firstTargetNode, lastTargetNode);
}
else {
XmlDiffElement e = (XmlDiffElement)firstSourceNode;
if ( e.FirstChildNode != null || e._attributes != null ) {
ShrinkNodeInterval( firstSourceNode, lastSourceNode, firstTargetNode, lastTargetNode);
}
}
}
}
// Walk through the newly expanded source nodes (=children of nodes in sourceNodesToExpand queue)
// and try to match them against targetUnmatchedNodes hashtable.
count = sourceNodesToExpand.Count;
for ( int i = 0; i < count; i++ )
{
XmlDiffParentNode sourceParentNode = (XmlDiffParentNode) sourceNodesToExpand.Dequeue();
Debug.Assert( sourceParentNode._bExpanded );
if ( !sourceParentNode.HasChildNodes )
continue;
XmlDiffNode curSourceNode = sourceParentNode._firstChildNode;
while ( curSourceNode != null )
{
// it it's an attribute or the node has already been matched -> continue
Debug.Assert( ! ( curSourceNode is XmlDiffAttributeOrNamespace ) ) ;
if ( curSourceNode is XmlDiffShrankNode ||
!NodeInHashTable( sourceUnmatchedNodes, curSourceNode ) )
{
curSourceNode = curSourceNode._nextSibling;
continue;
}
// try to match
XmlDiffNode firstTargetNode = null;
XmlDiffNodeListHead matchingTargetNodes = (XmlDiffNodeListHead) targetUnmatchedNodes[ curSourceNode.HashValue ];
if ( matchingTargetNodes != null ) {
// find matching node and remove it from the hashtable
firstTargetNode = HTFindAndRemoveMatchingNode( targetUnmatchedNodes, matchingTargetNodes, curSourceNode );
}
// no match
if ( firstTargetNode == null ||
// do not shrink xml declarations and DTD
(int)curSourceNode.NodeType < 0 )
{
if ( curSourceNode.HasChildNodes )
sourceNodesToExpand.Enqueue( curSourceNode );
else
curSourceNode._bExpanded = true;
curSourceNode = curSourceNode._nextSibling;
continue;
}
HTRemoveAncestors( targetUnmatchedNodes, firstTargetNode );
HTRemoveDescendants( targetUnmatchedNodes, firstTargetNode );
if ( !HTRemoveNode( sourceUnmatchedNodes, curSourceNode ) )
Debug.Assert( false );
HTRemoveAncestors( sourceUnmatchedNodes, curSourceNode );
// there are no source node descendants in the hash table
Debug.Assert( !( curSourceNode is XmlDiffAttributeOrNamespace ) );
// find matching interval - starts at startSourceNode and startTargetNode
XmlDiffNode firstSourceNode = curSourceNode;
XmlDiffNode lastSourceNode = firstSourceNode;
XmlDiffNode lastTargetNode = firstTargetNode;
curSourceNode = curSourceNode._nextSibling;
XmlDiffNode curTargetNode = firstTargetNode._nextSibling;
while ( curSourceNode != null &&
curTargetNode != null &&
curTargetNode.NodeType != XmlDiffNodeType.ShrankNode )
{
// still matches and the nodes has not been matched elsewhere
if ( IdenticalSubtrees( curSourceNode, curTargetNode ) &&
sourceUnmatchedNodes.Contains( curSourceNode.HashValue ) &&
targetUnmatchedNodes.Contains( curTargetNode.HashValue ) )
{
HTRemoveNode( sourceUnmatchedNodes, curSourceNode );
HTRemoveDescendants( sourceUnmatchedNodes, curSourceNode );
HTRemoveNode( targetUnmatchedNodes, curTargetNode );
HTRemoveDescendants( targetUnmatchedNodes, curTargetNode );
}
// no match -> end of interval
else {
break;
}
lastSourceNode = curSourceNode;
curSourceNode = curSourceNode._nextSibling;
lastTargetNode = curTargetNode;
curTargetNode = curTargetNode._nextSibling;
}
if ( firstSourceNode != lastSourceNode ||
firstSourceNode.NodeType != XmlDiffNodeType.Element ) {
ShrinkNodeInterval( firstSourceNode, lastSourceNode, firstTargetNode, lastTargetNode);
}
else {
XmlDiffElement e = (XmlDiffElement)firstSourceNode;
if ( e.FirstChildNode != null || e._attributes != null ) {
ShrinkNodeInterval( firstSourceNode, lastSourceNode, firstTargetNode, lastTargetNode);
}
}
}
}
}
}
public IEnumerator GetEnumerator()
{
return(m_logQueue.GetEnumerator());
}
private static Hashtable AdjustGenericTypes(Type genericType, Hashtable genInnerTypes, short genTypeHandle, ref Hashtable nestedGenerics, bool throwExceptions)
{
Hashtable genNestedTypes = new Hashtable();
if (genInnerTypes != null)
{
IDictionaryEnumerator ide1 = genInnerTypes.GetEnumerator();
while (ide1.MoveNext())
{
System.Collections.Queue genConcreteTypes = (System.Collections.Queue)ide1.Value;
IEnumerator ide = genConcreteTypes.GetEnumerator();
int genArgsCount = genericType.GetGenericArguments().Length;
Type[] parms = new Type[genArgsCount];
SortedList sortedTypes = new SortedList(genArgsCount);
int index = 0;
short typeHandle = 0;
while (ide.MoveNext())
{
TypeHandlePair thp = (TypeHandlePair)ide.Current;
if (!genNestedTypes.Contains((Type)thp._type) && CheckForBuiltinSurrogate((Type)thp._type))
{
if (!nestedGenerics.Contains((Type)thp._type))
{
nestedGenerics.Add((Type)thp._type, (short)thp._handle);
}
}
if (typeof(Dictionary <,>) == genericType && index == 0)
{
Type typ = typeof(System.Collections.Generic.Dictionary <,>);
if (!nestedGenerics.Contains(typ))
{
nestedGenerics.Add(typ, genTypeHandle);
}
}
if (typeof(List <>).Equals(genericType) && index == 0)
{
Type typ = typeof(System.Collections.Generic.List <>);
if (!nestedGenerics.Contains(typ))
{
nestedGenerics.Add(typ, genTypeHandle);
}
}
if (index == 0 || ((Type)thp._type).IsGenericType)
{
typeHandle = (short)((short)thp._handle - 1);
index++;
}
sortedTypes.Add((short)thp._handle, (Type)thp._type);
}
for (int indx = 0; indx < sortedTypes.Count; indx++)
{
if (indx < parms.Length)
{
parms[indx] = (Type)sortedTypes.GetByIndex(indx);
}
}
Type genType = null;
try
{
genType = genericType.MakeGenericType(parms);
}
catch (Exception ex)
{
if (throwExceptions)
{
string data = "param count : " + parms.Length.ToString() + "\n\n";
for (int i = 0; i < parms.Length; i++)
{
data += " FullName Arg " + i + " : " + ((Type)parms[i]).FullName;
data += " Name Arg " + i + " : " + ((Type)parms[i]).Name + "\n";
}
throw new Exception(genericType.FullName + " can not be registered with compact framework ( ex.Message : " + ex.Message + " ) ex.Tostring() : " + ex.ToString() + "Data:" + data);
}
}
if (genType != null && !genNestedTypes.Contains(genType))
{
typeHandle = GetUniqueHandle(genNestedTypes, nestedGenerics, sortedTypes);
genNestedTypes.Add(genType, typeHandle);
}
}
}
return(genNestedTypes);
}
public override IEnumerator GetEnumerator()
{
lock (queue) {
return(queue.GetEnumerator());
}
}