how to fix an error on a simulation? : Please help me to find the errors .I am trying to run a simulation but I keep getting some kind of error.I am not very experienced in c++ .I will attach  both files  the main file of the simulation and the file ndn-v2v..
i will appreciate any help i can get even a small advice and thanks in advance.[i also added a screen capture for the error while compilling the script here][1] 

    enter code here
   

     #include <boost/shared_ptr.hpp>
        #include <boost/make_shared.hpp>
        #include <boost/lexical_cast.hpp>
        #include <boost/tokenizer.hpp>
        #include "ns3/core-module.h"
        #include "ns3/network-module.h"
        #include "ns3/mobility-module.h"
        #include "ns3/config-store-module.h"
        #include "ns3/wifi-module.h"
        #include "ns3/internet-module.h"
        #include "ns3/ndnSIM-module.h"
        #include "ns3/corner-propagation-loss-model.h"
        #include "ns3/ndn-v2v-net-device-face.h"
        #include <iostream>
        #include <fstream>
        #include <vector>
        #include <string>
        #include <map>
        #include "../src/ndnSIM/utils/tracers/ndn-l3-aggregate-tracer.h"
        #include "../src/ndnSIM/utils/tracers/ndn-l3-rate-tracer.h"
        #include "../src/ndnSIM/utils/tracers/v2v-tracer.h"
        NS_LOG_COMPONENT_DEFINE ("Wifiv2v");
        using namespace ns3;
        #define MAX_NODES 1002;
        static int packet_count = 0;
        // Variable for simulation-traces
        //------------------------------------//
        //------------------------------------//
        //------------------------------------//
        int mac_tx_count = 0; // counts how many packets a rereceived from the     higher layers in order to be enqueued for transmission
        int mac_tx_drop = 0; //counts how many packets are has been dropped in the Mac layer before beeing queued for transmission
        int mac_rx_count = 0; //counts how many packets a rereceived from the phy layer and is being forwarded to the local protocol stack
        int mac_rx_drop = 0; //counts how many packtes has been dropped in the Mac layer after has been passed
         //up from phylayer
        //------------------------------------//
        //------------------------------------//
        // Call back for simulation-traces
        //------------------------------------//
        //------------------------------------//
        
        void MacTxCount(Ptr<const Packet> p) {
        	mac_tx_count++;
        	NS_LOG_DEBUG(
        			"[MACTXCOUNT] Packet is going to be transmitted...mac_tx_count="
        					<< mac_tx_count);
        }
        void MacTxDrop(Ptr<const Packet> p) {
        	mac_tx_drop++;
        	NS_LOG_DEBUG(
        			"[MAC_TX_DROP] Packet has been dropped before transmission...mac_tx_drop="
        					<< mac_tx_drop);
        }
        void MacRxCount(Ptr<const Packet> p) {
        	mac_rx_count++;
        	NS_LOG_DEBUG(
        			"[MAC_RX_COUNT] Packet has been received,going to forward...mac_rx_drop="
        					<< mac_rx_count);
        }
        void MacRxDrop(Ptr<const Packet> p) {
        	mac_rx_drop++;
        	NS_LOG_DEBUG(
        			"[MAC_RX_DROP] Packet has been dropped by Mac before forward...mac_rx_drop="
        					<< mac_rx_drop);
        }
        void PrintTrasmission() {
        //std::cout<<Simulator::Now().GetSeconds()<<"\t"<<
        
        	mac_tx_count << "\t" << mac_tx_drop << "\t" << mac_rx_count << "\t"
        			<< mac_rx_drop << "\n ";
        	NS_LOG_DEBUG(
        			" [ PRINT-TRANSMISSION]Time=" << Simulator::Now().GetSeconds()
        					<< " mac_tx_count=" << mac_tx_count << " mac_tx_drop= "
        					<< mac_tx_drop << " mac_rx_count= " << mac_rx_count
        					<< " mac_rx_drop=" << mac_rx_drop);
        	Simulator::Schedule(Seconds(5.0), &PrintTrasmission);
        }
        void OutInterest(Ptr<const ns3::ndn::InterestHeader> interestHeader,
        		Ptr<const ns3::ndn::Face> face) {
        	NS_LOG_DEBUG(
        			"[OUT INTEREST]Time=" << Simulator::Now().GetSeconds() << " NID= "
        					<< face->GetNode()->GetId() << " Nonce= "
        					<< interestHeader->GetNonce() << "Name="
        					<< interestHeader->GetName() << "\n");
        }
        void InInterest(Ptr<const ns3::ndn::InterestHeader> interestHeader,
        		Ptr<const ns3::ndn::Face> face) {
        	NS_LOG_DEBUG(
        			"[IN INTEREST]Time=" << Simulator::Now().GetSeconds() << "NID="
        					<< face->GetNode()->GetId() << "Nonce="
        					<< interestHeader->GetNonce() << "Name="
        					<< interestHeader->GetName() << "Position="
        					<< face->GetNode()->GetObject<MobilityModel>()->GetPosition()
        					<< "\n");
        
        }
        void DropInterest(Ptr<const ns3::ndn::InterestHeader> interestHeader,
        		Ptr<const ns3::ndn::Face> face) {
        	NS_LOG_DEBUG(
        			"[DROPINTEREST]Time=" << Simulator::Now().GetSeconds() << "NID="
        					<< face->GetNode()->GetId() << "Nonce="
        					<< interestHeader->GetNonce() << "Name="
        					<< interestHeader->GetName() << "\n");
        }
        void InData(Ptr<const ns3::ndn::ContentObjectHeader> contentHeader,
        		Ptr<const ns3::Packet> packet, Ptr<const ns3::ndn::Face> face) {
        	NS_LOG_DEBUG(
        			"[INDATA]Time=" << Simulator::Now().GetSeconds() << "NID="
        					<< face->GetNode()->GetId() << "Name="
        					<< contentHeader->GetName() << "Position="
        					<< face->GetNode()->GetObject<MobilityModel>()->GetPosition()
        					<< "\n ");
        }
        void OutData(Ptr<const ns3::ndn::ContentObjectHeader> contentHeader,
        		Ptr<const ns3::Packet> packet, bool value,
        		Ptr<const ns3::ndn::Face> face) {
        	NS_LOG_DEBUG(
        			"[OUT DATA]Time=" << Simulator::Now().GetSeconds() << "NID="
        					<< face->GetNode()->GetId() << "Name="
        					<< contentHeader->GetName() << "\n");
        }
        void DropData(Ptr<const ns3::ndn::ContentObjectHeader> contentHeader,
        		Ptr<const ns3::Packet> packet, Ptr<const ns3::ndn::Face> face) {
        	NS_LOG_DEBUG(
        			"[DROP DATA]Time=" << Simulator::Now().GetSeconds() << "NID="
        					<< face->GetNode()->GetId() << "Name="
        					<< contentHeader->GetName() << "\n");
        }
        Ptr<ndn::NetDeviceFace> V2vNetDeviceFaceCallback(Ptr<Node> node,
        		Ptr<ndn::L3Protocol> ndn, Ptr<NetDevice> device) {
        //NS LOG UNCOND ("Creating ndn::V2vNetDeviceFace on node"<< node->GetId()
        	);
        	Ptr < ndn::NetDeviceFace > face = CreateObject < ndn::V2vNetDeviceFace
        			> (node, device);
        	NS_LOG_DEBUG("Node=" << node->GetId() << "MAC=" << device->GetAddress());
        	ndn->AddFace(face);
        	return face;
        }
        voidprintPosition(Ptr<const MobilityModel>mobility)
        {
        	NS LOG INFO("Time="<<Simulator::Now().GetSeconds( )<<"Positionof:"<< mobility->GetObject<Node>()->GetId()<<":"<<mobility->GetPosition());
        }
        //------------------------------------//
        void ReceivePacket(Ptr<Socket> socket) {
        //NS LOG UNCOND ("Received one packet!");
        	packet_count++;
        }
        int main(int argc, char* argv[]) {
        //NS LOG UNCOND( "NDN SIMULATION ---->Started<----");
        std::stringphyMode("OfdmRate6Mbps"); //("DsssRate1Mbps");
        double rss = -80; // -dBm
        uint32_t packet
        Size = 512; // bytes
        uint32_t numPackets = 50;
        // double interval=0.5;//seconds
        bool verbose = false;
        //Param for simulation and tracing
        bool pcapOn = true; // Tracing is enabled by default
        uint32_t numberOfConsumer = 1; // D a f ault value:1
        uint32_t numberOfProducer = 1; //Default value:1
        uint32_t numberOfRuns = 50; //Default value:50
        uint32_t numOfNodes = 357; //Default value:12
        std::string mobFile("/home/user/Desktop/ndnSIM/ns-3/scratch/losangeles.cc");
        double time = 0;
        double x = 0, y = 0, z = 0;
        int nodeNo = 0;
        CommandLine cmd;
        cmd.AddValue("phyMode", "Wifi Phy mode", phyMode);
        cmd.AddValue("rss", "received signal  strength", rss);
        cmd.AddValue("packet Size", " size of application packet sent", packetSize);
        cmd.AddValue("numPackets ", "number of packets generated", numPackets);
        //cmd . AddValue("interval","interval(seconds) between packets",interval);
        cmd.AddValue("verbose"," turn on all WifiNetDevice log components",verbose) ;
        //new param
        		cmd.AddValue("pcapOn","Turn on/off pcap tracing.Tracing is enabled by default",pcapOn);
        				cmd.AddValue("numConsumer","Number of consumer in the simulation",numberOfConsumer);
        				cmd.AddValue("numProducer","Number of producer in the simulation",numberOfProducer);
        				cmd.AddValue("numRun", "Number of run per simulation",numberOfRuns);
        				cmd.AddValue("mobilityFile", "Insertfullpath", mobFile);
        				cmd.AddValue("numNodes"," Total number o f nodes in the simulation",numOfNodes);
        				cmd.Parse(argc, argv);
        // Convert to time object
        //Time inter Packet Interval= Seconds (interval);
        // NS LOG UNCOND("true");
        //disable fragmentation for frames below 2200 bytes
        				Config::SetDefault(
        						"ns3::WifiRemoteStationManager::FragmentationThreshold ",
        						StringValue("2200"));
        // turn off RTS/CTS for frames below 2200bytes 
        				Config::SetDefault(
        						"ns3::WifiRemoteStationManager::RtsCtsThreshold ",
        						StringValue("2200"));
        // Fix non-unicast data rate to be the same as that of unicast
        				Config::SetDefault("ns3::WifiRemoteStationManager::NonUnicastMode",String Value(phyMode));
        //enable cache unsolicited Data
        				Config::SetDefault(
        						"ns3::ndn::ForwardingStrategy::CacheUnsolicitedData",
        						BooleanValue(true));
        //Read number of cars directly from file
        				std::ifstreamreadNcars;
        				std::map<int, int> map
        				count;
        				int count = 0;
        				readNcars.open(mobFile.cstr(), std::ios::in);
        				while (readNcars >> nodeNo) {
        					readNcars >> time >> x >> y >> z;
        					if (mapcount.find(nodeNo) != mapcount.end()) { // cout<<"Ke yis present:"<<nodeNo<<" is present!\n";
        						count = mapcount[nodeNo];
        						count++;
        						mapcount[nodeNo] = count;
        					} else {
        // cout <<"Key not present:"<<nodeNo<<"is not present!\n";
        						mapcount[nodeNo] = 1;
        					}
        				}
        				numOfNodes = map
        				count.size();
        				NodeContainer c;
        				c.Create(numOfNodes);
        // The below set of helpers will help us to put together th e wifi NICs we want
    				WifiHelperwifi;
    				if (verbose) {
    					wifi.EnableLogComponents(); // Turn on all Wifi logging
    				}
    				wifi.SetStandard ( WIFI PHY STANDARD 80211a); //WIFI PHY STANDARD 80211b
    				YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default();
    // This is one parameter that matters when using FixedRssLossModel
    // set it to zero;otherwise, gain will be added
    				wifiPhy.Set("RxGain ", DoubleValue(0));
    				wifiPhy.Set("EnergyDetectionThreshold", DoubleValue(-93)); //dBm,default value is -96 dBm
    // ns-3 supports RadioTap and Prism tracing extensions for 802.11b
    				wifiPhy.SetPcapDataLinkType(
    						YansWifiPhyHelper::DLTIEEE80211RADIO);
    				YansWifiChannelHelperwifiChannel;
    				wifiChannel.SetPropagationDelay(
    						"ns3::ConstantSpeedPropagationDelayModel ");
    // Proptagation model is CORNER
    				wifiChannel.AddPropagationLoss(
    						"ns3::CornerPropagationLossModel");
    				wifiPhy.SetChannel(wifiChannel.Create());
    // Add a non-QoS upper mac,and disablerate control
    				NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default();
    				wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager",
    						"DataMode ", StringValue(phyMode), "ControlMode",
    						StringValue(phyMode));
    // Set it to adhoc mode
    				wifiMac.SetType("ns3::AdhocWifiMac");
    				NetDeviceContainerdevices = wifi.Install(wifiPhy, wifiMac, c);
    // Create file for thecapture
    			if(pcapOn==true) {
    //wifiPhy.EnablePcap("capture examp",devices);
    //wifiPhy.EnablePcap Internal("captureexampnode0",devices.Get(0),true);
    //wifiPhy.Enable Pcap Internal("captureexampnode1",devices.Get(0),true);}
    //the format of corner.mobility
    //NodeNum time x y z
    // by reading each line ,we can get a detaile  dtrace of nodes ’ mobility
    				MobilityHelper mobility;
    				mobility.SetMobilityModel("ns3::WaypointMobilityModel");
    				mobility.Install(c);
    				std::ifstream mobileInput;
    				mobileInput.open(mobFile.cstr(),std::ios::in);
    				if(!mobileInput.isopen()) {
    					NS LOG ERROR("Invalidmap.The path("<<mobFile<<"is wrong.Please check it again");
    					return -1;
    				}
    //With map
    				std::map<int,Ptr<WaypointMobilityModel>>wayMobility;
    //NS LOG UNCOND ( " nNodes = "<<nNodes ) ;
    				uint32_t indexc=0;
    				for(std::map<int,int>::iteratorit=mapcount.begin();
    						it!=mapcount.end();it++,indexc++) {
    					wayMobility[it ->first]=c.Get(indexc)->GetObject<WaypointMobilityModel >();
    // cout <<"Key="<<it->first<<"Value="<<it->
    					second <<"\n ";
    				}
    // setting initial position to all the nodes.We put all the cars far away from the map (100Km +some randomvalue)
    				double sinkX =100000;
    				double sinkY = 100000;
    				double sinkZ =0;
    				index c = 0;
    				for (std::map<int,int>::iteratorit=map count.begin();
    						it!=mapcount.end();it++,indexc++) {
    					Waypoint waypoint(Seconds(0.1),Vector3D(sinkX+(indexc *10000),sinkY+(indexc *10000),sinkZ));
    // wayMobility [ i ]->AddWaypoint (waypoint);
    					Simulator::Schedule(Seconds(0.1),&WaypointMobilityModel::SetPosition,wayMobility[it->first],Vector3D(sinkX+(indexc*10000),sinkY+(indexc*10000),sinkZ)
    					);
    				}
    				std::map<int,int>endTime;
    				for(std::map<int,int>::iteratorit=mapcount.begin();
    						it != map count.end();it++) {
    					endTime[it->first]=0;
    				}
    				while(mobileInput>>nodeNo)
    				{
    					mobileInput>>time>>x>>y>>z;
    					if(time <=0.1) {
    //discarding the positionatsec0; we ’ ve substituted them with sink coordinates
    						continue;
    					}
    					endTime[nodeNo]=time;
    					Waypoint waypoint(Seconds (time),Vector3D(x,y,z));
    //NS LOG UNCOND( "Reading mobility file Id="<< nodeNo<<" time="<<time<<"("<<x<<","<<y<<")");
    					wayMobility[nodeNo]->AddWaypoint(waypoint);
    
    					/*if(nodeNo==0)
    					{
    						wayMobility0->AddWaypoint ( waypoint );} else if(nodeNo==1)
    					{
    						wayMobility1->AddWaypoint(waypoint);
    					}*/
    				}
    //std::vector<Ptr<Node>>::constiterator it=c.Begin();
    //setting sink coordinates when a car mobility terminates
    				uint32_t numberOfWaypoint;
    				Waypoint point;
    				for(std::map<int,int>::iteratorit=map count.begin();
    						it!=mapcount.end();it ++) {numberOfWaypoint = wayMobility[it->first]->WaypointsLeft(); //TO DO chec kif  it goes to the last element
    					if(numberOfWaypoint==0) {
    						continue;
    					}
    					index c = 0;
    					Simulator::Schedule(Seconds(endTime[it->first]+0.0001),&WaypointMobilityModel::SetPosition,wayMobility[it->first],Vector3D (sinkX+(indexc*10000),sinkY+(indexc*10000),sinkZ));}
    //NS LOG UNCOND ("Mobility read!") ;
    // Install Ndn stack on all nodes
    //NS LOG INFO ( " Installing Ndnstack ") ;
    				ndn::StackHelperndnHelper;
    
    				EndnHelper.AddNetDeviceFaceCreateCallback (
    						WifiNetDevice : : GetTypeId ( ),MakeCallback(V2vNetDeviceFaceCallback ) );
    //...setting ad hoc forwarding
    				ndnHelper.SetForwardingStrategy("ns3::ndn::fw::V2v");
    				ndnHelper.SetDefaultRoutes(true);
    				ndnHelper.InstallAll( );
    // Test with more than one consumer
    				std::ifstream fileConsumer;
    				fileConsumer.open("/home/nrl/contolic/vndn-sim/ns-3/scratch/consumer.txt",std::ios::in);
    				if ( !fileConsumer.is open () ) {
    					NS LOG ERROR("Invalidname.The name"<<fileConsumer<<"is wrong.Please check it again");
    					return -1;
    				}
    				int idConsumer = 0;
    				int countCons = 0;
    				int indexCNodes = numOfNodes - 1;
    				while(fileConsumer>>idConsumer ) {
    //NS LOG UNCOND( " idConsumer " << idConsumer ) ;
    					std::string consumerName=" c"+idConsumer;
    					Ptr<Node> nodeConsumer = CreateObject <Node >();
    //Names : : Add( consumerName , nodeConsumer ) ;
    					ndn::AppHelper consumerHelper("ns3::ndn::ConsumerCbr");
    					consumerHelper.SetPrefix("/prefix");
    					consumerHelper.SetAttribute(" Frequency ",StringValue ("1"));
    					consumerHelper.SetAttribute("Randomize",StringValue("uniform "));
    					ApplicationContainerconsumers=consumerHelper.Install(c.Get(indexCNodes-countCons));
    					consumers.Start(Seconds(50));//(50)-countCons *10
    					consumers.Stop(Seconds(450));//(600)-30
    					countCons++;
    				}
    // Test with more than oneproducer
    				std::ifstream fileProducer;
    				fileProducer.open("/home/nrl/contolic/vndn-sim/ns-3/scratch/producer.txt",std::ios::in);
    				if(!fileProducer.is open () ) {
    					NS LOG ERROR( "Invalidname.Thename"<<fileProducer<<"iswrong.Please  check it again ");
    					return -1;
    
    				}
    				int idProducer = 0;
    				int countProd = 0;
    				int indexPNodes = 0;
    				while(fileProducer>>idProducer) {
    //NS LOG UNCOND("idProducer"<<idProducer);
    					std::string producerName="c"+idProducer;Ptr<Node>nodeProducer=CreateObject<Node >();
    //Names::Add(producerName,nodeProducer);
    					ndn::AppHelperproducerHelper("ns3::ndn::Producer");
    					producerHelper.SetPrefix("/prefix" );
    					producerHelper.SetAttribute("PayloadSize",StringValue ("1024") );
    					ApplicationContainerproducers=producerHelper.Install(c.Get(indexPNodes+countProd));
    //producers.Start(Seconds(countProd*0.5));
    					countProd++;}
    				/*ndn::AppHelperproducerHelper("ns3::ndn::Producer");
    
    // Producer willreply to all requestsstarting
    				with/prefixproducerHelper.SetPrefix("/prefix");
    				producerHelper.SetAttribute(" PayloadSize ",StringValue("1024"));
    //ApplicationContainerproducers=producerHelper.
    				Install(c.Get(0));// AlmostatLincolnBlvd
    				on WilshireBlvd*/
    //NS LOG UNCOND(" Applicationinstalled!!" ) ;
    // Trace oflevel2.5
    				Config::ConnectWithoutContext("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacTx",MakeCallback(&MacTxCount));
    				Config::ConnectWithoutContext("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRx",MakeCallback(&MacRxCount ) );
    				Config::ConnectWithoutContext("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice /Mac/MacTxDrop",MakeCallback(&MacTxDrop));
    				Config::ConnectWithoutContext("/NodeList/*/DeviceList/*/$ns3::WifiNetDevice/Mac/MacRxDrop",MakeCallback(&MacRxDrop));
    // Trace
    				Config::ConnectWithoutContext("/NodeList/*/$ns3::ndn::ForwardingStrategy/OutInterests",MakeCallback(&OutInterest));
    				Config::ConnectWithoutContext("/NodeList/*/$ns3::ndn::ForwardingStrategy/InInterests",MakeCallback(&InInterest));
    				Config::ConnectWithoutContext("/NodeList/*/$ns3::ndn::ForwardingStrategy/DropInterests",MakeCallback(& DropInterest));
    				Config::ConnectWithoutContext("/NodeList/*/$ns3::ndn::ForwardingStrategy/InData ",MakeCallback(&InData));
    				Config::ConnectWithoutContext("/NodeList/*/$ns3::ndn::ForwardingStrategy/DropData ",MakeCallback(&DropData ));
    				Config::ConnectWithoutContext("/NodeList/*/$ns3::ndn::ForwardingStrategy/OutData",MakeCallback(&OutData ) );
    				/* Tracing the car position*/
    				Config::ConnectWithoutContext("/NodeList/*/$ns3::MobilityModel / CourseChange ",MakeCallback(&printPosition ) );
    				Simulator::Stop(Seconds(600.0));//(600.0)-30
    				/*Testingtraces*/
    				/* boost::tuple< boost::sharedptr<std::ostream >,
    				std::list<Ptr<ndn::L3AggregateTracer> > >
    				aggTracers= ndn::L3AggregateTracer::InstallAll("/ mnt/space/simulationlog/ndn-600s-aggregate-trace-v2v.txt",Seconds (0.5));*/
    				/* boost::tuple<boost::sharedptr<std::ostream >,std::list<Ptr<ndn::L3RateTracer> > >
    				rateTracers=ndn::L3RateTracer::InstallAll("/mnt/space/simulationlog/ndn-600s-rate-trace-v2v.txt",Seconds(0.5));*/
    				/*
    				boost::tuple<boost::sharedptr<std::ostream >,
    				std::list<boost::sharedptr<ndn::V2vTracer> >>v2vtracing=ndn::V2vTracer::InstallAll("v2v.tracer.txt");*/
    
    				Simulator:: Run ( );
    				Simulator:: Destroy ( );
    				return 0;
        
    
    			}

