vector<uint32_t>::const_iterator endRouters()
 {
      lock.unlock();
      auto it = routers.end();
      lock.unlock();
      return it;
 }

void addFriend(SceNetAdhocctlConnectPacketS2C * packet) {
  // Allocate Structure
  SceNetAdhocctlPeerInfo * peer = (SceNetAdhocctlPeerInfo *)malloc(sizeof(SceNetAdhocctlPeerInfo));
  // Allocated Structure
  if(peer != NULL) {
    // Clear Memory
    memset(peer, 0, sizeof(SceNetAdhocctlPeerInfo));

    // Link to existing Peers
    peer->next = friends;

    // Save Nickname
    peer->nickname = packet->name;

    // Save MAC Address
    peer->mac_addr = packet->mac;

    // Save IP Address
    peer->ip_addr = packet->ip;

    // Multithreading Lock
    peerlock.lock();

    // Link into Peerlist
    friends = peer;

    // Multithreading Unlock
    peerlock.unlock();
  }
}

 void producerSatisfiedAuthRequest( const Name& producer_name,
                                    const Name& request_name,
                                    const NdnParameterSet& credentials )
 {
       if( logging_enabled )
       {
           lock.lock();
           log_file << "Producer:SatisfiedAuth" << endl
                    << "{" << endl
                    << "    time     = " <<  time::system_clock::now() << endl
                    << "    producer = " << producer_name.toUri() << endl
                    << "    request  = " << request_name.toUri() << endl
                    << "    username = " <<
                               ( ( credentials.hasParameter( "username" ) )
                                 ? credentials.getParameter( "username" )
                                 : "none" )
                               << endl
                    << "    password = " <<
                               ( ( credentials.hasParameter( "password" ) )
                                 ? credentials.getParameter( "password" )
                                 : "none" )
                               << endl
                    << "}" << endl;
            lock.unlock();
        }
 }

 size_t routerStartedCount()
 {
      lock.lock();
      auto count = routers_started.size();
      lock.unlock();
      return count;
 }

 vector<uint32_t>::const_iterator beginRouters()
 {
      lock.lock();
      auto it = routers.begin();
      lock.unlock();
      return it;
 }

 vector<uint32_t>::const_iterator endProducers()
 {
      lock.lock();
      auto it = producers.end();
      lock.unlock();
      return it;
 }

 size_t producerStartedCount()
 {
      lock.lock();
      auto count = producers_started.size();
      lock.unlock();
      return count;
 }

 size_t consumerStartedCount()
 {
      lock.lock();
      auto count = consumers_started.size();
      lock.unlock();
      return count;
 }

 size_t nodeCount()
 {
      lock.lock();
      auto count = routers.size();
      lock.unlock();
      return count;
 }

 size_t consumerCount()
 {
      lock.lock();
      auto count = consumers.size();
      lock.unlock();
      return count;
 }

 size_t producerCount()
 {
      lock.lock();
      auto count = producers.size();
      lock.unlock();
      return count;
 }

void deleteFriendByIP(uint32_t ip) {
  // Previous Peer Reference
  SceNetAdhocctlPeerInfo * prev = NULL;

  // Peer Pointer
  SceNetAdhocctlPeerInfo * peer = friends;

  // Iterate Peers
  for(; peer != NULL; peer = peer->next) {
    // Found Peer
    if(peer->ip_addr == ip) {
      // Multithreading Lock
      peerlock.lock();

      // Unlink Left (Beginning)
      if(prev == NULL)friends = peer->next;

      // Unlink Left (Other)
      else prev->next = peer->next;

      // Multithreading Unlock
      peerlock.unlock();

      // Free Memory
      free(peer);

      // Stop Search
      break;
    }

    // Set Previous Reference
    prev = peer;
  }
}

 vector<uint32_t>::const_iterator endConsumers()
 {
      lock.lock();
      auto it = consumers.end();
      lock.unlock();
      return it;
 }

 void removeProducer( uint8_t producer_instance )
  {
       lock.lock();
       auto it = find( producers.begin(), producers.end(), producer_instance );
       if( it != producers.end() )
           producers.erase( it );
       lock.unlock();
  }

 static void workerFunction(){	  
   mMutex.lock();
   cout << "Operation Started" << endl;
   workerFunction(); //this goes in a no ending loop if it works. Which means we can call recousively this function from the same thread
   sleep(1);
   cout << "Operation Terminated" << endl;
   mMutex.unlock();
 }

 void removeRouter( uint32_t router_instance )
 {
      lock.lock();
      auto it = find( routers.begin(), routers.end(), router_instance );
      if( it != routers.end() )
          routers.erase( it );
      lock.unlock();
 }

 void removeConsumer( uint32_t consumer_instance )
 {
      lock.lock();
      auto it = find( consumers.begin(), consumers.end(), consumer_instance );
      if( it != consumers.end() )
          consumers.erase( it );
      lock.unlock();
 }

 void routerStopped( uint32_t router_instance )
 {
      lock.lock();
      auto it = find( routers_started.begin(),
                      routers_started.end(),
                      router_instance );
      if( it != routers_started.end() )
          routers_started.erase( it );
      lock.unlock();
 }

 void consumerStopped( uint32_t consumer_instance )
 {
      lock.lock();
      auto it = find( consumers_started.begin(),
                      consumers_started.end(),
                      consumer_instance );
      if( it != consumers_started.end() )
          consumers.erase( it );
      lock.unlock();
 }

       NdnSigner* producerSigner( const Name& producer )
       {
            lock.lock();

            // make signer if not already available
            NdnSigner* ret = &producer_signers[producer];

            lock.unlock();
            return ret;
       }