/**
 *	@author 	ETSI / STF405
 *  @version 	$URL$
 *				$Id$
 *	@desc		GeoNetworking Templates
 *
 */
module LibItsGeoNetworking_Templates {
    
    // Libcommon
    import from LibCommon_BasicTypesAndValues all;
    
    // LibIts
    import from LibIts_Interface all;
    import from LibItsGeoNetworking_TypesAndValues all;
    
    group geoNwPrimitivesTemplates {
    
    	template (value) GeoNetworkingReq m_geoNwReq(
            template (value) GeoNetworkingPacket p_geoNwMsg
            ) := {
            msgOut := p_geoNwMsg
        }
        
        template GeoNetworkingInd mw_geoNwInd(
            template (present) GeoNetworkingPacket p_geoNwMsg
            ) := {
            msgIn := p_geoNwMsg
        }
    
    } // geoNwPrimitivesTemplates
    
    group geoNwPduTemplates {
        
        template (value) GeoNetworkingPacket m_geoNwPdu(in template (value) Header p_header) := {
        	header := p_header,
        	secHeader := omit,
        	payload := omit           
        }
             
        template GeoNetworkingPacket mw_geoNwPdu(in template (present) Header p_header) := {
        	header := p_header,
        	secHeader := *,
            payload := *          
        }     
                
        template GeoNetworkingPacket mw_geoNwPduWithPayload(in template (present) Header p_header) := {
        	header := p_header,
        	secHeader := *,
            payload := ?          
        }     
                
    } // end geoNwPduTemplates
    
