void Node::PacketGenerating(int time){//节点是否产生数据包，以及能量消耗
if(m_Battery->GetEnergyGrade() <= 0){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<<"电池耗尽啦><"<<endl;
outLogFile.close();
return;
}
double pos = (double) (rand() + 1) / (double)RAND_MAX;
if(time % SENSE_DURATION == 1){//因为是从第一秒开始计算的么
if(pos <= POSIBILITY_PACKET_GENERATING){//产生数据包
bufferedPackets.push(Packet(id, MAX_TIME));
}
if(currentWorkState == Sleeping){
return;
}
int i = 0;
while(!bufferedPackets.empty() && i < MAX_PACKETS_PER_SLOT){
//RoutingWithBufferedPackets();
bufferedPackets.pop();
++i;
}
if(bufferedPackets.empty() && currentState == NonGatewayNode){
pos = (double) (rand() + 1) / (double)RAND_MAX;
if(pos <= POSIBILITY_PACKET_GENERATING){
currentWorkState = Sleeping;
workingTime = 0;
relaxingTime = 0;
}
}
}
}
void CmpMemoryMonitor::setLogFilename(const char *logFilename)
{
if(logFilename)
{
// Clean up file name and stream since we are changing the
// output filename.
fileCleanUp();
setIsMemMonitor(TRUE);
logFilename_ = new(heap_) char[strlen(logFilename)+1];
strcpy(logFilename_, logFilename);
// Initialize the log file and write appropriate headers.
ofstream outLogFile(logFilename_);
outLogFile.width(19); outLogFile << "";
outLogFile << "Memory Usage Information for SQL/MX Compiler" << endl;
outLogFile.width(23); outLogFile << "" << " ";
outLogFile.width(11); outLogFile << "StmtH Alloc" << " ";
outLogFile.width(15); outLogFile << "StmtH HgWtrMark" << " ";
outLogFile.width(11); outLogFile << "CxtH Alloc" << " ";
outLogFile.width(15); outLogFile << "CxtH HgWtrMark" << endl;
outLogFile.close();
// Now open the file stream to append memery usage data as we get it.
logFilestream_ = new(heap_) ofstream(logFilename_, ios::app);
}
}
bool Node::ForcedSleep(){
assert(currentWorkState == Receiving);
//assert(relaxingTime == 0);
if(currentState == GatewayNode){
//如果gateway节点，要导致邻居节点重新选择啦
for(size_t i = 0; i < neighbors.size(); ++i){
if(nodes[neighbors[i]]->IsGatewayNodeOrNot() == NonGatewayNode){
//
/*if(!nodes[neighbors[i]]->routingTable.size()){
nodes[neighbors[i]]->UpdateRoutingTable();
}*/
assert(nodes[neighbors[i]]->routingTable.size());
if(nodes[neighbors[i]]->routingTable[0].destination != id && nodes[nodes[neighbors[i]]->routingTable[0].destination]->GetNodeWorkState() == Receiving){
continue;
//这个邻居节点本来就不用自己来转发节点，自己睡不睡，人家一点都不关心
}
double bestGatewayNodeCondition = 0.0;
RoutingEntry entry;
for(size_t j = 0; j < nodes[neighbors[i]]->GetNeighbors().size(); ++j){
if(nodes[ nodes[neighbors[i]]->GetNeighbors()[j]]->IsGatewayNodeOrNot() == GatewayNode
&&nodes[ nodes[neighbors[i]]->GetNeighbors()[j]]->GetId() != id
&& nodes[nodes[neighbors[i]]->GetNeighbors()[j]]->GetNodeWorkState() == Receiving){
if(nodes[nodes[neighbors[i]]->GetNeighbors()[j]]->GetBattery()->GetEnergyGrade() > bestGatewayNodeCondition){
bestGatewayNodeCondition = nodes[nodes[neighbors[i]]->GetNeighbors()[j]]->GetBattery()->GetEnergyGrade();//暂时就先选择一个吧
entry.destination = nodes[neighbors[i]]->GetNeighbors()[j];
entry.nextHop = entry.destination;
entry.distance = 1;
}
}
}
if(bestGatewayNodeCondition == double(0)){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"NonGateway节点"<<neighbors[i]<< "在邻居节点"<<id<<" Sleep后孤立"<<endl;
outLogFile.close();
return false;//有一个节点是不连通，fail to get a dominating set,网络瘫痪
}else{
if(routingTable.size()){
routingTable[0].destination = entry.destination;
routingTable[0].nextHop = entry.nextHop;
}else{
routingTable.push_back(entry);
}
}
}
//else情况下，可能发生的情况是：
//邻居的gateway节点可能需要当前节点转发消息，可是当前节点处于睡眠状态，不能参与转发,其他没有妨碍吧
}
}
//else情况下，在实际的网络中，节点在睡之前通知一下邻居节点，使得邻居节点在进行状态抉择的时候不要把自己忘记啦
//节点在sleep阶段错过的消息，会在节点醒来的时候，重新收集一下
return true;
}
void Node::MakeSureIsGatewayNodeOrNot(){//确定自己是否是gateway node,只是初步确定而已
assert(currentWorkState == Receiving);
//assert(relaxingTime == 0);
if(m_Battery->GetEnergyGrade() <= 0){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<<"电池耗尽啦><"<<endl;
outLogFile.close();
return;
}
if(neighbors.size() == 0){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<< "孤立"<<endl;
outLogFile.close();
return;//有一个节点是不连通，fail to get a dominating set,网络瘫痪
}
if(neighbors.size() == 1){//即使这个唯一的邻居已经是gateway节点啦，可以在furtherdecision中进行比较选择比较合理的一个
currentState = GatewayNode;
return;
}
currentState = NonGatewayNode;
for(size_t i = 0; i < neighbors.size(); ++i){//Node 0是sink节点，我们约定sink节点
size_t j = 0;
for(; j < neighbors.size(); ++j){
if(neighbors[i] == neighbors[j]){
continue;
}
if(DIS(nodes[neighbors[i]]->GetXLoc(), nodes[neighbors[i]]->GetYLoc(),nodes[neighbors[j]]->GetXLoc(), nodes[neighbors[j]]->GetYLoc()) >= nodes[neighbors[i]]->GetTransDis()){
//实现通信距离的不对称， 如果该节点的两个节点没有直接通信，则该节点就应该标记为gateway node
currentState = GatewayNode;
break;
}
}
if(j < neighbors.size()){
break;
}
}
}
void Node::AddTime(){//增加距离上次作为gateway node工作的休息时间，
if(id == 0){
workingTime++;
totalWorkTime++;
return;//作为sink节点，要一直工作
}
switch(currentWorkState){
case Receiving:
workingTime++;
totalWorkTime++;
if(currentState == NonGatewayNode && workingTime >= MAX_WORK_TIME){
//导致其他的邻居
/*if(ForcedSleep()){
currentWorkState = Sleeping;
currentState = WhoKnows;
//在睡着之前给所有的邻居节点发送信息。
relaxingTime = 0;
workingTime = 0;
}
*/
currentWorkState = Sleeping;
currentState = WhoKnows;
//在睡着之前给所有的邻居节点发送信息。
relaxingTime = 0;
workingTime = 0;
}
break;
case Sleeping:
relaxingTime++;
if(relaxingTime >= THRESHOLD){
//确定需不需要醒过过来
relaxingTime = 0;
workingTime = 0;
currentWorkState = Receiving;
WakeupAfterSleep();
}
break;
default:
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"CurrentWorkStatus Error"<<endl;
outLogFile.close();
}
}
void Node::Routing(){//路由，确定数据包在路由阶段经过哪些节点，相应节点就需要能量减少
if(currentWorkState == Sleeping){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<<"处于睡眠状态怎么能路由呢><"<<endl;
outLogFile.close();
return;
}
if(m_Battery->GetEnergyGrade() <= 0){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<<"电池耗尽啦><"<<endl;
outLogFile.close();
return;
}
allNodesOfForwardedPacket.push(id);
allNodesOfForwardedPacket.push(-1);
Node* currentNode = NULL;
while(allNodesOfForwardedPacket.front() != -1){
if(hop > MAX_TIME){
//TTL expired
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"数据包TTL过期"<<id<<endl;
outLogFile.close();
return;
}
currentNode = nodes[allNodesOfForwardedPacket.front()];
//currentNode->SetNodeWorkStatus(Receiving);
assert(currentNode->GetNodeWorkState() == Receiving);
size_t i = 0;
size_t j = 0;
for(i = 0; i < currentNode->domainMembers.size(); ++i){
if(currentNode->GetDomainMembers()[i] == 0){//暂定sink节点Id为0
//找到该sink节点
//nodes[currentNode->domainMembers[i]]->AddEnergy( -(SEND_PACKET_ENERGY + RECEIVE_PACKET_ENERGY));
nodes[0]->AddEnergy( -(RECEIVE_PACKET_ENERGY));
break;
}
}
if(i == currentNode->domainMembers.size()){
for(i = 0; i < currentNode->routingTable.size(); ++i){
j = 0;
for(; j < nodes[currentNode->routingTable[i].destination]->GetDomainMembers().size(); ++j){
if(nodes[currentNode->routingTable[i].destination]->GetDomainMembers()[j] == 0){//暂定sink节点Id为0
//找到该sink节点
if(currentNode->routingTable[i].destination == currentNode->routingTable[i].nextHop){
nodes[currentNode->routingTable[i].destination]->AddEnergy( -(SEND_PACKET_ENERGY + RECEIVE_PACKET_ENERGY));
nodes[0]->AddEnergy( -(RECEIVE_PACKET_ENERGY));
}else{
nodes[currentNode->routingTable[i].nextHop]->AddEnergy( -(SEND_PACKET_ENERGY + RECEIVE_PACKET_ENERGY));
allNodesOfForwardedPacket.push(currentNode->routingTable[i].nextHop);
}
break;
}
}
if(j < nodes[currentNode->routingTable[i].destination]->GetDomainMembers().size()){
break;
}
}
if(i == currentNode->routingTable.size()){//没有现成的路由，只有广播啦啦
for(size_t m = 0; m < currentNode->routingTable.size(); ++m){
if(currentNode->routingTable[m].distance == 1){//当然只广播一跳的邻居啦
allNodesOfForwardedPacket.push(currentNode->routingTable[m].destination);
nodes[currentNode->routingTable[m].destination]->AddEnergy( -(SEND_PACKET_ENERGY + RECEIVE_PACKET_ENERGY));
}
}
}
}
allNodesOfForwardedPacket.pop();
if(allNodesOfForwardedPacket.front() == -1){
++hop;
allNodesOfForwardedPacket.pop();
allNodesOfForwardedPacket.push(-1);
}
}
}
void Node::RoutingWithBufferedPackets(){
assert(bufferedPackets.size());
assert(currentWorkState == Receiving);
if(currentWorkState == Sleeping){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<<"处于睡眠状态怎么能路由呢,一定是哪里弄错了><"<<endl;
outLogFile.close();
return;
}
if(m_Battery->GetEnergyGrade() <= 0){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<<"电池都耗尽啦，还路由什么啊><"<<endl;
outLogFile.close();
return;
}
if(bufferedPackets.empty()){
return;//No Packets in the queue
}
--(bufferedPackets.front().TTL);
if(bufferedPackets.front().TTL >= 0){
if(id == 0){
assert(bufferedPackets.size());
bufferedPackets.pop();
return;
}
if(currentState == NonGatewayNode){
if(!routingTable.size() || nodes[routingTable[0].nextHop]->GetNodeWorkState() == Sleeping){
double bestGatewayNodeCondition = 0.0;
RoutingEntry entry;
for(size_t i = 0; i < neighbors.size(); ++i){
if(nodes[neighbors[i]]->IsGatewayNodeOrNot() == GatewayNode
&& nodes[neighbors[i]]->GetNodeWorkState() == Receiving){
if(nodes[neighbors[i]]->GetBattery()->GetEnergyGrade() > bestGatewayNodeCondition){
bestGatewayNodeCondition = nodes[neighbors[i]]->GetBattery()->GetEnergyGrade();//暂时就先选择一个吧
entry.destination = neighbors[i];
entry.nextHop = entry.destination;
entry.distance = 1;
}
}
}
if(bestGatewayNodeCondition == double(0)){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"NonGateway节点"<<id<< "孤立,无法路由啦"<<endl;
outLogFile.close();
return;//有一个节点是不连通，fail to get a dominating set,网络瘫痪
}else{
if(routingTable.size()){
routingTable[0].destination = entry.destination;
routingTable[0].nextHop = entry.nextHop;
}else{
routingTable.push_back(entry);
}
}
}
assert(bufferedPackets.size());
nodes[routingTable[0].nextHop]->PushPackets(bufferedPackets.front());
bufferedPackets.pop();
return;
}
size_t d = 0;
size_t j = 0;
for(d = 0; d < domainMembers.size(); ++d){
if(domainMembers[d] == 0){//暂定sink节点Id为0，0节点一直都是醒着的啊啊啊
assert(bufferedPackets.size());
nodes[0]->PushPackets(bufferedPackets.front());
bufferedPackets.pop();
//找到该sink节点
//nodes[currentNode->domainMembers[i]]->AddEnergy( -(SEND_PACKET_ENERGY + RECEIVE_PACKET_ENERGY));
//nodes[0]->AddEnergy( -(RECEIVE_PACKET_ENERGY));
break;
}
}
if(d == domainMembers.size()){
size_t i = 0;
for(i = 0; i < routingTable.size(); ++i){
j = 0;
for(; j < nodes[routingTable[i].destination]->GetDomainMembers().size()
&& nodes[routingTable[i].nextHop]->GetNodeWorkState() == Receiving; ++j){
if(nodes[routingTable[i].destination]->GetDomainMembers()[j] == 0){//暂定sink节点Id为0
assert(bufferedPackets.size());
nodes[routingTable[i].nextHop]->PushPackets(bufferedPackets.front());
bufferedPackets.pop();
break;
}
}
if(j < nodes[routingTable[i].destination]->GetDomainMembers().size()){
break;
}
}
if(i == routingTable.size()){//没有现成的路由，只有广播啦啦
/*if(currentState == NonGatewayNode){
double bestGatewayNodeCondition = 0.0;
RoutingEntry entry;
for(size_t i = 0; i < neighbors.size(); ++i){
if(nodes[neighbors[i]]->IsGatewayNodeOrNot() == GatewayNode && nodes[neighbors[i]]->GetNodeWorkState() == Receiving){
if(nodes[neighbors[i]]->GetBattery()->GetEnergyGrade() > bestGatewayNodeCondition){
bestGatewayNodeCondition = nodes[neighbors[i]]->GetBattery()->GetEnergyGrade();//暂时就先选择一个吧
entry.destination = neighbors[i];
entry.nextHop = entry.destination;
entry.distance = 1;
}
}
}
if(bestGatewayNodeCondition == double(0)){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"NonGateway节点"<<id<< "孤立"<<endl;
outLogFile.close();
return;//有一个节点是不连通，fail to get a dominating set,网络瘫痪
}else{
if(routingTable.size()){
routingTable[0].destination = entry.destination;
routingTable[0].nextHop = entry.nextHop;
}else{
routingTable.push_back(entry);
}
}
}else{
*/
bool isOut = false;
for(size_t m = 0; m < routingTable.size()
&& nodes[routingTable[m].nextHop]->GetNodeWorkState() == Receiving; ++m){
if(routingTable[m].distance == 1){//当然只广播一跳的邻居啦
assert(bufferedPackets.size());
nodes[routingTable[m].nextHop]->PushPackets(bufferedPackets.front());
isOut = true;
}
}
if(isOut){
assert(bufferedPackets.size());
bufferedPackets.pop();
}
//}
}
}
}
}
void Node::UpdateRoutingTable(){//更新路由表和domain nodes
//根据自己当前的状态确定自己的routing table，必要的话 nodes in its domain
assert(currentWorkState == Receiving);//因为需要与邻居节点的交换路由表
//assert(relaxingTime == 0);
if(id == 0){
id = 0;
}
if(id != 0 && m_Battery->GetEnergyGrade() <= 0){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<<"电池耗尽啦><"<<endl;
outLogFile.close();
return;
}
RoutingEntry entry;
if(currentState == NonGatewayNode){
//has no domain
//routing table 只有一条，自己选择好的能量最高的gateway node，可不可以多选择几个，
//再根据休息时间什么的确定，因为能量小的那个说不定再休息多久也不会再增加能量啦，而能量高的那个节点说不定还可以继续增加能量
double bestGatewayNodeCondition = 0.0;
if(routingTable.size()){
bestGatewayNodeCondition = nodes[routingTable[0].nextHop]->GetBattery()->GetEnergyGrade();
}
for(size_t i = 0; i < neighbors.size(); ++i){
if(nodes[neighbors[i]]->IsGatewayNodeOrNot() == GatewayNode
&& nodes[neighbors[i]]->GetNodeWorkState() == Receiving){
if(nodes[neighbors[i]]->GetBattery()->GetEnergyGrade() > bestGatewayNodeCondition){
bestGatewayNodeCondition = nodes[neighbors[i]]->GetBattery()->GetEnergyGrade();//暂时就先选择一个吧
entry.destination = neighbors[i];
entry.nextHop = entry.destination;
entry.distance = 1;
}
}
}
if(bestGatewayNodeCondition == double(0)){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"NonGateway节点"<<id<< "孤立"<<endl;
outLogFile.close();
return;//有一个节点是不连通，fail to get a dominating set,网络瘫痪
}else{
if(routingTable.size()){
if(bestGatewayNodeCondition != nodes[routingTable[0].nextHop]->GetBattery()->GetEnergyGrade()){
routingTable[0].destination = entry.destination;
routingTable[0].nextHop = entry.nextHop;
}
}else{
routingTable.push_back(entry);
}
}
}else{//Gateway节点
for(size_t i = 0; i < neighbors.size(); ++i){
if(nodes[neighbors[i]]->IsGatewayNodeOrNot() == GatewayNode){
size_t j = 0;
for(; j < routingTable.size(); ++j){
if(neighbors[i] == routingTable[j].nextHop){//已经存在
break;
}
}
if(j == routingTable.size()){
entry.destination = neighbors[i];
entry.nextHop = entry.destination;
entry.distance = 1;
routingTable.push_back(entry);
}
}else{
size_t m = 0;
for(; m < domainMembers.size(); ++m){
if(i == domainMembers[m]){//已经存在
break;
}
}
if(m == domainMembers.size()){
domainMembers.push_back(neighbors[i]);
}
}
}
if(!routingTable.size()){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"Gateway节点"<<id<< "孤立"<<endl;
outLogFile.close();
}
//根据邻居节点的routing table再更新一下
for(size_t i = 0; i < neighbors.size(); ++i){
if(nodes[neighbors[i]]->IsGatewayNodeOrNot() == GatewayNode){
for(size_t j = 0; j < nodes[neighbors[i]]->routingTable.size(); ++j){
size_t k = 0;
for(; k < routingTable.size(); ++k){
if(nodes[neighbors[i]]->routingTable[j].destination == routingTable[k].destination
|| nodes[neighbors[i]]->routingTable[j].destination == id){
break;
}
}
if(k == routingTable.size()){
entry.destination = nodes[neighbors[i]]->routingTable[j].destination;
entry.nextHop = neighbors[i];
entry.distance = nodes[neighbors[i]]->routingTable[j].distance + 1;
routingTable.push_back(entry);
}
}
}
}
}
}
void Node::FurtherDecision(const int& time){//进一步确定自己是不是gateway node，从而精简dominating set的大小
assert(currentState == GatewayNode);
assert(currentWorkState == Receiving);
/*if(currentWorkState == Sleeping){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<<"都睡着了，还怎么进一步判断自己是不是gateway啊啊啊><"<<endl;
outLogFile.close();
return;
}*/
if(m_Battery->GetEnergyGrade() <= 0){
ofstream outLogFile("log.txt", ios_base::out | ios_base::app);
assert(!outLogFile.fail());
outLogFile<<__TIME__<<"节点"<<id<<"电池耗尽啦><"<<endl;
outLogFile.close();
return;
}
//Rule 1
for(size_t i = 0; i < neighbors.size(); ++i){
if(nodes[neighbors[i]]->IsGatewayNodeOrNot() == GatewayNode){
if(VectorBelong2Vector(neighbors,id, nodes[neighbors[i]]->GetNeighbors(), neighbors[i])){
//如果当前节点的所有邻居也是其邻居gateway节点neighbor[i]的邻居
Rule1(id, neighbors[i]);
//Rule11(id, neighbors[i]);
}
}
}
if(currentState == NonGatewayNode){
return;
}
//Rule 2
for(size_t i = 0; i < neighbors.size(); ++i){
for(size_t j = 0; j < neighbors.size(); ++j){
if(neighbors[i] == neighbors[j]){
continue;
}
if(nodes[neighbors[i]]->IsGatewayNodeOrNot() == GatewayNode && nodes[neighbors[j]]->IsGatewayNodeOrNot() == GatewayNode){
if(VectorBelong2VectorAndVector(neighbors, nodes[neighbors[i]]->GetNeighbors(), nodes[neighbors[j]]->GetNeighbors())
&& !VectorBelong2VectorAndVector(nodes[neighbors[i]]->GetNeighbors(),neighbors, nodes[neighbors[j]]->GetNeighbors())
&& !VectorBelong2VectorAndVector(nodes[neighbors[j]]->GetNeighbors(),neighbors, nodes[neighbors[i]]->GetNeighbors())
){
currentState = NonGatewayNode;
}else{
if(VectorBelong2VectorAndVector(neighbors, nodes[neighbors[i]]->GetNeighbors(), nodes[neighbors[j]]->GetNeighbors())
&& VectorBelong2VectorAndVector(nodes[neighbors[i]]->GetNeighbors(),neighbors, nodes[neighbors[j]]->GetNeighbors())
&& !VectorBelong2VectorAndVector(nodes[neighbors[j]]->GetNeighbors(),neighbors, nodes[neighbors[i]]->GetNeighbors())
){
Rule1(id, neighbors[i]);
//Rule11(id, neighbors[i]);
}else{
if(VectorBelong2VectorAndVector(neighbors, nodes[neighbors[i]]->GetNeighbors(), nodes[neighbors[j]]->GetNeighbors())
&& VectorBelong2VectorAndVector(nodes[neighbors[i]]->GetNeighbors(),neighbors, nodes[neighbors[j]]->GetNeighbors())
&& VectorBelong2VectorAndVector(nodes[neighbors[j]]->GetNeighbors(),neighbors, nodes[neighbors[i]]->GetNeighbors())
){
Rule2(id, neighbors[i], neighbors[j]);
//Rule22(id, neighbors[i], neighbors[j]);
}
}
}
}
}
}
/*if(time != -1 && currentState == GatewayNode){
double pos = ((double)(totalWorkTime) / (double)(time));
double randN = ((double) (rand() + 1) / (double)(RAND_MAX));
if( totalWorkTime >= MAX_WORK_TIME && randN < pos){
size_t i = 0;
for(; i < neighbors.size(); ++i){
if(nodes[neighbors[i]]->GetNodeWorkState() == Sleeping){
continue;
}
size_t j = 0;
for(; j < nodes[neighbors[i]]->neighbors.size(); ++j){
if(nodes[nodes[neighbors[i]]->neighbors[j]]->IsGatewayNodeOrNot() == GatewayNode && id != nodes[neighbors[i]]->neighbors[j]){
break;
}
}
if(j == nodes[neighbors[i]]->neighbors.size()){
break;
}
}
if(i == neighbors.size()){
currentState = NonGatewayNode;
}
}
}*/
//Rule 3
/*
size_t i = 0;
for(; i < neighbors.size(); ++i){
if(nodes[neighbors[i]]->IsGatewayNodeOrNot() == NonGatewayNode){
size_t n = 0;
for(; n < nodes[neighbors[i]]->GetNeighbors().size(); ++n){
if(nodes[nodes[neighbors[i]]->GetNeighbors()[n]]->IsGatewayNodeOrNot() == GatewayNode
&& nodes[neighbors[i]]->GetNeighbors()[n] != id){
break;
}
}
if(n == nodes[neighbors[i]]->GetNeighbors().size()){
//当前邻居的一个NonGateway节点没有其他Gateway节点邻居了，只有该节点一个，好可怜啊TQT,当前节点不能改为nongatwayNode啦
return;
}
}else{
size_t m = 0;
for(; m < neighbors.size(); ++m){
if(neighbors[i] == neighbors[m]){
continue;
}else{
if(nodes[neighbors[m]]->IsGatewayNodeOrNot() == GatewayNode){
size_t x = 0;
size_t y = 0;
for(x = 0; x < nodes[neighbors[i]]->GetNeighbors().size(); ++x){
for(y = 0; y < nodes[neighbors[m]]->GetNeighbors().size(); ++y){
if(nodes[neighbors[i]]->GetNeighbors()[x] == nodes[neighbors[m]]->GetNeighbors()[y]
&& nodes[nodes[neighbors[i]]->GetNeighbors()[x]]->IsGatewayNodeOrNot() == GatewayNode
&& nodes[neighbors[i]]->GetNeighbors()[x] != id){
//当前节点的两个gateway邻居节点通过另外一个邻居节点相连
//并且其能量要高一点，或者其他比较方式
Rule1(id, nodes[neighbors[i]]->GetNeighbors()[x]);
if(currentState == NonGatewayNode){
currentState = GatewayNode;//只是其中两个gateway节点有相连的而已，并不是所有的
break;
}
}
}
if(y < nodes[neighbors[m]]->GetNeighbors().size()){
break;
}
}
if(y < nodes[neighbors[m]]->GetNeighbors().size()){
break;
}
}
}
}
if(m == neighbors.size()){//当前邻居的两个Gateway节点没有其他Gateway节点邻居了，只有该节点一个，也比较可怜
return;
}
}
}
if( i == neighbors.size()){
currentState = NonGatewayNode;
}
//relaxingTime = 0;
*/
}