public void TestEncodeList1()
{
//Test1
ListNode list1 = new ListNode();
string source1 = BEncode.StringEncode(list1);
Assert.AreEqual("{}", source1);
//Test2
ListNode list2 = new ListNode();
for (int i = 1; i <= 3; i++)
{
list2.Add(i);
}
string source2 = BEncode.StringEncode(list2);
Assert.AreEqual(source2, "{i1ei2ei3e}");
//Test3
ListNode lh31 = new ListNode();
lh31.Add("Alice");
lh31.Add("Bob");
ListNode lh32 = new ListNode();
lh32.Add(2);
lh32.Add(3);
ListNode list3 = new ListNode(new List <BEncodedNode>(new BEncodedNode[] { lh31, lh32 }));
string source3 = BEncode.StringEncode(list3);
Assert.AreEqual(source3, "{{5:Alice3:Bob}{i2ei3e}}");
}
/// <summary>
/// 处理Reader函数
/// </summary>
/// <param name="cmd">数据库命令</param>
public DictNode HandleReader(DbCommand cmd)
{
DictNode result = new DictNode();
using (DbConnection conn = new SqlConnection(connectionString))
{
conn.Open();
cmd.Connection = conn;
using (DbDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
{
ListNode typeListNode = CreateTypeListNode(rdr);
result.Add("typelist", typeListNode);
ListNode itemsNode = new ListNode();
while (rdr.Read())
{
ListNode itemNode = new ListNode();
for (int i = 0; i < rdr.FieldCount; i++)
{
if (rdr.IsDBNull(i))
{
itemNode.Add(BytesNode.NullBytesNode);
}
else
{
if (IsBinaryType(rdr.GetDataTypeName(i)))
{
itemNode.Add((byte[])rdr.GetValue(i));
}
else
{
itemNode.Add(rdr.GetValue(i).ToString());
}
}
}
itemsNode.Add(itemNode);
}
result.Add("items", itemsNode);
}
}
result.Add("code", 2);
ListNode parmlistNode = CreateParmListNode(cmd);
if (parmlistNode.Count != 0)
{
result.Add("parmlist", parmlistNode);
}
return(result);
}
/*
* Process Method
*/
public override ListNode Process(GroupNode group, ListNode list)
{
if (group.Decorations[MutualExclusionDecision.DECISION_KEY] != null)
{
MutualExclusionDecision d =
(MutualExclusionDecision)group.Decorations[MutualExclusionDecision.DECISION_KEY];
if (d.Handled)
{
return(list);
}
}
if (group.Decorations[ListNodeDecision.DECISION_KEY] != null)
{
return(list);
}
if (group.Labels != null)
{
LabeledListNode item = new LabeledListNode(group.Labels);
item.Group = group;
list.Add(item);
group.Decorations.Add(ListNodeDecision.DECISION_KEY,
new ListNodeDecision(item));
return(item);
}
return(list);
}
private ListNode CreateParmListNode(DbCommand cmd)
{
ListNode result = new ListNode();
foreach (DbParameter para in cmd.Parameters)
{
switch (para.Direction)
{
case ParameterDirection.InputOutput:
case ParameterDirection.Output:
case ParameterDirection.ReturnValue:
DictNode parmNode = new DictNode();
parmNode.Add("name", para.ParameterName);
parmNode.Add("type", para.Value.GetType().ToString());
if (para.Value == DBNull.Value)
{
parmNode.Add("value", BytesNode.NullBytesNode);
}
else if (para.DbType == DbType.Binary)
{
parmNode.Add("value", (byte[])para.Value);
}
else
{
parmNode.Add("value", para.Value.ToString());
}
result.Add(parmNode);
break;
}
}
cmd.Parameters.Clear();
cmd.Dispose();
return(result);
}
/*
* Process Method
*/
public override ListNode Process(GroupNode group, ListNode list)
{
if (group.Decorations[UnitDecision.DECISION_KEY] != null)
{
// get the values that we need
UnitDecision decision =
(UnitDecision)group.Decorations[UnitDecision.DECISION_KEY];
CIOListItemNode item = new CIOListItemNode(decision.CIO);
item.Decorations[GroupDecision.DECISION_KEY] =
new GroupDecision(group);
// determine whether this CIO should be on a panel
bool onPanel = decision.CIO is ControlBasedCIO;
item.Decorations[PanelDecision.DECISION_KEY] =
new PanelDecision(decision, onPanel);
if (onPanel)
{
LabelDictionary labels;
if (decision.CIO is SmartCIO)
{
labels = ((SmartCIO)decision.CIO).Labels;
}
else
{
labels = ((ApplianceState)((StateLinkedCIO)decision.CIO).GetApplObj()).Labels;
}
if (labels != null)
{
PanelListNode pNode = new PanelListNode(labels);
pNode.Add(item);
list.Add(pNode);
}
}
else
{
list.Add(item);
}
}
return(list);
}
public Node ListType()
{
var result = new ListNode()
{
AnchorToken = Expect(TokenCategory.LIST)
};
Expect(TokenCategory.OF);
result.Add(SimpleType());
return(result);
}
/// <summary>
/// 创建类型节点
/// </summary>
/// <param name="rdr">数据库读取器</param>
/// <returns>返回类型节点</returns>
private ListNode CreateTypeListNode(IDataRecord rdr)
{
ListNode result = new ListNode();
for (int i = 0; i < rdr.FieldCount; i++)
{
DictNode columnNode = new DictNode();
columnNode.Add("name", rdr.GetName(i));
columnNode.Add("type", rdr.GetDataTypeName(i));
result.Add(columnNode);
}
return(result);
}
/// <summary>
/// 生成存储过程发送的字节流
/// </summary>
/// <returns>返回发送的字节流</returns>
private byte[] BuildProcMessage(DictNode contentNode)
{
contentNode.Add("text", commandText);
//建立参数列表
if (parameters.Count != 0)
{
ListNode parmsNode = new ListNode();
foreach (DbProxyParameter para in parameters)
{
DictNode parmNode = new DictNode();
parmNode.Add("name", para.ParameterName);
parmNode.Add("type", (int)para.DbType);
switch (para.Direction)
{
case ParameterDirection.Input:
parmNode.Add("value", NodeEncoder.GetValueNode(para));
break;
case ParameterDirection.Output:
parmNode.Add("direction", OutputNum);
break;
case ParameterDirection.InputOutput:
parmNode.Add("direction", InputOutputNum);
parmNode.Add("value", NodeEncoder.GetValueNode(para));
break;
case ParameterDirection.ReturnValue:
parmNode.Add("direction", ReturnValueNum);
break;
}
if (para.Size != 0)
{
parmNode.Add("size", para.Size);
}
parmsNode.Add(parmNode);
}
contentNode.Add("parms", parmsNode);
}
return(BEncode.ByteArrayEncode(contentNode));
}
public static void AddTwoNumbersTest()
{
ListNode l1 = new ListNode(2);
l1.Add(4).Add(3);
ListNode l2 = new ListNode(5);
l2.Add(6);
var res = AlgorithmCenter.AlgorithmCenter191213.AddTwoNumbers(l1, l2);
while (res != null)
{
Console.Write(res.val);
res = res.next;
}
}
private void GetListNode(TreeNodeCollection nodes)
{
foreach (TreeNode node in nodes)
{
string path = (string)node.Tag;
if (!File.Exists(path))
{
GetListNode(node.Nodes);
}
else
{
if (!ListNode.Contains(node.Parent))
{
ListNode.Add(node.Parent);
}
}
}
return;
}
public void MergeTwoSortedListByListNodeTest()
{
ListNode<int> list1 = new ListNode<int>(1);
list1.Add(new ListNode<int>(3));
list1.NextNode.Add(new ListNode<int>(5));
list1.NextNode.NextNode.Add(new ListNode<int>(7));
ListNode<int> list2 = new ListNode<int>(2);
list2.Add(new ListNode<int>(4));
list2.NextNode.Add(new ListNode<int>(6));
list2.NextNode.NextNode.Add(new ListNode<int>(8));
ListNode<int> actual = Algorithm.MergeTwoSortedListByListNode(list1, list2);
ListNode<int> next = actual;
while (next.NextNode != null)
{
Console.WriteLine(next.Value);
next = next.NextNode;
}
Console.WriteLine(next.Value);
}
/*
* Process Method
*/
public override ListNode Process(GroupNode g, ListNode list)
{
// look for MutualExclusionDecisions
object o = g.Decorations[MutualExclusionDecision.DECISION_KEY];
if (o != null && o is MutualExclusionDecision)
{
MutualExclusionDecision d = (MutualExclusionDecision)o;
if (!d.Handled &&
d.State.Type.ValueSpace is EnumeratedSpace)
{
EnumeratedSpace espc = (EnumeratedSpace)d.State.Type.ValueSpace;
if (espc.GetItemCount() == (d.DependencySets.Count - 1))
{
for (int i = 1; i < d.DependencySets.Count; i++)
{
ArrayList dep = (ArrayList)d.DependencySets[i];
if (dep.Count != 1)
{
// Globals.AddLogLine("size! " + dep.Count );
return(list);
}
if (!(dep[0] is EqualsDependency))
{
// Globals.AddLogLine("not equals!");
return(list);
}
}
}
else
{
return(list);
}
// we need a pointer to the GroupNode that contains the state
// variable that we are looking at (because tree manipulations
// will need to use it)
ObjectGroupNode stateGroup = null;
BranchGroupNode bg = (BranchGroupNode)g;
IEnumerator e = bg.Children.GetEnumerator();
while (e.MoveNext())
{
if (e.Current is ObjectGroupNode &&
((ObjectGroupNode)e.Current).Object == d.State)
{
stateGroup = (ObjectGroupNode)e.Current;
break;
}
}
// re-order the tree
ArrayList childOrder = new ArrayList();
bg.Children.Remove(stateGroup);
BranchGroupNode midG = new BranchGroupNode();
midG.Children = bg.Children;
e = midG.Children.GetEnumerator();
while (e.MoveNext())
{
((GroupNode)e.Current).Parent = midG;
}
bg.Children = new ArrayList();
ArrayList dset = (ArrayList)d.ChildSets[0];
if (dset.Count > 0)
{
e = dset.GetEnumerator();
while (e.MoveNext())
{
GroupNode c = (GroupNode)e.Current;
c.Parent = bg;
midG.Children.Remove(c);
bg.Children.Add(c);
}
}
bg.Children.Add(midG);
midG.Parent = bg;
stateGroup.Parent = bg;
for (int i = 1; i < d.ChildSets.Count; i++)
{
dset = (ArrayList)d.ChildSets[i];
if (dset.Count > 1)
{
BranchGroupNode newG = new BranchGroupNode();
newG.Parent = midG;
e = dset.GetEnumerator();
while (e.MoveNext())
{
GroupNode c = (GroupNode)e.Current;
c.Parent = newG;
midG.Children.Remove(c);
newG.Children.Add(c);
}
childOrder.Insert(i - 1, newG);
}
else if (dset.Count == 0)
{
BranchGroupNode newG = new BranchGroupNode();
newG.Parent = midG;
midG.Children.Add(newG);
childOrder.Insert(i - 1, newG);
}
else
{
childOrder.Insert(i - 1, dset[0]);
}
}
d.DependencySets.RemoveAt(0);
// now create StateValueListNodes from the re-orged group tree
// these nodes will be picked up by an additional rule later
// in the generation process
StateValueListNode newList = null;
for (int i = 0; i < childOrder.Count; i++)
{
GroupNode group = (GroupNode)childOrder[i];
ArrayList aryDeps = (ArrayList)d.DependencySets[i];
EqualsDependency eqDep = (EqualsDependency)aryDeps[0];
newList = new StateValueListNode(d.State, eqDep.Value);
list.Add(newList);
group.Decorations.Add(ListNodeDecision.DECISION_KEY, new ListNodeDecision(newList, d));
}
d.Handled = true;
}
}
return(list);
}
/*
* Member Variables
*/
/*
* Constructor
*/
/*
* Process Rule Method
*/
/// <summary>
/// This method checks if for a pattern that looks like
/// ListNode->ListNode(one child)->ListNode and removes the
/// intermediate ListNode.
/// </summary>
public override bool Process(ListItemNode node, UIGenerator ui)
{
// promotion rules can't work on the root node
bool ableToPromote = node.Parent != null;
if (node is ListNode)
{
ListNode listNode = (ListNode)node;
Hashtable panelNodes = new Hashtable(listNode.Items.Count);
IEnumerator e = listNode.Items.GetEnumerator();
while (e.MoveNext())
{
if (e.Current is PanelListNode)
{
//
// ASSUMPTION: All items in a panel node share
// the same parent group
//
GroupDecision d =
(GroupDecision)((ListItemNode)((PanelListNode)e.Current).Items[0]).Decorations[GroupDecision.DECISION_KEY];
if (d != null)
{
ArrayList list = (ArrayList)panelNodes[d.Group.Parent];
if (list == null)
{
list = new ArrayList(listNode.Items.Count);
}
list.Add(e.Current);
panelNodes[d.Group.Parent] = list;
}
}
}
e = panelNodes.Keys.GetEnumerator();
while (e.MoveNext())
{
GroupNode parent = (GroupNode)e.Current;
if (parent.Labels == null)
{
// has no labels, so abort for this group
continue;
}
// create a new PanelNode and move all items into this node
PanelListNode newPanel = new PanelListNode(parent.Labels);
ArrayList list = (ArrayList)panelNodes[parent];
if (list.Count <= 1)
{
continue;
}
IEnumerator panels = list.GetEnumerator();
while (panels.MoveNext())
{
PanelListNode existPanel = (PanelListNode)panels.Current;
IEnumerator items = existPanel.Items.GetEnumerator();
while (items.MoveNext())
{
newPanel.Add((ListItemNode)items.Current);
}
listNode.Remove(existPanel);
}
listNode.Add(newPanel);
}
}
return(false);
}
protected Boundary DelimitedBy(Queue <LexerNode> lexer,
DelimeterParams _params,
ListNode node,
Func <Queue <LexerNode>, AbstractNode> parser)
{
var boundary = new Boundary();
boundary.StartPointer = lexer.Peek();
if (_params.IsStart != null && !_params.IsStart(lexer.Dequeue())) //incorect declaration
{
throw new SyntaxException(lexer.Peek());
}
var blocks = new Queue <LexerNode>();
LexerNode next = null;
var bracket = 1;
do
{
lexer.ThrowIfEmpty(next ?? boundary.StartPointer);
next = lexer.Dequeue();
if (next.Token == LexerTokens.Comment)
{
//OnIgnored(next);
node.Add(new CommentsNode()
{
Lex = next
});
continue;
}
if (_params.IsStart != null && _params.IsStart(next))
{
bracket++;
}
if ((_params.IsSeparator(next) && bracket == 1) || !lexer.Any())
{
if (blocks.Any())
{
node.Add(parser(blocks));
blocks.ThrowIfAny();
}
continue;
}
if (_params.IsStop(next))
{
bracket--;
if (bracket == 0)
{
if (blocks.Any())
{
node.Add(parser(blocks));
blocks.ThrowIfAny();
}
}
}
blocks.Enqueue(next);
} while (bracket != 0 && lexer.Any());
boundary.EndPointer = next;
return(boundary);
}