    group geoNwHeadersTemplates {
        
        group geoNwCommonHeaderTemplates {
        
            template (value) CommonHeader m_commonHeader (
            	in template (value) NextHeader p_nextHeader,
            	in template (value) HeaderTST p_headerTST,
            	in template (value) TrafficClass p_trafficClass,
            	in template (value) UInt8 p_hopLimit,
            	in template (value) LongPosVector p_longPosVec,
            	in template (value) StationTypeIdentifier p_stationType
            ) := {
            	version := c_geoNwProtocolVersion,
                nextHeader := p_nextHeader,
    			headerTST := p_headerTST,
                reserved := c_uInt8Zero,
                flags := m_flags(p_stationType),
                plLength := 0, // will be computed by Codec
                trafficClass := p_trafficClass,
                hopLimit := p_hopLimit,
                senderPosVector := p_longPosVec    
            }
            
            template CommonHeader mw_commonHeader (
                in template (present) LongPosVector p_senderLongPosVec,
            	in template (present) NextHeader p_nextHeader,
            	in template (present) HeaderTST p_headerTST,
            	in template (present) StationTypeIdentifier p_stationType
            ) := {
            	version := c_geoNwProtocolVersion,
                nextHeader := p_nextHeader,
    			headerTST := p_headerTST,
                reserved := c_uInt8Zero,
                flags := mw_flags(p_stationType),
                plLength := ?, 
                trafficClass := ?,
                hopLimit := ?,
                senderPosVector := p_senderLongPosVec    
            }
            
            template CommonHeader mw_commonHeaderBeacon (
            	in template (present) StationTypeIdentifier p_stationType,
            	in template (present) TrafficClass p_trafficClass,
            	in template (present) UInt8 p_hopLimit,
                in template (present) LongPosVector p_senderLongPosVec
        ) := {
				version := c_geoNwProtocolVersion,
				nextHeader := e_any, // 0
				headerTST := {
					beaconHdr := {	headerType := e_beacon, // 0
					    			headerSubType := 0}
				},
				reserved := c_uInt8Zero,
				flags := mw_flags(p_stationType),
				plLength := 0,
				trafficClass := p_trafficClass,
				hopLimit := p_hopLimit,
				senderPosVector := p_senderLongPosVec
			}
          
            template CommonHeader mw_commonHeaderWithHopLimit (
                in template (present) LongPosVector p_senderLongPosVec,
            	in template (present) NextHeader p_nextHeader,
            	in template (present) HeaderTST p_headerTST,
            	in template (present) StationTypeIdentifier p_stationType,
            	in template (present) UInt8 p_hopLimit
            ) modifies mw_commonHeader := {
                hopLimit := p_hopLimit   
            }
            
            template (value) Flags m_flags(
            	in template (value) StationTypeIdentifier p_stationType
            ) := {
                reserved := c_uInt6Zero,
                stationType := p_stationType,
                reserved2 := c_uInt1Zero            
            }
            
            template Flags mw_flags(
            	in template (present) StationTypeIdentifier p_stationType
            ) := {
                reserved := c_uInt6Zero,
                stationType := p_stationType,
                reserved2 := c_uInt1Zero            
            }
         
            template (value) TrafficClass m_trafficClass := {
                reserved := c_uInt1Zero,
                relevance := c_uInt3Zero,
                reliability := e_veryHigh,
                latency := e_veryLow
            }
            
            template GN_Address mw_gnAddressAny := {
                typeOfAddress := ?,
                stationType := ?,
                stationSubType := ?,
                stationCountryCode := ?,
                mid := ?
            }
         
            
            template LongPosVector mw_longPosVectorAny(
            	in template (present) GN_Address p_gnAddress
        	) := {
                    gnAddr := p_gnAddress,
                    timestamp := ?,
                    latitute := ?,
                    longitude := ?,
                    speed := ?,
                    heading := ?,
                    altitude := ?,
                    timeAccuracy := ?,
                    posAccuracy := ?,
                    speedAccuracy := ?,
                    headingAccuracy := ?,
                    altitudeAccuracy := ?
            }
         
	   	} // end geoNwCommonHeaderTemplates
    
    	group geoUnicastHeaderTemplates {
    	    
    	    template (value) Header m_geoUnicastHeader(
    	    	in template (value) LongPosVector p_sourceLongPosVec,
    	    	in template (value) ShortPosVector p_destinationLongPosVec,
    	    	in template (value) LongPosVector p_senderLongPosVec,
    	    	in template (value) StationTypeIdentifier p_stationType,
    	    	in template (value) UInt16 p_seqNumber
    	    ) := {
                geoUnicastHeader := {
                    commonHeader := m_commonHeader(
                    	e_ipv6,
                    	m_geoUnicastHeaderType,
                    	m_trafficClass,
                    	c_defaultHopLimit,
                    	p_senderLongPosVec,
    					p_stationType
                    ),
                    seqNumber := p_seqNumber,
                    lifetime := m_lifetime,
                    reserved := c_uInt8Zero,
               		srcPosVector := p_sourceLongPosVec,
                	dstPosVector := p_destinationLongPosVec
                }
    	    }    
          
            template (value) Header m_geoUnicastHeaderWithHopLimit(
                in template (value) LongPosVector p_sourceLongPosVec,
                in template (value) ShortPosVector p_destinationLongPosVec,
                in template (value) LongPosVector p_senderLongPosVec,
                in template (value) StationTypeIdentifier p_stationType,
                in template (value) UInt16 p_seqNumber,
                in template (value) UInt8 p_hopLimit
            ) modifies m_geoUnicastHeader := {
                geoUnicastHeader := {
                    commonHeader := {
                      hopLimit := p_hopLimit
                    }
                }
            }    

    	    template Header mw_geoUnicastHeader(
    	    	in template (present) LongPosVector p_senderLongPosVec,
    	    	in template (present) ShortPosVector p_destinationShortPosVec,
    			in template (present) StationTypeIdentifier p_stationType,
    	    	in template (present) UInt16 p_seqNumber
    	    ) := {
                geoUnicastHeader := {
                    commonHeader := mw_commonHeader(
                        p_senderLongPosVec,
                    	?,
                    	mw_geoUnicastHeaderType,
                    	p_stationType
                    ),
                    seqNumber := p_seqNumber,
                    lifetime := ?,
                    reserved := ?,
               		srcPosVector := ?,
                	dstPosVector := p_destinationShortPosVec
                }
    	    }    
    	    
    	    template Header mw_geoUnicastHeaderWithHopLimit(
    	    	in template (present) LongPosVector p_senderLongPosVec,
    	    	in template (present) ShortPosVector p_destinationShortPosVec,
    			in template (present) StationTypeIdentifier p_stationType,
    	    	in template (present) UInt16 p_seqNumber,
    	    	in template (present) UInt8 p_hopLimit
    	    ) modifies mw_geoUnicastHeader := {
                geoUnicastHeader := {
                    commonHeader := {
                        hopLimit := p_hopLimit
                    }
                }
    	    } 
    	    
    	    template (value) HeaderTST m_geoUnicastHeaderType := {
                geoUnicastHdr := {
                	headerType := e_geoUnicast,
                    headerSubType := c_uInt4Zero
                }
            }      
            
            template HeaderTST mw_geoUnicastHeaderType := {
                geoUnicastHdr := {
                	headerType := e_geoUnicast,
                    headerSubType := c_uInt4Zero
                }
            }       
    	    
    	} // end geoUnicastHeaderTemplates
    
        group geoBroadcastHeaderTemplates {
            
    		template (value) Header m_geoBroadcastHeader(
            	in template (value) LongPosVector p_sourceLongPosVec,
            	in template (value) LongPosVector p_senderLongPosVec,
    			in template (value) StationTypeIdentifier p_stationType,
            	in template (value) UInt16 p_seqNumber,
            	in template (value) BroadcastArea p_broadcastArea
            ) := {
                geoBroadcastHeader := {
                    commonHeader := m_commonHeader(
                    	e_btp,
                    	m_geoBroadcastHeaderType(p_broadcastArea.geoBroadcastSubType),
                    	m_trafficClass,
                    	c_defaultHopLimit,
                    	p_senderLongPosVec,
    					p_stationType
                    ),
                    seqNumber := p_seqNumber,
                    lifetime := m_lifetime,
                    reserved := c_uInt8Zero,
                    srcPosVector := p_sourceLongPosVec,
                    geoAreaPosLatitude := p_broadcastArea.geoBroadcastArea.geoAreaPosLatitude,
                    geoAreaPosLongitude := p_broadcastArea.geoBroadcastArea.geoAreaPosLongitude,
                    distanceA := p_broadcastArea.geoBroadcastArea.distanceA,
                    distanceB := p_broadcastArea.geoBroadcastArea.distanceB,
                    angle := p_broadcastArea.geoBroadcastArea.angle,
                    reserved2 := c_uInt24Zero
                }
            }  
            
            template (value) Header m_geoBroadcastHeaderWithHopLimit(
                in template (value) LongPosVector p_sourceLongPosVec,
                in template (value) LongPosVector p_senderLongPosVec,
                in template (value) StationTypeIdentifier p_stationType,
                in template (value) UInt16 p_seqNumber,
                in template (value) BroadcastArea p_broadcastArea,
                in template (value) UInt8 p_hopLimit
            ) modifies m_geoBroadcastHeader := {
                geoBroadcastHeader := {
                    commonHeader := m_commonHeader(
                        e_btp,
                        m_geoBroadcastHeaderType(p_broadcastArea.geoBroadcastSubType),
                        m_trafficClass,
                        p_hopLimit,
                        p_senderLongPosVec,
                        p_stationType
                    )
                }
            }
            
            template Header mw_geoBroadcastHeader(
                in template (present) LongPosVector p_sourceLongPosVec,
                in template (present) LongPosVector p_senderLongPosVec,
    			in template (present) StationTypeIdentifier p_stationType,
            	in template (present) UInt16 p_seqNumber
            ) := {
                geoBroadcastHeader := {
                    commonHeader := mw_commonHeader(
                        p_senderLongPosVec,
                        ?,
                    	mw_geoBroadcastHeaderType,
                    	p_stationType
                    ),
                    seqNumber := p_seqNumber,
                    lifetime := ?,
                    reserved := c_uInt8Zero,
                    srcPosVector := p_sourceLongPosVec,
                    geoAreaPosLatitude := ?,
                    geoAreaPosLongitude := ?,
                    distanceA := ?,
                    distanceB := ?,
                    angle := ?,
                    reserved2 := c_uInt24Zero
                }
            } 
                       
            template Header mw_geoBroadcastHeaderWithArea (
                in template (present) LongPosVector p_sourceLongPosVec,
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) StationTypeIdentifier p_stationType,
                in template (present) UInt16 p_seqNumber,
                in template (present) BroadcastArea p_broadcastArea
            ) modifies mw_geoBroadcastHeader := {
                geoBroadcastHeader := {
                    commonHeader := mw_commonHeader(
                        p_senderLongPosVec,
                        ?,
                        mw_geoBroadcastHeaderTypeWithSubType(p_broadcastArea.geoBroadcastSubType),
                        p_stationType
                    ),
                    geoAreaPosLatitude := p_broadcastArea.geoBroadcastArea.geoAreaPosLatitude,
                    geoAreaPosLongitude := p_broadcastArea.geoBroadcastArea.geoAreaPosLongitude,
                    distanceA := p_broadcastArea.geoBroadcastArea.distanceA,
                    distanceB := p_broadcastArea.geoBroadcastArea.distanceB,
                    angle := p_broadcastArea.geoBroadcastArea.angle
                }
            } 

            template Header mw_geoBroadcastHeaderWithAreaWithHopLimit(
                in template (present) LongPosVector p_sourceLongPosVec,
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) StationTypeIdentifier p_stationType,
                in template (present) UInt16 p_seqNumber,   
                in template (present) BroadcastArea p_broadcastArea,             
                in template (present) UInt8 p_hopLimit
            ) modifies mw_geoBroadcastHeaderWithArea := {
                geoBroadcastHeader := {
                    commonHeader := mw_commonHeaderWithHopLimit(
                        p_senderLongPosVec,
                        ?,
                        mw_geoBroadcastHeaderType,
                        p_stationType, 
                        p_hopLimit
                    )
                } 
            }
                        