also here is the second file ndn-v2v-net-device-face.h 

    enter code here
   

     #ifndef NDN_V2V_NET_DEVICE_FACE_H
    #define NDN_V2V_NET_DEVICE_FACE_H
    
    #include "ns3/nstime.h"
    #include "ns3/event-id.h"
    #include "ns3/random-variable.h"
    #include "ns3/traced-callback.h"
    
    #include "ns3/ndn-net-device-face.h"
    #include "ns3/ndn-header-helper.h"
    
    namespace ns3 {
    
    class Vector3D;
    typedef Vector3D Vector;
    
    namespace ndn {
    
    class NameComponents;
    
    /**
     * \ingroup ndn-face
     * \brief Implementation of layer-2 broadcast vehicle-2-vehicle NDN face
     *
     * This class defines basic functionality of NDN face. Face is core
     * component responsible for actual delivery of data packet to and
     * from NDN stack
     *
     * ndn::NetDevice face is permanently associated with one NetDevice
     * object and this object cannot be changed for the lifetime of the
     * face
     *
     * The only difference from the base class is that ndn::V2vNetDevice
     * makes additional consideration for overheard information
     *
     * \see ndn::AppFace, ndn::NetDeviceFace
     */
    class V2vNetDeviceFace  : public NetDeviceFace
    {
    public:
      static TypeId
      GetTypeId ();
    
      /**
       * \brief Constructor
       *
       * \param netDevice a smart pointer to NetDevice object to which
       * this face will be associate
       */
      V2vNetDeviceFace (Ptr<Node> node, const Ptr<NetDevice> &netDevice);
      virtual ~V2vNetDeviceFace();
    
      // from CcnxFace
      virtual void
      SendLowPriority (Ptr<Packet> p);
    
    protected:
      // from ndn::NetDeviceFace
      virtual bool
      SendImpl (Ptr<Packet> p);
    
    public:
      virtual std::ostream&
      Print (std::ostream &os) const;
    
    private:
      V2vNetDeviceFace (const V2vNetDeviceFace &); ///< \brief Disabled copy constructor
      V2vNetDeviceFace& operator= (const V2vNetDeviceFace &); ///< \brief Disabled copy operator
    
      /// \brief callback from lower layers
      virtual void
      ReceiveFromNetDevice (Ptr<NetDevice> device,
                            Ptr<const Packet> p,
                            uint16_t protocol,
                            const Address &from,
                            const Address &to,
                            NetDevice::PacketType packetType);
    
      void
      SendFromQueue ();
    
      void
      SetMaxDelay (const Time &value);
    
      Time
      GetMaxDelay () const;
    
      void
      SetMaxDelayLowPriority (const Time &value);
    
      Time
      GetMaxDelayLowPriority () const;
    
      void
      ProcessRetx ();
    
      Time
      GetPriorityQueueGap () const;
    
      void
      NotifyJumpDistanceTrace (const Ptr<const Packet> packet);
    
    private:
      struct Item
      {
        Item (const Time &_gap, const Ptr<Packet> &_packet);
        Item (const Item &item);
    
        Item &
        operator ++ ();
    
        Item &
        Gap (const Time &time);
    
        Time gap;
        Ptr<Packet> packet;
        HeaderHelper::Type type;
        Ptr<const NameComponents> name;
        uint32_t retxCount;
      };
      typedef std::list<Item> ItemQueue;
    
      EventId m_scheduledSend;
    
      // Primary queue (for requested ContentObject packets)
      Time m_totalWaitPeriod;
      UniformVariable m_randomPeriod;
      Time m_maxWaitPeriod;
      uint32_t m_maxPacketsInQueue;
      ItemQueue m_queue;
    
      // Low-priority queue (for pushing Interest and ContentObject packets)
      Time m_maxWaitLowPriority;
      double m_maxDistance;
      ItemQueue m_lowPriorityQueue;
    
      // Retransmission queue for low-priority pushing
      EventId m_retxEvent;
      Time m_maxWaitRetransmission;
      ItemQueue m_retxQueue;
      uint32_t m_maxRetxAttempts;
    
      TracedCallback<double, double> m_waitingTimeVsDistanceTrace;
      TracedCallback<Ptr<const Node>, double> m_jumpDistanceTrace;
      TracedCallback<Ptr<Node>, Ptr<const Packet>, const Vector&> m_tx;
      TracedCallback<Ptr<Node>, Ptr<const Packet> > m_cancelling;
    };
    
    } // namespace ndn
    } // namespace ns3
    
    #endif // NDN_V2V_NET_DEVICE_FACE_H
    
    
      [1]: http://i.stack.imgur.com/kdiPk.png