总结：
07上半年运势还行，暑期4个月积累了点经验，9月到现在凑活。
展望：
08年开始准备发下飙，9月一定要买个车。
——————————————————————————————————————————————————
以上的实在是太简单了。。自己也看不过去。。。
——————————————————————————————————————————————————
07年总结：
这一年基本上是平稳度过的，上半年的事基本上都忘了，暑期4个月，花了3个星期在一个游戏公司里担任了个超级底层的职业（写写随机对白。。。编写任务策划，妈的。。。不就是第一天开个凌志被策划总监撞见了。。。竟让我单枪匹马的把公司上款游戏的资料篇的所有任务都给搞定。。。），不过我的主要目的是去看过程的，手头上工作完成后，基本上把策划/美工这块的流程都看了个透（程序部有独立房间，还有窗帘，啥也看不到）
9月回来后，凑活。。。貌似是只有这个词能形容的了。。。不过，还有很大的空间，所有下学期再加门课玩玩，毕竟难度上也差不多要到头了，早点结束早点完事，这鬼地方越来越不想待了。
08年展望：
元旦前看到BEST BUY那有卖键盘（做音轨用键盘）的，很心动。。。非常想买下来平时无聊练着玩。不过。。。我也该决定主攻的方向了。。。做游戏这行，如果把5个最重要的能力（领导能力，编程，绘画，制作音轨，写剧本）分散布置成个5边形，那最牛X的人就是5能力全满的（不过有可能吗？除非用下修改器-_-!)。如果我过于执着于完美，那估计到头来很可能搞的什么也不是。。。（反正我是一定不做编程的。。。肥哥硬是从软件学院毕业后准备考公务员，我算是明白他怎么想的了）
——————————————————————————————————————————————————
和我一起出国的阿伟明年就能彻底回国了。哎，现在我越来越有感觉，刚一出国，我的人生就像是被击碎成无数个细小的碎片，然后度过那么几年的颓期后又重新凝聚的。那段痛苦的经历，对我而言，沉重，悲惨，教训深刻！但是，却可以说是目前这23年的人生中，最最有价值的2年！疯狂玩上网络游戏，让我从骨灰级玩家到骨灰级游戏开发人员的转变过程变为可能。而且那两年的经历让我学会了如何专注。所以，当我现在要专心于某一件事的时候，会很轻松的就静默自己的情绪，就算周围的环境很嘈杂，也不会对我有什么大的影响。而目前，我缺的是完全开放性的思维能力，或者说是想象力。这和目前自己的能力有很大的关系（脑袋是那么想的，但是手就不知道怎么去实现它），所以，新的一年里，希望在这方面有所突破。
07年在编程上，突破了两个瓶颈，所以实力上升很快，明年的DS，现在有12分的信心去搞定它。越来越觉得，气势是最重要的因素，要变得牛X，就先要强制性的把自己想的牛X！
——————————————————————————————————————————————————
最后，08年，希望国泰民安，家族成员，朋友们身体健康，事业稳定，老妈的项目顺利（这对我有非凡的意义）。
PS：台湾如果要独立了，那就打了得了，也怪双方现在话都放狠了，箭在弦上，不得不发。不过台湾，对中国来说，战略意义远远大于其他的意义，真不知道那些论坛上的独独和运运脑子里怎么想的。。。中国会放任台湾独立，让那个在太空都看的到的巨型航母就一直卡在那么关键的位置上？除非中国以后不想混了。。。
12/30/2007
以下为网易一新闻的某个评论长城：
网易广东惠州网友(59.39.*.*) 的原贴：
哪为什么很多江浙人还要跑到广东打工挣钱.
网易浙江温州网友(218.75.*.*) 的原贴：
因为我们不象广东人那么死要面子，缺钱了就要到处奔波，多吃苦多赚钱。。。。。这点你这个懒人是体会不到的
网易浙江金华网友(60.182.*.*) 的原贴：
同意，懒人是体会不到我们浙商的辛酸。江苏和广东的你们自己看看你们有多少工厂是你们自己人开的就明白了（你们这2个地方出卖了人民的利益，换来了莫须有的GDP，再说了这些GDP是你们自己人创造的吗）。再来我们浙江看看有多少企业不是自己人开的。看看我们浙江什么资源没有，人多地少，国家没有优惠政策，只能靠自己双手，要说全国的富豪浙商钱是最干净的，外省兄弟你们慢慢玩屋里斗吧。我们浙江人到时候赚边全世界你们或许会清醒点。现在我们浙江人想玩的是犹太人，不跟你们一般见识。等你们这些地方有能力去世界各地看看那里的做生意比较成功的华人。做生意当中10个华人，不敢说全部是浙江人，但是绝对有7个是浙江人。你们去欧洲看看，去美国看看，去中东（几乎全部是浙江人）去非洲看看，去南美看看，去澳洲看看，不信可以问问你们身边去过国外的人是不是这样。
网易浙江金华网友(60.182.*.*) 的原贴：
我们浙江人面对是全世界不跟国人一般见识，世界经济（我们不喜欢从政）必将掌握在我们5000万勤劳的浙江人手里。不出30年大家来看看。
网易广东广州网友(121.8.*.*) 的原贴：
温州人在外搞的中国人声誉很贱,有小聪明,但没大智慧.
网易浙江金华网友(60.182.*.*) 的原贴：
这点我们承认，我们会改，谁叫我们站在时代的前沿呢，这点你不会否认吧。
网易广东佛山南海网友(219.135.*.*) 的原贴：
温州人很大胆.但是广东人很少做鸡的.
网易广东肇庆网友(125.90.*.*) 的原贴：
浙江人的确有很多地方值得我们广东人学习，我的确佩服浙江人。你们做品牌我是很佩服的。我们广东的老板还是做代工啊。可悲。你们的产业形态的确比广东高一些。
至于江苏其实是空有架子，苏北和苏南差距大，而且也是代工为主，我们广东暂时不学习江苏。
还有山东，国有经济为主体，人民不富。
希望你们浙江人在原始积累结束后，就不要再做假了，弄得中国人在外的名声不好啊。
也希望你们不要骗了，我和几个浙江人做过生意都被骗了。
我们广东要学习浙江的是升级产业形态。
网易浙江舟山网友(61.153.*.*) 的原贴：
现在作假的基本是福建，不是10年前了，我们淘汰的产业都转移了
网易浙江网友(123.249.*.*) 的原贴：
谁说我们江苏是空架子呀，江苏南北差距是存在，可我们在努力拉近，比如泰州这几年就不错
，其中戴南一个镇的不锈钢产值一年就有４百多亿．最值得骄傲的是江苏自古以来注重教育，是有名的教育大省，不象有的地方一帮土包子！
网易广东东莞网友(58.252.*.*) 的原贴：
别那么自我意淫、相互吹捧好不好！
打工者眼中：江浙一带就是薪水高、治安好！
珠三角那个治安差呀真是想想就怕，工资那是十年如一日啊！
网易广东广州白云网友(219.136.*.*) 的原贴：
晕！那你为什么不去江浙呢？是不是有人不让你走啊？
网易广东广州网友(58.62.*.*) 的原贴：
是中国人就要团结，浙江人，广东人各有各的优点，江苏人，福建人没接触过。
网易贵州毕节网友(58.42.*.*) 的原贴：
沿海地区的人在辩论也,我们深山里的看热闹好拉
网易广东深圳网友(116.77.*.*) 的原贴：
在这里吵这么利害,我只想问一句:不管你是浙江,广东,或还是其他的地方也好,那里面有钱的人是你吗?GDP高就不等于你的收入就高了,醒醒吧.没有任何意义的争吵
网易广西玉林网友(222.83.*.*) 的原贴：
~~~~~三楼的,你说的话就差了,我虽然不是广东的也不是你产江苏浙江的,但你们浙江大把人是走私发起来再转行的,我识的人不少,不要说你们神了,而且全是干净的,打个比方,人家外国的家族集团,几百年下来的积累,为什么中国的几十年就追得上了?好好想想吧,出身干净的人少之又少,不是说没有,但你说得你们浙江过于神了,但很多浙江人民我还是服的,他们的创劲是很多人值得学习.
网易浙江温州网友(125.108.*.*) 的原贴：
富民才是真富！
我们温州月收入低于1000的人和家庭也很多，在这样富的地方，他们就显得更穷了。
网易广东惠州网友(59.33.*.*) 的原贴：
呵呵，浙江绝对是目前国内最具潜力的省份，因为有4500万勤劳勇敢的浙江人，有天下无所不在的浙商。偶也浙江的，在广东。吵来吵去没意思，自己有钱能过上体面的生活才是最重要。
网易广东深圳福田网友(202.104.*.*) 的原贴：
广州人说自己会做生意，温州人笑了；
温州人说自己会做生意，潮州人笑了！
网易宁夏银川网友(124.224.*.*) 的原贴：
确实发展不错，不过不要骂起来了，都说的不错，我们西北你们要给投点资才行，不要光用我们的资源不给钱！你们谁强我们都高兴都是自己人么！
网易山东潍坊网友(122.4.*.*) 的原贴：
山东，不好意思说什么了，因为你们说的都对，真的。
网易广东广州网友(121.32.*.*) 的原贴：
大家富才是真的富！！数字？几十个超级富豪就能拉高很多！哪个省低收入的少才是真的好！！
12/29/2007
这次圣诞去魁北克逛了一圈，总的来说还是可以:
蒙特利尔吃了两顿自助。。。魁北克古城待了1个小时。。。
大部分的时候都是在车上和酒店里。。。
所幸住的酒店都还不错，都有人工的露天温泉。特别是第2天住古堡酒店，在泡温泉的时候天上还飘着大雪花~
光着身子穿个大泳裤衩泡在温泉里，脑袋上的水珠都成了冰碴，抬头看看天上的飘雪，就差杯酒这人生就完美了。。。
就先写这么点吧，照片过两天再更新了~
12/22/2007
在西方世界待久了，时常能听到一些在国内听不到的声音。一开始觉得还挺好玩，不过久而久之，就会觉得，西方所奉行的一切，都是狗屎。
民主，自由，人权。这些个词汇，西方国家一直都挂在嘴边。搞的自己非常清高，就是站在世界顶端，非要对别的国家指手画脚。这种行为实在很令人觉得恶心。照我说，幸好中国有共产党搞一党专政，否则中国仅有的尊严早就被他国给践踏了。民主制？简直就是吃饱了饭没事做！对自己生活水平的提高没有一点帮助。而且，在某些涉及核心利益的问题上，就算国民闹的再凶，该怎么办还是要怎么办。民主，只是个政府欺骗人民的幌子罢了。
反观中国，虽然问题不少，不过在很多方面，独裁的优势还是体现出来了。比如中国目前奉行的国家资本主义，足以令世界上任何一个资本大鳄胆战心惊。留园上有篇文章就举了个很不错的例子：中石油要收购别的石油公司，中国工商银行就站在中石油的后面！如此强大的经济实力，有西方的大财团能与之抗衡吗？
自由。。。这几十年的自由，令加拿大的人变得特别的散漫，毫无责任心。有的时候，我实在不明白，就他们这熊样，竟然有资格来评价中国人在国内的人身自由！？国外严重的消息闭塞，令这群井底之蛙一直生活在自己的世界中。西方对中国取得成就的震惊，完全是他们咎由自取。我的老祖宗2500年前就说了：知己知彼，百战不殆。就现在西方国家，国民的闭塞程度，以后被灭国了也毫无怜悯之处。
在对死刑的态度上，我对西方人的观点完全不能理解。他们只认为死刑是完完全全错误的，但他们却对被执行人所犯下的罪恶又视而不见。在这群呆瓜的眼中：剥夺一个罪有应得的罪犯的生存权是不可原谅的，反而要用纳税人的钱把那个罪犯好生养在监狱里，养一辈子！如果中国政府参照了他们的做法，那中国不知道会乱成什么样子！照我说，死刑绝不能废，反而要恢复些极端残酷的刑罚。正所谓乱世出重典，只有这样才能强行抑制下现在居高不下的犯罪率。
另外，在主权问题上，中国是不容挑衅的。清末以来，中国已经丢了不少领土了。。。但是，从现在开始，将不再会容忍一丁点的领土被分裂出去。很多西方国家，就好比傻比云集的加拿大，对领土问题一点都不在意！哈珀执政下，魁北克成了加拿大的国中国！但是，令我不能容忍的是：加拿大自己对领土无所谓的态度，一定要强加给别的国家！这就好比：一个人自己要当傻比，当了傻比后还要别人和他一起当傻比！真不知道应该说这个是强盗逻辑呢还是应该说成傻比逻辑。。。
更令我无法忍受的是：有不少中国人出来后，竭尽所能诋毁中国的一切，甚至到了令人发指的程度。。。对这些人，我能说的只有一个字：贱！！你们老老实实待在国外行啦，现在的中国人自己都长眼睛长脑袋，有辨别的能力，你们说什么，都是没用的。。。省着点力气等死得了，别吃力不讨好了。。。
我，其实是个彻头彻尾的民族主义者。我一直都觉得：人和人是不平等的，而且这是个弱肉强食的世界，只有表现出足够斗争欲的人，才能一直很有尊严的生存下去。我只会尊重那些值得尊重的人，并在自己力所能及的范围内相对无私的帮助些需要帮助的人。当然，是在不影响自己的前提下（不过对一些很不错的人，牺牲下自己也是无所谓的）。
12/20/2007
这4个月，过的。。。又点累。。。
先说分。。。
本来很多期待拿A+的课，却都反到在关键时刻痿。。。比如drawing 1, 平时分（占总分70%）的平均分拿到了92，但是FINAL（30%），一下就把总分拉到了80刚刚出头，也就是刚A-的样子。。。（其实FINAL也没辙，整篇考试，很多题目都是在题目，选项完全看懂的情况下瞎懵。。。怪不得考后没有几个人是不骂教授的！想我在绘画上拥有这般专业级的技巧。。。最后竟差点混到B+去了。。。）
OOP也是，我在它的前一个级别课程：Introduction to programming很轻松的拿到了A+，本想这个也应该可以拿个A+的。。。可没想在midterm的时候竟然来了25%的理论题。。。（cheat sheet是可以用的，可我那时候什么概念都没抄下来。。。）分数可想而之，刚刚70%出出头。这样一来，在教授不提分的情况下，我FINAL和最后份作业要全拿满分，才可以勉勉强强拿个A+。。。不过都拿满是不可能的。。。所以，这课最后的GRADE最有可能还是A-。
DM应该能拿A+,IT的话也差不多是个A-，这样一来，今年最有希望拿A+的四门课，竟然有2门在阴沟里翻船了。。。哎。。。不过，MARKETING竟然简单的出乎我的意料，我们那个组（全华班），不出意外应该都能拿到A（A+就不去想了）。所以，这学期的GPA能上3.8，真的要谢天谢地了！
下学期的课里，有3门很难的课：Data Structure(编程里老祖宗级别的课), IT project management(想想就觉得难), 还有门sound & audio(专门玩音频制作的). 而graphic design的教授和drawing 1是同一个人，所以。。。能拿上A-真的就很不错很不错了。。。
而明年9月份，还要修drawing 2。。。我一个以前ItE的队友说：那课就是牛屎。。。作业是编程，考试是数学，打着绘画的名号却一点不关绘画的事。唯一靠点边的就是会用MAYA这款3D建模软件。。。我狂吐。。。这样一来，我明年9月份很可能会一学期里修上5门编程的课。。。今年一门OOP的A3&4, 就让我脑门上暴了3个痘，明年这个时候，估计连门都不敢出了！
再说圣诞的打算：
26号去加东泡温泉，泡到29号回来准备准备迎接本命年的到来（不过理论上应该是春节后才是真正的本命年）。之前这几天有很多想法想付诸实践，比如练下PS手绘的风格技巧，玩会MAYA的3D建模，不过已经2天过去了。。才刚刚安上个数位板驱动（时间都浪费在仙剑4上了，呵呵。。。不过以后做游戏么，游戏总要多玩的~~）学期还没结束的时候，我一边编着OOP的作业，一边想着自学下VC++的编程，寒假里编点有意思的WIN应用程序出来，不过现在的进度看来，这一理想又要无限期压后了。。。
最后：
因为某些不可抗拒的现实原因，我未来的左后手和他老婆黄了。。。这几天看他QQ后面拖着个OVER的签名，觉得闷闷的，哎。。。不过将来锐剑网络的CIO，总不用担心女人的问题的吧，呵呵
12/19/2007
OOP最后份作业，虽然过程很艰巨。。。但是好歹还是完成了~真TMD有成就感啊，哈哈~~
这是个简单的C/S模拟，也就是服务器和客户端之间最最基本的功能的实现。理论上来说，这个应该是用stock技术来实现的，可是那个变态的教授竟要我们来手工模拟这个东西。。。虽说这个网络要实现起来不难，不过。。。一旦换成用手工的方式来做，就很难，而且很烦了。。。
整个代码结构：
Inferface：
网络节点部分：
<Server.h>,<Client.h>,<Router.h>,<NetworkNode.h>
网络节点容量，地址分配，数据包：
<Buffer.h>,<AddressManager.h>,<Packet.h>
传输路径：
<RoutingTable.h>
预防错误机制：
<Exception.h>,<InvalidIndexException.h>,<OverflowException.h>,<InvalidIndexException.h>,<UnderflowException.h>
公用命令：
<common.h>
Implemention:
与上面头文件一一对照：
<UnderflowException.cpp>,<Server.cpp>,<Router.cpp>,<Packet.cpp>,<OverflowException.cpp>,<NetworkNode.cpp>,
<InvalidIndexException.cpp>,<Exception.cpp>,<common.cpp>,<Client.cpp>,<Buffer.cpp>,<AddressManager.cpp>
#include "UnderflowException.h"
using namespace simulation;
UnderflowException::UnderflowException(void)
: Exception("Underflow error")
{
}
UnderflowException::~UnderflowException(void)
{
}
#include "Server.h"
using namespace simulation;
Server::Server(int buffSize)
: NetworkNode(buffSize)
{
se = new m_server;
}
Server::~Server(void)
{
delete se;
}
void Server::processOneStep()
{
cout << "Server at address " << getAddress() << " processing one step." << endl;
if( isWaiting() )
{
while (isWaiting())
{
Packet& p1 = receive();
if (p1.getSourceAddress() != getAddress())
{
cout << "Server: buffered packet waiting to be received." << endl;
cout << "Server: packet information: " << endl;
cout << p1.toString() << endl;
if( p1.getDestinationAddress() == getAddress() )
{
cout << "Server: packet received correctly." << endl;
cout << "Server: well done!" << endl;
Packet reply;
reply.setDestinationAddress(p1.getSourceAddress());
reply.setSourceAddress(getAddress());
reply.setData("### THIS IS A REPLY DATA PACKET ###");
acceptDelivery(reply);
send(reply);
}
else
{
cout << "Receiver: PACKET ROUTED INCORRECTLY !!" << endl;
}
}
else
{
putReplyIntoQueue(p1);
}
}
}
else
{
cout << "Server: idle." << endl;
}
}
void Server::putReplyIntoQueue(Packet& reply)
{
se->push(reply);
}
#include "Router.h"
using namespace simulation;
// Construct a Router node with buffer of capacity `buffSize'
Router::Router(int buffSize)
: NetworkNode(buffSize)
{
}
// Destructor
Router::~Router(void)
{
}
// Do one step of processing.
// This implementation is specific to a Router.
void Router::processOneStep()
{
cout << "Router at address " << getAddress() << " processing one step." << endl;
if( isWaiting() )
{
cout << "Router: another packet to be routed." << endl;
// retrieving the waiting packet from the buffer.
Packet& p = receive();
cout << "Router: packet information: " << endl;
cout << p.toString() << endl;
// attempting to send to destination.
send(p);
}
else
{
cout << "Router: nothing to do." << endl;
}
}
#include "Packet.h"
using namespace simulation;
// Default constructor.
Packet::Packet(void)
: m_hopCount(0),
m_sourceAddress(0),
m_destinationAddress(0),
m_data("")
{
m_nextIDAvailable++;
m_ID = m_nextIDAvailable;
}
// Default COPY constructor.
Packet::Packet(const Packet& p)
{
m_hopCount = p.m_hopCount;
m_sourceAddress = p.m_sourceAddress;
m_destinationAddress = p.m_destinationAddress;
m_ID = p.m_ID;
m_data = p.m_data;
}
// Destructor
Packet::~Packet(void)
{
}
// static member that keeps track of ID's to give out.
int Packet::m_nextIDAvailable = 0;
// returns a string representation of the packet.
string Packet::toString() const
{
string s;
s+="\tPacket ID# "; s+= to_string(getID()); s+= " -- Information"; s+= "\n";
s+="\tSource Addr: "; if( m_sourceAddress ) s+= to_string(getSourceAddress()); else s+= "(undefined)";
s+= "\n";
s+=" \tDest Addr: "; if( m_destinationAddress ) s+= to_string(getDestinationAddress()); else s+= "(undefined)";
s+= "\n";
s+="\tHop Count: " + to_string(getHopCount()) + "\n";
s+="\tData: \""; s+=getData(); s+="\"\n";
return s;
}
#include "OverflowException.h"
using namespace simulation;
OverflowException::OverflowException(void)
: Exception("Overflow error")
{
}
OverflowException::~OverflowException(void)
{
}
#include "NetworkNode.h"
#include "addressmanager.h"
using namespace simulation;
// Constructor. Create network node with buffer of size `bufferSize'
NetworkNode::NetworkNode(int bufferSize)
: m_address(NO_ADDRESS)
{
m_routingTable = new RoutingTable;
m_buffer = new Buffer(bufferSize);
assert( !hasAddress() );
}
// Destructor.
NetworkNode::~NetworkNode(void)
{
delete m_buffer;
delete m_routingTable;
}
// Get address of this network node.
int NetworkNode::getAddress() const
{
assert( hasAddress() );
return m_address;
}
// Set address of this network node. Can only pass a valid address,
// and can only use this method once.
void NetworkNode::setAddress(int address)
{
// Can only call this function if `m_address' was zero, as initialized.
assert( ! hasAddress() );
// Can only pass an address greater than zero and less than 256
assert( NO_ADDRESS < address && address <= MAX_ADDRESS );
m_address = address;
}
// Returns true if and only if an address was set.
bool NetworkNode::hasAddress() const
{
return m_address != NO_ADDRESS;
}
// Contact the AddressManager and tries to obtain an unassigned address.
void NetworkNode::requestAddress()
{
AddressManager* theAddressManager = AddressManager::getInstance();
if( theAddressManager->hasFree() )
{
int nextFree = theAddressManager->getNextFree();
theAddressManager->reserve(nextFree);
assert( ! theAddressManager->isFree(nextFree) );
setAddress( nextFree );
}
}
// Return true if and only iff the address `addr' has an entry.
bool NetworkNode::hasRoutingTableEntry( int addr )
{
// return whether or not m_routingTable has the address `addr'
return m_routingTable->has(addr);
}
// Accept delivery of a data packet `packet' either for routing or for consumption.
// May throw an exception if this NetworkNode's buffer overflows!
void NetworkNode::acceptDelivery(Packet& packet) throw (...)
{
assert( hasAddress() );
// Increment the hop count on the packet.
packet.incrementHopCount();
m_buffer->insert(packet);
}
// Return a pointer to the neighboring NetworkNode object associated with the address `addr'.
NetworkNode* NetworkNode::getRoutingTableEntry( int addr )
{
assert( NO_ADDRESS < addr && addr <= MAX_ADDRESS );
return m_routingTable->lookUp(addr);
}
// Add one entry to this NetworkNode's routing table. The entry consists of a valid address
// `addr' and a pointer to the NetworkNode object that represents the neighboring node
// that is on the path towards the node that actually has the address `addr'.
void NetworkNode::addRoutingTableEntry( int addr, NetworkNode* neighbor )
{
assert( NO_ADDRESS < addr && addr <= 255 );
m_routingTable->add(addr,neighbor);
}
// Send a packet off towards its destination address. The packet's destination address can't
// be the same as the current node.
void NetworkNode::send(Packet& packet)
{
assert( hasAddress() );
assert( m_address != packet.getDestinationAddress() );
NetworkNode* neighbor = m_routingTable->lookUp( packet.getDestinationAddress() );
cout << "NetworkNode: send(): attempting delivery to neighbor with address " << neighbor->getAddress() << endl;
try
{
neighbor->acceptDelivery( packet );
cout << "NetworkNode: send(): packet delivered to neighbor." << endl;
}
catch( OverflowException e )
{
cout << "NetworkNode: send(): BUFFER OVERFLOW ON NEIGHBORING NODE! DROPPING PACKET!" << endl;
}
}
// Remove the next packet from the buffer
Packet NetworkNode::receive() throw (...)
{
assert( hasAddress() );
Packet result = m_buffer->getFront();
m_buffer->remove();
return result;
}
// Get the number of entries in the routing table.
int NetworkNode::getRoutingTableCount() const
{
return m_routingTable->getSize();
}
// Output the current state of the network node n.
string NetworkNode::toString() const
{
string s;
s += " Address: ";
if( hasAddress() ) s+= to_string(getAddress()); else s+= "(none)";
s += "\n";
s += " Buffer State: "; s+= ( isWaiting() ? "waiting." : "idle." ); s+= "\n";
s += " Buffer Count: "; s+= to_string( m_buffer->getSize() ); s+= "\n";
s += " Buffer Capacity: "; s+= to_string( m_buffer->getCapacity() ); s+= "\n";
if( isWaiting() )
{
s += " Packet at Front of Buffer: \n";
s += m_buffer->getFront().toString();
s += "\n";
}
return s;
}
#include "InvalidIndexException.h"
using namespace simulation;
InvalidIndexException::InvalidIndexException(void)
: Exception("Invalid test index error")
{
}
InvalidIndexException::~InvalidIndexException(void)
{
}
#include "Exception.h"
using namespace simulation;
Exception::~Exception(void)
{
}
#include "common.h"
string to_string( const int& i )
{
char buffer[512];
sprintf_s(buffer,"%d",i);
return string(buffer);
}
string to_string( const float& f )
{
char buffer[512];
sprintf_s(buffer,"%.f",f);
return string(buffer);
}
string to_string( const bool& b )
{
return string( b? "true" : "false" );
}
#include "Client.h"
#include "common.h"
using namespace simulation;
Client::Client(int buffSize)
: NetworkNode(buffSize)
{
cs = new m_client;
}
Client::~Client(void)
{
delete cs;
}
void Client::processOneStep()
{
cout << "Client at address " << getAddress() << " processing one step." << endl;
if( isWaiting() )
{
while ( isWaiting())
{
Packet& p = receive();
if ( p.getDestinationAddress() == getAddress())
{
cout << "Client: Receive a reply data packet!" << endl;
cout << "Client: packet information: "<<endl;
cout << p.toString() << endl;
}
else
{
putPacketIntoQueue(p);
}
}
if (!cs->empty())
{
acceptDelivery(getPacketFromQueue());
cout << "Client: another request data packet to be transmitted." << endl;
Packet& requestP = receive();
requestP.setSourceAddress( getAddress() );
cout << "Client: packet information: " << endl;
cout << requestP.toString() << endl;
send(requestP);
}
else
{
cout << "Client: Client is idle." << endl;
}
}
else if ( !isWaiting() && !cs->empty())
{
cout << "Client: Client is waiting for a reply data packet." << endl;
}
else
{
cout << "Client: Client is idle." << endl;
}
}
void Client::putPacketIntoQueue(Packet& request)
{
cs->push(request);
}
Packet Client::getPacketFromQueue()
{
Packet result;
result = cs->front();
cs->pop();
return result;
}
#include "Buffer.h"
using namespace simulation;
// Constructor: create a buffer that can hold up to `capacity' packets.
Buffer::Buffer(int capacity)
: m_capacity(capacity)
{
assert(capacity>0);
}
// Destructor.
Buffer::~Buffer(void)
{
}
// pushes a packet `p' onto the back of the buffer if the buffer is not full.
// Throws an Exception if the buffer is full (buffer overflow)
void Buffer::insert( const Packet& p ) throw (...)
{
// Leave in this Exception throw!
if( isFull() )
throw OverflowException();
m_queue.push(p);
}
// returns a reference to the packet at the front of the buffer.
// Throws an Exception if the buffer is empty (buffer underflow)
Packet Buffer::getFront() const throw (...)
{
// Leave in this Exception throw!
if( isEmpty() )
throw UnderflowException();
return m_queue.front();
}
// pops whatever packet is sitting at the front of the buffer if the buffer is not empty.
// Throws an Exception if the buffer is empty (buffer underflow)
void Buffer::remove() throw (...)
{
// Leave in this Exception throw!
if( isEmpty() )
throw UnderflowException();
m_queue.pop();
}
// returns the size of the buffer.
int Buffer::getSize() const
{
return m_queue.size();
}
// returns whether or not the buffer is empty.
bool Buffer::isEmpty() const
{
return getSize() == 0;
}
// returns whether or not the buffer is full.
bool Buffer::isFull() const
{
return getSize() == getCapacity();
}
#include "AddressManager.h"
using namespace simulation;
AddressManager::AddressManager(void)
{
m_freeAddressTable[NO_ADDRESS] = false; // Address NO_ADDRESS is always reserved.
for( int i=1; i<=MAX_ADDRESS; i++ )
m_freeAddressTable[i] = true; // true means it's free.
}
AddressManager::~AddressManager(void)
{
}
AddressManager* AddressManager::getInstance()
{
if (m_theAddressManager == NULL)
m_theAddressManager = new AddressManager;
return m_theAddressManager;
}
AddressManager* AddressManager::m_theAddressManager = NULL;
// Find out the first address that's available.
int AddressManager::getNextFree()
{
assert( hasFree() );
for(int i=0; i<=MAX_ADDRESS; i++ )
if( isFree(i) ) return i;
assert(false); // should never happen.
return -1;
}
bool AddressManager::hasFree()
{
for(int i=0; i<=MAX_ADDRESS; i++ )
if( isFree(i) ) return true;
return false;
}
bool AddressManager::isFree(int address)
{
assert( NO_ADDRESS <= address && address <= MAX_ADDRESS );
return m_freeAddressTable[address];
}
void AddressManager::reserve(int address)
{
assert( NO_ADDRESS <= address && address <= MAX_ADDRESS );
assert( isFree(address) );
m_freeAddressTable[address] = false;
}
void AddressManager::release(int address)
{
assert( NO_ADDRESS <= address && address <= MAX_ADDRESS );
assert( ! isFree(address) );
m_freeAddressTable[address] = true;
}
#pragma once
#include "exception.h"
#include "common.h"
namespace simulation
{
class UnderflowException :
public Exception
{
public:
UnderflowException(void);
virtual ~UnderflowException(void);
};
};
Tools 