            template (value) HeaderTST m_geoBroadcastHeaderType(
            	in template (value) HeaderSubTypeGeoBroadcast p_headerSubType
            ) := {
                geoBroadcastHdr := {
                	headerType := e_geoBroadcast,
                	headerSubType := p_headerSubType
                }
            }      
            
            template HeaderTST mw_geoBroadcastHeaderType := {
                geoBroadcastHdr := {
                	headerType := e_geoBroadcast,
                	headerSubType := ?
                }
            }       
            
            template HeaderTST mw_geoBroadcastHeaderTypeWithSubType(
            	in template (present) HeaderSubTypeGeoBroadcast p_headerSubType
            ) modifies mw_geoBroadcastHeaderType := {
                geoBroadcastHdr := {
                	headerSubType := p_headerSubType
                }
            }       
                        
            template (value) Lifetime m_lifetime := {
                multiplier := c_defaultLifetime,
                ltBase := e_1s
            }
                
        } // end geoBroadcastHeaderTemplates

        group geoAnycastHeaderTemplates {
            
            template (value) Header m_geoAnycastHeader(
                in template (value) LongPosVector p_sourceLongPosVec,
                in template (value) LongPosVector p_senderLongPosVec,
                in template (value) StationTypeIdentifier p_stationType,
                in template (value) UInt16 p_seqNumber,
                in template (value) AnycastArea p_anycastArea
            ) := {
                geoAnycastHeader := {
                    commonHeader := m_commonHeader(
                        e_btp,
                        m_geoAnycastHeaderType(p_anycastArea.geoAnycastSubType),
                        m_trafficClass,
                        c_defaultHopLimit,
                        p_senderLongPosVec,
                        p_stationType
                    ),
                    seqNumber := p_seqNumber,
                    lifetime := m_lifetime,
                    reserved := c_uInt8Zero,
                    srcPosVector := p_sourceLongPosVec,
                    geoAreaPosLatitude := p_anycastArea.geoAnycastArea.geoAreaPosLatitude,
                    geoAreaPosLongitude := p_anycastArea.geoAnycastArea.geoAreaPosLongitude,
                    distanceA := p_anycastArea.geoAnycastArea.distanceA,
                    distanceB := p_anycastArea.geoAnycastArea.distanceB,
                    angle := p_anycastArea.geoAnycastArea.angle,
                    reserved2 := c_uInt24Zero
                }
            }  
            
            template (value) Header m_geoAnycastHeaderWithHopLimit(
                in template (value) LongPosVector p_sourceLongPosVec,
                in template (value) LongPosVector p_senderLongPosVec,
                in template (value) StationTypeIdentifier p_stationType,
                in template (value) UInt16 p_seqNumber,
                in template (value) AnycastArea p_anycastArea,
                in template (value) UInt8 p_hopLimit
            ) modifies m_geoAnycastHeader := {
                geoAnycastHeader := {
                    commonHeader := m_commonHeader(
                        e_btp,
                        m_geoAnycastHeaderType(p_anycastArea.geoAnycastSubType),
                        m_trafficClass,
                        p_hopLimit,
                        p_senderLongPosVec,
                        p_stationType
                    )
                }
            }
            
            template Header mw_geoAnycastHeader(
                in template (present) LongPosVector p_sourceLongPosVec,
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) StationTypeIdentifier p_stationType,
                in template (present) UInt16 p_seqNumber
            ) := {
                geoAnycastHeader := {
                    commonHeader := mw_commonHeader(
                        p_senderLongPosVec,
                        ?,
                        mw_geoAnycastHeaderType,
                        p_stationType                        
                    ),
                    seqNumber := p_seqNumber,
                    lifetime := ?,
                    reserved := c_uInt8Zero,
                    srcPosVector := p_sourceLongPosVec,
                    geoAreaPosLatitude := ?,
                    geoAreaPosLongitude := ?,
                    distanceA := ?,
                    distanceB := ?,
                    angle := ?,
                    reserved2 := c_uInt24Zero
                }
            } 
                       
            template Header mw_geoAnycastHeaderWithArea (
                in template (present) LongPosVector p_sourceLongPosVec,
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) StationTypeIdentifier p_stationType,
                in template (present) UInt16 p_seqNumber,
                in template (present) AnycastArea p_anycastArea
            ) modifies mw_geoAnycastHeader := {
                geoAnycastHeader := {
                    commonHeader := mw_commonHeader(
                        p_senderLongPosVec,
                        ?,
                        mw_geoAnycastHeaderTypeWithSubType(p_anycastArea.geoAnycastSubType),
                        p_stationType                 
                    ),
                    geoAreaPosLatitude := p_anycastArea.geoAnycastArea.geoAreaPosLatitude,
                    geoAreaPosLongitude := p_anycastArea.geoAnycastArea.geoAreaPosLongitude,
                    distanceA := p_anycastArea.geoAnycastArea.distanceA,
                    distanceB := p_anycastArea.geoAnycastArea.distanceB,
                    angle := p_anycastArea.geoAnycastArea.angle
                }
            } 

            template Header mw_geoAnycastHeaderWithAreaWithHopLimit(
                in template (present) LongPosVector p_sourceLongPosVec,
                in template (present) LongPosVector p_senderLongPosVec,
                in template (present) StationTypeIdentifier p_stationType,
                in template (present) UInt16 p_seqNumber,   
                in template (present) AnycastArea p_anycastArea,             
                in template (present) UInt8 p_hopLimit
            ) modifies mw_geoAnycastHeaderWithArea := {
                geoAnycastHeader := {
                    commonHeader := mw_commonHeaderWithHopLimit(
                        p_senderLongPosVec,
                        ?,
                        mw_geoAnycastHeaderType,
                        p_stationType, 
                        p_hopLimit
                    )
                } 
            }
                        
            template (value) HeaderTST m_geoAnycastHeaderType(
                in template (value) HeaderSubTypeGeoAnycast p_headerSubType
            ) := {
                geoAnycastHdr := {
                    headerType := e_geoAnycast,
                    headerSubType := p_headerSubType
                }
            }      
            
            template HeaderTST mw_geoAnycastHeaderType := {
                geoAnycastHdr := {
                    headerType := e_geoAnycast,
                    headerSubType := ?
                }
            }       
            
            template HeaderTST mw_geoAnycastHeaderTypeWithSubType(
                in template (present) HeaderSubTypeGeoAnycast p_headerSubType
            ) modifies mw_geoAnycastHeaderType := {
                geoAnycastHdr := {
                    headerSubType := p_headerSubType
                }
            }       
               
        } // end geoAnycastHeaderTemplates

        group lsRequestHeaderTemplates {
            
            template (value) Header m_lsRequestHeader(
            	in template (value) LongPosVector p_sourceLongPosVec,
            	in template (value) LongPosVector p_senderLongPosVec,
    			in template (value) StationTypeIdentifier p_stationType,
    			in template (value) UInt16 p_seqNumber,
            	in template (value) GN_Address p_gnAddress      
            ) := {
                lsRequestHeader := {
                	commonHeader := m_commonHeader(
                    	e_btp,
                    	m_lsRequestHeaderType,
                    	m_trafficClass,
                    	c_defaultHopLimit,
                    	p_senderLongPosVec,
    					p_stationType
                    ),    
                    seqNumber := p_seqNumber,
                	lifetime := m_lifetime,
                	reserved := c_uInt8Zero,
                	srcPosVector := p_sourceLongPosVec,
               		gnAddress := p_gnAddress
                }
            }
            
            template Header mw_lsRequestHeader(
     			in template (present) StationTypeIdentifier p_stationType,
    			in template (present) UInt16 p_seqNumber,
            	in template (present) GN_Address p_gnAddress      
            ) := {
                lsRequestHeader := {
                	commonHeader := mw_commonHeader(
                        ?,
                    	e_any,
                    	mw_lsRequestHeaderType,
                    	p_stationType
                    ),    
                    seqNumber := p_seqNumber,
                	lifetime := ?,
                	reserved := ?,
                	srcPosVector := ?,
               		gnAddress := p_gnAddress
                }
            }
            
            template Header mw_lsRequestHeader_withHopLimit(
                in template (present) StationTypeIdentifier p_stationType,
                in template (present) UInt16 p_seqNumber,
                in template (present) GN_Address p_gnAddress,
                in template (present) UInt8 p_hopLimit
            ) modifies mw_lsRequestHeader := {
                lsRequestHeader := {
                  commonHeader := {
                      hopLimit := p_hopLimit
                  }
                }
            }
            
            template (value) HeaderTST m_lsRequestHeaderType := {
                lsHdr := {
                	headerType := e_locationService,
                	headerSubType := e_lsRequest
                }
            }      
            
            template HeaderTST mw_lsRequestHeaderType := {
                lsHdr := {
                	headerType := e_locationService,
                	headerSubType := e_lsRequest
                }
            }       
            
        } // end lsRequestHeaderTemplates 
                    
        group lsReplyHeaderTemplates {
            
            template (value) Header m_lsReplyHeader(
              in template (value) LongPosVector p_sourceLongPosVec,
              in template (value) LongPosVector p_destinationLongPosVec,
              in template (value) LongPosVector p_senderLongPosVec,
              in template (value) StationTypeIdentifier p_stationType,
              in template (value) UInt16 p_seqNumber
            ) := {
                lsReplyHeader := {
                  commonHeader := m_commonHeader(
                      e_btp,
                      m_lsRequestHeaderType,
                      m_trafficClass,
                      c_defaultHopLimit,
                      p_senderLongPosVec,
                      p_stationType
                  ),    
                  seqNumber := p_seqNumber,
                  lifetime := m_lifetime,
                  reserved := c_uInt8Zero,
                  srcPosVector := p_sourceLongPosVec,
                  dstPosVector := p_destinationLongPosVec
                }
            }
            
            template Header mw_lsReplyHeaderAny(
              in template (present) StationTypeIdentifier p_stationType,
              in template (present) UInt16 p_seqNumber
            ) := {
                lsReplyHeader := {
                commonHeader := mw_commonHeader(
                    ?,
                    e_any,
                    m_lsReplyHeaderType,
                    p_stationType
                ),    
                seqNumber := p_seqNumber,
                lifetime := ?,
                reserved := ?,
                srcPosVector := ?,
                dstPosVector := ?
                }
            }
            
            template Header mw_lsReplyHeader(
                in template (present) StationTypeIdentifier p_stationType,
                in template (present) UInt16 p_seqNumber, 
                in template (present) LongPosVector p_sourceLongPosVec, 
                in template (present) LongPosVector p_destinationLongPosVec)
            modifies mw_lsReplyHeaderAny := {
                lsReplyHeader := {
                    srcPosVector := p_sourceLongPosVec,
                    dstPosVector := p_destinationLongPosVec
                }
            }

            
            template (value) HeaderTST m_lsReplyHeaderType := {
                lsHdr := {
                  headerType := e_locationService,
                  headerSubType := e_lsReply
                }
            }      
            
        } // end lsRequestHeaderTemplates 
                    
		group beaconHeaderTemplates {
		    
		    template (value) Header m_beaconHeader(
            	in template (value) LongPosVector p_senderLongPosVec
            ) := {
                beaconHeader := {
                	commonHeader := m_commonHeader(
                    	e_btp,
                    	m_beaconHeaderType,
                    	m_trafficClass,
                    	c_defaultHopLimit,
                    	p_senderLongPosVec,
    					e_vehicleStation
                    )
                }
            }
            
            template Header mw_beaconHeader(
            in template (present) StationTypeIdentifier p_stationType,
            in template (present) TrafficClass p_trafficClass,
            in template (present) UInt8 p_hopLimit,
            in template (present) LongPosVector p_senderLongPosVec
            ) := {
                beaconHeader := {
                   	commonHeader := mw_commonHeaderBeacon(
                        p_stationType,
                        p_trafficClass,
                        p_hopLimit,
                        p_senderLongPosVec
                    )
                }
            }
            
            template (value) HeaderTST m_beaconHeaderType := {
                beaconHdr := {
                	headerType := e_beacon,
                    headerSubType := c_uInt4Zero
                }
            }      
            
            template HeaderTST mw_beaconHeaderType := {
                beaconHdr := {
                	headerType := e_beacon,
                    headerSubType := ?
                }
            }   
		    
		} // end beaconHeaderTemplates                    
                    
        group shbHeaderTemplates {
            
            template (value) Header m_shbHeader(
                in template (value) LongPosVector p_senderLongPosVec,
                in template (value) StationTypeIdentifier p_stationType
            ) := {
                shbHeader := {
                    commonHeader := m_commonHeader(
                        e_any,
                        m_shbHeaderType,
                        m_trafficClass,
                        c_defaultHopLimit,
                        p_senderLongPosVec,
                        p_stationType
                    )
                }
            }
            
            template Header mw_shbHeader(
                in template (present) StationTypeIdentifier p_stationType
            ) := {
                shbHeader := {
                    commonHeader := mw_commonHeaderWithHopLimit(
                        ?, // SE PV
                        ?, // NH
                        m_shbHeaderType, // HT + HST
                        p_stationType,
                        1 // HL
                    )
                }
            }
            
            template (value) HeaderTST m_shbHeaderType := {
                tsbHdr := {
                  headerType := e_topologicallyScopedBroadcast,
                  headerSubType := e_singleHop
                }
            }      
            
        } // end shbHeaderTemplates
        
        group tsbHeaderTemplates {
            
            template Header m_tsbHeader(
                in template (value) LongPosVector p_senderLongPosVec,
                in template (value) StationTypeIdentifier p_stationType,
                in template (value) UInt16 p_seqNumber,
                in template (value) LongPosVector p_srcPosVector
            ) := {
                tsbHeader := {
                    commonHeader := m_commonHeader(
                        e_any, 
                        m_shbHeaderType, 
                        m_trafficClass,
                        c_defaultHopLimit, 
                        p_senderLongPosVec,
                        p_stationType
                    ),
                    seqNumber := p_seqNumber,
                    lifetime := m_lifetime,
                    reserved := c_uInt8Zero,
                    srcPosVector := p_srcPosVector
                }
            }
            
            template Header m_tsbHeaderWithHopLimit(
                in template (value) LongPosVector p_senderLongPosVec,
                in template (value) StationTypeIdentifier p_stationType,
                in template (value) UInt16 p_seqNumber,
                in template (value) LongPosVector p_srcPosVector,
                in template (value) UInt8 p_hopLimit
            ) modifies m_tsbHeader := {
                tsbHeader := {
                    commonHeader := {
                        hopLimit := p_hopLimit
                    }
                }
            }
            
            template Header mw_tsbHeader(
                in template (present) StationTypeIdentifier p_stationType,
                in template (present) UInt16 p_seqNumber, 
                in template (present) LongPosVector p_srcPosVector
            ) := {
                tsbHeader := {
                    commonHeader := mw_commonHeader(
                        ?,
                        e_any,
                        m_tsbHeaderType,
                        p_stationType
                    ),
                    seqNumber := p_seqNumber,
                    lifetime := ?,
                    reserved := ?,
                    srcPosVector := p_srcPosVector
                }
            }
            
            template Header mw_tsbHeaderWithHopLimit(
                in template (present) StationTypeIdentifier p_stationType,
                in template (present) UInt16 p_seqNumber, 
                in template (present) LongPosVector p_srcPosVector,
                in template (present) UInt8 p_hopLimit 
            ) modifies mw_tsbHeader := {
                tsbHeader := {
                    commonHeader := {
                      hopLimit := p_hopLimit
                    }
                }
            }
            
            template (value) HeaderTST m_tsbHeaderType := {
                tsbHdr := {
                  headerType := e_topologicallyScopedBroadcast,
                  headerSubType := e_multiHop
                }
            }      
            
        } // end tsbHeaderTemplates
        
    } // end geoNwHeadersTemplates
    
    group geoMiscTemplates {
        
        group geoDummyTemplates {
            
            template (value) GN_Address m_dummyGnAddr := {
                typeOfAddress := e_manual,
                stationType := {
                    vehicleStation := {
                        stationType := e_vehicleStation,
                        vsKind := e_car   
                    }
                },
                stationSubType := e_private,
                stationCountryCode := c_uInt10Zero,
                mid := c_uInt48Zero              
            }
            
            template (value) LongPosVector m_dummyLongPosVector := {
                gnAddr := m_dummyGnAddr,
                timestamp := c_uInt32Zero,
                latitute := c_uInt32Zero,
                longitude := c_uInt32Zero,
                speed := c_uInt16Zero,
                heading := c_uInt16Zero,
                altitude := c_uInt16Zero,
                timeAccuracy := c_uInt4Zero,
                posAccuracy := c_uInt4Zero,
                speedAccuracy := c_uInt3Zero,
                headingAccuracy := c_uInt3Zero,
                altitudeAccuracy := c_uInt2Zero
            }
            
            template (value) Area m_dummyArea := {
                geoAreaPosLatitude := c_uInt32Zero,
                geoAreaPosLongitude := c_uInt32Zero,
                distanceA := c_uInt16Zero,
                distanceB := c_uInt16Zero,
                angle := c_uInt8Zero    
            }
        
            template (value) BroadcastArea m_dummyGeoBroadcastArea := {
                geoBroadcastSubType := e_geoBroadcastRect,
                geoBroadcastArea := m_dummyArea
            }
            
        } // end geoDummyTemplates
        
    } // end geoMiscTemplates
    
} // end ItsGeoNetworking_Templates