static void Main(string[] args)
{
// Like opening a browser
Workspace w = new Workspace();
// Enables network connections
w.AddURIHandler(new WebSocketURIHandler());
// Get a room
Resource resource = w.Open("ws://localhost:8888/room1");
TSet <string> messages = (TSet <string>)resource.Value;
// A room is a set of messages. Adding a message to a
// set raises the 'Added' event on all clients who
// share the the same URI
// Display messages that get added to the set
messages.Added += s =>
{
Console.WriteLine(s);
};
// Listen for typed messages and add them to the set
Console.Write("my name? ");
string me = Console.ReadLine();
messages.Add("New user: "******": " + s);
}
}
private void lvMemory_RetrieveVirtualItem(object sender, RetrieveVirtualItemEventArgs e)
{
do
{
if (null == this.Image)
{
break;
}
UInt32 tStartAddress = (UInt32)e.ItemIndex * this.LineSize;
ListViewCacheLine tCacheLineItem = m_ListViewCache.Find(tStartAddress.ToString("X8"));
if (null == tCacheLineItem)
{
//! a cache miss
Byte[] tBuffer = new Byte[this.LineSize];
this.Image.Read(tStartAddress, tBuffer);
ListViewItem tItem = new ListViewItem(tStartAddress.ToString("X8"));
tItem.SubItems.Add(HEX.HEXBuilder.ByteArrayToHEXString(tBuffer));
tItem.SubItems.Add(BuildDisplayString(tBuffer));
tCacheLineItem = new ListViewCacheLine(tStartAddress, tItem);
m_ListViewCache.Add(tCacheLineItem);
}
e.Item = tCacheLineItem.Tag;
} while (false);
}
public void TestContains2()
{
TSet <Frac> tset1 = new TSet <Frac>();
tset1.Add(new Frac(1, 2));
tset1.Add(new Frac(2, 3));
tset1.Add(new Frac(3, 4));
Assert.AreEqual(tset1.Contains(new Frac(2, 30)), false);
}
public void TestIsClear()
{
TSet <Frac> tset1 = new TSet <Frac>();
tset1.Add(new Frac(1, 2));
tset1.Add(new Frac(2, 3));
tset1.Add(new Frac(3, 4));
Assert.AreEqual(tset1.IsClear(), false);
}
public void TestRemove()
{
TSet <Frac> tset1 = new TSet <Frac>();
tset1.Add(new Frac(1, 2));
tset1.Add(new Frac(2, 3));
tset1.Add(new Frac(3, 4));
tset1.Remove(new Frac(2, 3));
Assert.AreEqual(tset1.Show(), "1/2 3/4 ");
}
public void TestCount()
{
TSet <Frac> tset1 = new TSet <Frac>();
tset1.Add(new Frac(1, 2));
tset1.Add(new Frac(2, 3));
tset1.Add(new Frac(3, 4));
Assert.AreEqual(tset1.Count(), 3);
}
public void TestFrac()
{
TSet <Frac> tset1 = new TSet <Frac>();
tset1.Add(new Frac(1, 2));
tset1.Add(new Frac(2, 3));
tset1.Add(new Frac(3, 4));
Assert.AreEqual(tset1.ElementAt(1), new Frac(2, 3));
Assert.AreEqual(tset1.ElementAt(0), new Frac(1, 2));
Assert.AreEqual(tset1.ElementAt(2), new Frac(3, 4));
}
public void TestClear()
{
TSet <Frac> tset1 = new TSet <Frac>();
tset1.Add(new Frac(1, 2));
tset1.Add(new Frac(2, 3));
tset1.Add(new Frac(3, 4));
Assert.AreEqual(tset1.Show(), "1/2 2/3 3/4 ");
tset1.Clear();
Assert.AreEqual(tset1.Show(), "");
}
public Boolean TriggerState(SafeID tID)
{
if (!this.Available)
{
return(false);
}
else if (!this.IsActive)
{
return(false);
}
lock (m_Locker)
{
State tTarget = m_FreeStateSet.Find(tID);
if (null != tTarget)
{
if (!tTarget.Available)
{
return(false);
}
if (tTarget.IsFSM)
{
IFSM tFSM = tTarget as IFSM;
if (null == tFSM)
{
return(false);
}
m_FreeStateSet.Remove(tID);
m_ActiveFSMSet.Add(tTarget);
tFSM.Reset();
tFSM.Start();
}
else
{
m_FreeStateSet.Remove(tID);
m_ActiveStateSet.Add(tTarget);
}
}
}
m_StateChanged = true;
RefreshState();
return(true);
}
public void TestExcept()
{
TSet <Frac> tset1 = new TSet <Frac>();
tset1.Add(new Frac(1, 2));
tset1.Add(new Frac(2, 3));
tset1.Add(new Frac(3, 4));
TSet <Frac> tset2 = new TSet <Frac>();
tset2.Add(new Frac(1, 2));
tset2.Add(new Frac(2, 3));
tset2.Add(new Frac(5, 5));
Assert.AreEqual(tset1.Except(tset2).Show(), "3/4 ");
}
public void TestUnion()
{
TSet <Frac> tset1 = new TSet <Frac>();
tset1.Add(new Frac(1, 2));
tset1.Add(new Frac(2, 3));
tset1.Add(new Frac(3, 4));
TSet <Frac> tset2 = new TSet <Frac>();
tset2.Add(new Frac(1, 2));
tset2.Add(new Frac(2, 3));
tset2.Add(new Frac(5, 5));
Assert.AreEqual(tset1.Union(tset2).Show(), "1/2 2/3 3/4 5/5 ");
}
public void TestIntersect()
{
TSet <Frac> tset1 = new TSet <Frac>();
tset1.Add(new Frac(1, 2));
tset1.Add(new Frac(2, 3));
tset1.Add(new Frac(3, 4));
TSet <Frac> tset2 = new TSet <Frac>();
tset2.Add(new Frac(1, 2));
tset2.Add(new Frac(2, 3));
tset2.Add(new Frac(5, 5));
Assert.AreEqual(tset1.Intersect(tset2).Show(), "1/2 2/3 ");
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
// Add an image to the set
TArray <double> position = new TArray <double>(positions.Resource, 2);
Random rand = new Random();
position[0] = rand.Next(100) + 50;
position[1] = rand.Next(100) + 50;
positions.Add(position);
}
//! \brief add component to list
public Boolean Add(String tPath)
{
TType tItem = CreateItem(tPath);
if (!tItem.Available)
{
return(false);
}
else if (null == tItem.Target)
{
return(false);
}
if (m_ComponentSet.Add(tItem) == SET_ADD_RESULT.SET_FAILED)
{
return(false);
}
return(true);
}
private TSet AddAll(TSet set, Symbol symbol)
{
var newSet = new TSet();
foreach (var item in set.Where(i => !i.IsComplete && i.PostDot.Equals(symbol)))
{
newSet.Add(item, item.Next(true));
}
newSet.Close();
return(newSet);
}
private void AddAll(TSet set, Symbol symbol)
{
Debug.Assert(symbol.IsPid);
var newSet = new TSet();
foreach (var item in set.Where(i => !i.IsComplete && i.PostDot.Equals(symbol)))
{
newSet.Add(item, item.Next(true));
}
Todo.Enqueue(newSet);
}
public static void AddNameSpace(String tID)
{
s_NameSpaceSet.Add(new Namespace(tID));
}
public override Status Task(params object[] tArgs)
{
if (!this.Available)
{
return(m_Status);
}
do
{
switch (m_Status)
{
case Status.FSM_STARTING:
m_Status = Status.FSM_WORKING;
break;
case Status.FSM_CLOSING:
case Status.FSM_PENDING:
case Status.FSM_WORKING:
break;
case Status.FSM_ERROR:
case Status.FSM_INVALID:
case Status.FSM_CANCELLED:
case Status.FSM_CLOSED:
case Status.FSM_IDLE:
default:
return(m_Status);
}
//! stop event
if (m_Event.WaitOne(0))
{
lock (m_Locker)
{
foreach (State tItem in m_ActiveStateSet)
{
if (null == tItem)
{
continue;
}
else if (!tItem.Available)
{
continue;
}
if ((tItem.IsActive) || (tItem.Status == Status.FSM_IDLE))
{
tItem.StopSignal.Set();
}
}
foreach (State tItem in m_ActiveFSMSet)
{
if (null == tItem)
{
continue;
}
else if (!tItem.Available)
{
continue;
}
IFSM tFSM = tItem as IFSM;
if (null == tFSM)
{
continue;
}
if ((tFSM.IsActive) || (tFSM.Status == Status.FSM_IDLE))
{
tFSM.RequestStop();
}
}
m_Event.Reset();
}
}
m_StateChanged = false; //!< reset state change flag
lock (m_Locker)
{
State[] tActiveStates = m_ActiveStateSet.ToArray();
foreach (State tItem in tActiveStates)
{
if (null == tItem)
{
continue;
}
else if (!tItem.Available)
{
continue;
}
switch (tItem.Task(m_Args))
{
case Status.FSM_PENDING:
case Status.FSM_CLOSING:
case Status.FSM_STARTING:
case Status.FSM_WORKING:
break;
case Status.FSM_ERROR:
//! encountered an unhandled error
if (ErrorHandler(m_Args))
{
continue;
}
m_Status = Status.FSM_ERROR;
return(m_Status);
case Status.FSM_INVALID:
case Status.FSM_CANCELLED:
case Status.FSM_CLOSED:
case Status.FSM_IDLE:
default:
m_FreeStateSet.Add(tItem);
m_ActiveStateSet.Remove(tItem.ID);
m_StateChanged = true;
break;
}
}
tActiveStates = m_ActiveFSMSet.ToArray();
foreach (State tItem in tActiveStates)
{
if (null == tItem)
{
continue;
}
else if (!tItem.Available)
{
continue;
}
switch (tItem.Task(m_Args))
{
case Status.FSM_ERROR:
m_Status = Status.FSM_ERROR;
return(m_Status);
case Status.FSM_CLOSING:
case Status.FSM_PENDING:
case Status.FSM_STARTING:
case Status.FSM_WORKING:
break;
case Status.FSM_INVALID:
case Status.FSM_CANCELLED:
case Status.FSM_CLOSED:
case Status.FSM_IDLE:
default:
m_FreeStateSet.Add(tItem);
m_ActiveFSMSet.Remove(tItem.ID);
m_StateChanged = true;
IFSM tFSM = tItem as IFSM;
if (null != tFSM)
{
tFSM.Reset();
}
do
{
miniFSM tminiFSM = tItem as miniFSM;
if (null == tminiFSM)
{
break;
}
else if (null == tminiFSM.ReturnStateID)
{
break;
}
this.TriggerFSM(tminiFSM.ReturnStateID, m_Args);
}while (false);
break;
}
}
}
RefreshState();
}while (m_StateChanged);
return(m_Status);
}
