transformer

var DbToYang_acl_destination_port_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_acl_destination_port_xfmr: ", data, inParams.ygRoot)
	if _, ok := data[RULE_TABLE]; !ok {
		err = errors.New("RULE_TABLE entry not found in the input param")
		return result, err
	}
	ruleTbl := data[RULE_TABLE]
	ruleInst := ruleTbl[inParams.key]
	port, ok := ruleInst.Field["L4_DST_PORT"]
	if ok {
		result["destination-port"] = port
		return result, nil
	}

	portRange, ok := ruleInst.Field["L4_DST_PORT_RANGE"]
	if ok {
		result["destination-port"] = portRange
		return result, nil
	} else {
		err = errors.New("DST PORT/PORT_RANGE field not found in DB")
	}
	return result, err
}

var DbToYang_acl_entry_sequenceid_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error
	log.Info("DbToYang_acl_entry_sequenceid_xfmr: ", inParams.key)

	res, err := DbToYang_acl_entry_key_xfmr(inParams)
	log.Info("acl-entry/config/sequence-id ", res)
	if err != nil {
		return res_map, err
	}
	if seqId, ok := res["sequence-id"]; !ok {
		log.Error("sequence-id not found in acl entry")
		return res_map, err
	} else {
		res_map["sequence-id"] = seqId
	}
	return res_map, err
}

var DbToYang_acl_forwarding_action_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_acl_forwarding_action_xfmr", data, inParams.ygRoot)
	oc_action := findInMap(ACL_FORWARDING_ACTION_MAP, data[RULE_TABLE][inParams.key].Field["PACKET_ACTION"])
	n, err := strconv.ParseInt(oc_action, 10, 64)
	result["forwarding-action"] = ocbinds.E_OpenconfigAcl_FORWARDING_ACTION(n).ΛMap()["E_OpenconfigAcl_FORWARDING_ACTION"][n].Name
	return result, err
}

var DbToYang_acl_ip_protocol_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_acl_ip_protocol_xfmr", data, inParams.ygRoot)
	oc_protocol := findByValue(IP_PROTOCOL_MAP, data[RULE_TABLE][inParams.key].Field["IP_PROTOCOL"])
	n, err := strconv.ParseInt(oc_protocol, 10, 64)
	result["protocol"] = ocbinds.E_OpenconfigPacketMatchTypes_IP_PROTOCOL(n).ΛMap()["E_OpenconfigPacketMatchTypes_IP_PROTOCOL"][n].Name
	return result, err
}

var DbToYang_acl_l2_ethertype_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_acl_l2_ethertype_xfmr", data, inParams.ygRoot)
	if _, ok := data[RULE_TABLE]; !ok {
		err = errors.New("RULE_TABLE entry not found in the input param")
		return result, err
	}

	ruleTbl := data[RULE_TABLE]
	ruleInst := ruleTbl[inParams.key]
	etype, ok := ruleInst.Field["ETHER_TYPE"]

	if ok {
		etypeVal, _ := strconv.ParseUint(strings.Replace(etype, "0x", "", -1), 16, 32)
		result["protocol"] = getL2EtherType(etypeVal)
	} else {
		err = errors.New("ETHER_TYPE field not found in DB")
	}
	return result, nil
}

var DbToYang_acl_set_name_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error
	log.Info("DbToYang_acl_set_name_xfmr: ", inParams.key)

	aclName, _ := getOCAclKeysFromStrDBKey(inParams.key)
	res_map["name"] = aclName
	log.Info("acl-set/config/name  ", res_map)
	return res_map, err
}

var DbToYang_acl_source_port_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_acl_source_port_xfmr: ", data, inParams.ygRoot)
	result := make(map[string]interface{})
	if _, ok := data[RULE_TABLE]; !ok {
		err = errors.New("RULE_TABLE entry not found in the input param")
		return result, err
	}
	ruleTbl := data[RULE_TABLE]
	ruleInst := ruleTbl[inParams.key]
	port, ok := ruleInst.Field["L4_SRC_PORT"]
	if ok {
		result["source-port"] = port
		return result, nil
	}

	portRange, ok := ruleInst.Field["L4_SRC_PORT_RANGE"]
	if ok {
		result["source-port"] = portRange
		return result, nil
	} else {
		err = errors.New("PORT/PORT_RANGE field not found in DB")
	}
	return result, err
}

var DbToYang_acl_tcp_flags_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_acl_tcp_flags_xfmr: ", data, inParams.ygRoot)
	result := make(map[string]interface{})
	if _, ok := data[RULE_TABLE]; !ok {
		err = errors.New("RULE_TABLE entry not found in the input param")
		return result, err
	}
	ruleTbl := data[RULE_TABLE]
	ruleInst := ruleTbl[inParams.key]
	tcpFlag, ok := ruleInst.Field["TCP_FLAGS"]
	if ok {
		result["tcp-flags"] = getTransportConfigTcpFlags(tcpFlag)
		return result, nil
	}
	return result, nil
}

var DbToYang_acl_type_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_acl_type_field_xfmr", data, inParams.ygRoot)
	oc_acltype := findInMap(ACL_TYPE_MAP, data[ACL_TABLE][inParams.key].Field[ACL_TYPE])
	n, err := strconv.ParseInt(oc_acltype, 10, 64)
	result[ACL_TYPE] = ocbinds.E_OpenconfigAcl_ACL_TYPE(n).ΛMap()["E_OpenconfigAcl_ACL_TYPE"][n].Name
	return result, err
}

var DbToYang_as_path_set_name_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	key := inParams.key
	log.Info("DbToYang_as_path_set_name_fld_xfmr: ", key)
	setTblKey := strings.Split(key, "|")
	setName := setTblKey[0]

	res_map["as-path-set-name"] = setName
	log.Info("config/name  ", res_map)
	return res_map, err
}

var DbToYang_bgp_advertise_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})
	var afi_list []string

	log.Info(inParams.key)

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_advertise_fld_xfmr : ", data, "inParams : ", inParams)

	pTbl := data["BGP_GLOBALS_AF"]
	log.Info("Table: ", pTbl)
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_bgp_advertise_fld_xfmr BGP AF not found : ", inParams.key)
		return result, errors.New("BGP AF not found : " + inParams.key)
	}
	GblAfData := pTbl[inParams.key]

	adv_ipv4_uni, ok := GblAfData.Field["advertise-ipv4-unicast"]
	if ok {
		if adv_ipv4_uni == "true" {
			afi_list = append(afi_list, "IPV4_UNICAST")
		}
	} else {
		log.Info("advertise-ipv4-unicast field not found in DB")
	}

	adv_ipv6_uni, ok := GblAfData.Field["advertise-ipv6-unicast"]
	if ok {
		if adv_ipv6_uni == "true" {
			afi_list = append(afi_list, "IPV6_UNICAST")
		}
	} else {
		log.Info("advertise-ipv6-unicast field not found in DB")
	}

	result["advertise-list"] = afi_list

	return result, err
}

var DbToYang_bgp_dyn_neigh_listen_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	entry_key := inParams.key
	log.Info("DbToYang_bgp_dyn_neigh_listen_key_xfmr: ", entry_key)

	dynKey := strings.Split(entry_key, "|")

	rmap["prefix"] = dynKey[1]

	return rmap, err
}

var DbToYang_bgp_gbl_afi_safi_addr_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	entry_key := inParams.key
	log.Info("DbToYang_bgp_gbl_afi_safi_addr_field_xfmr: ", entry_key)

	dynKey := strings.Split(entry_key, "|")

	rmap["prefix"] = dynKey[2]

	return rmap, err
}

var DbToYang_bgp_gbl_afi_safi_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	entry_key := inParams.key
	log.Info("DbToYang_bgp_gbl_afi_safi_field_xfmr: ", entry_key)

	mpathKey := strings.Split(entry_key, "|")
	afi := ""

	switch mpathKey[1] {
	case "ipv4_unicast":
		afi = "IPV4_UNICAST"
	case "ipv6_unicast":
		afi = "IPV6_UNICAST"
	case "l2vpn_evpn":
		afi = "L2VPN_EVPN"
	default:
		return rmap, nil
	}

	rmap["afi-safi-name"] = afi

	return rmap, err
}

var DbToYang_bgp_local_asn_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_local_asn_fld_xfmr: ")

	pTbl := data["BGP_GLOBALS"]
	if _, ok := pTbl[inParams.key]; !ok {
		return result, err
	}
	pGblKey := pTbl[inParams.key]
	curr_asn, ok := pGblKey.Field["local_asn"]
	if ok {
		local_asn64, _ := strconv.ParseUint(curr_asn, 10, 32)
		local_asn := uint32(local_asn64)
		result["as"] = local_asn
	} else {
		log.Info("Local ASN field not found in DB")
	}
	return result, err
}

var DbToYang_bgp_nbr_address_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	entry_key := inParams.key
	nbrAddrKey := strings.Split(entry_key, "|")
	nbrAddr := nbrAddrKey[1]

	result["neighbor-address"] = nbrAddr

	return result, err
}

var DbToYang_bgp_nbr_afi_safi_name_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	var nbrAfName string
	result := make(map[string]interface{})

	entry_key := inParams.key
	nbrAfKey := strings.Split(entry_key, "|")

	switch nbrAfKey[2] {
	case "ipv4_unicast":
		nbrAfName = "IPV4_UNICAST"
	case "ipv6_unicast":
		nbrAfName = "IPV6_UNICAST"
	case "l2vpn_evpn":
		nbrAfName = "L2VPN_EVPN"
	default:
		return result, nil
	}
	result["afi-safi-name"] = nbrAfName

	return result, err
}

var DbToYang_bgp_nbr_community_type_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_nbr_community_type_fld_xfmr : ", data, "inParams : ", inParams)

	pTbl := data["BGP_NEIGHBOR_AF"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_bgp_nbr_community_type_fld_xfmr BGP Peer group not found : ", inParams.key)
		return result, errors.New("BGP neighbor not found : " + inParams.key)
	}
	pGrpKey := pTbl[inParams.key]
	community_type, ok := pGrpKey.Field["send_community"]

	if ok {
		if community_type == "standard" {
			result["send-community"] = "STANDARD"
		} else if community_type == "extended" {
			result["send-community"] = "EXTENDED"
		} else if community_type == "both" {
			result["send-community"] = "BOTH"
		} else if community_type == "none" {
			result["send-community"] = "NONE"
		}
	} else {
		log.Info("send_community not found in DB")
	}
	return result, err
}

var DbToYang_bgp_nbr_orf_type_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_nbr_orf_type_fld_xfmr : ", data, "inParams : ", inParams)

	pTbl := data["BGP_NEIGHBOR_AF"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_bgp_nbr_orf_type_fld_xfmr BGP neighbor not found : ", inParams.key)
		return result, errors.New("BGP neighbor not found : " + inParams.key)
	}
	pNbrKey := pTbl[inParams.key]
	orf_type, ok := pNbrKey.Field["cap_orf"]

	if ok {
		if orf_type == "send" {
			result["orf-type"] = "SEND"
		} else if orf_type == "receive" {
			result["orf-type"] = "RECEIVE"
		} else if orf_type == "both" {
			result["orf-type"] = "BOTH"
		}
	} else {
		log.Info("cap_orf_direction field not found in DB")
	}
	return result, err
}

var DbToYang_bgp_nbr_peer_type_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_nbr_peer_type_fld_xfmr : ", data, "inParams : ", inParams)

	pTbl := data["BGP_NEIGHBOR"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_bgp_nbr_peer_type_fld_xfmr BGP neighbor not found : ", inParams.key)
		return result, errors.New("BGP neighbor not found : " + inParams.key)
	}
	pGrpKey := pTbl[inParams.key]
	peer_type, ok := pGrpKey.Field["peer_type"]

	if ok {
		if peer_type == "internal" {
			result["peer-type"] = "INTERNAL"
		} else if peer_type == "external" {
			result["peer-type"] = "EXTERNAL"
		}
	} else {
		log.Info("peer_type field not found in DB")
	}
	return result, nil
}

var DbToYang_bgp_nbr_tx_add_paths_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_nbr_tx_add_paths_fld_xfmr: ", data, "inParams : ", inParams)

	pTbl := data["BGP_NEIGHBOR_AF"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_bgp_nbr_tx_add_paths_fld_xfmr BGP neighbor not found : ", inParams.key)
		return result, errors.New("BGP neighbor not found : " + inParams.key)
	}
	pNbrKey := pTbl[inParams.key]
	tx_add_paths_type, ok := pNbrKey.Field["tx_add_paths"]

	if ok {
		if tx_add_paths_type == "tx_all_paths" {
			result["tx-add-paths"] = "TX_ALL_PATHS"
		} else if tx_add_paths_type == "tx_best_path_per_as" {
			result["tx-add-paths"] = "TX_BEST_PATH_PER_AS"
		}
	} else {
		log.Info("Tx add Paths field not found in DB")
	}
	return result, err
}

var DbToYang_bgp_pgrp_afi_safi_name_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	entry_key := inParams.key
	pgrpAfKey := strings.Split(entry_key, "|")
	pgrpAfName := ""

	switch pgrpAfKey[2] {
	case "ipv4_unicast":
		pgrpAfName = "IPV4_UNICAST"
	case "ipv6_unicast":
		pgrpAfName = "IPV6_UNICAST"
	case "l2vpn_evpn":
		pgrpAfName = "L2VPN_EVPN"
	}

	result["afi-safi-name"] = pgrpAfName

	return result, err
}

var DbToYang_bgp_pgrp_community_type_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_pgrp_community_type_fld_xfmr : ", data, "inParams : ", inParams)

	pTbl := data["BGP_PEER_GROUP_AF"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_bgp_pgrp_community_type_fld_xfmr BGP Peer group not found : ", inParams.key)
		return result, errors.New("BGP peer group not found : " + inParams.key)
	}
	pGrpKey := pTbl[inParams.key]
	community_type, ok := pGrpKey.Field["send_community"]

	if ok {
		if community_type == "standard" {
			result["send-community"] = "STANDARD"
		} else if community_type == "extended" {
			result["send-community"] = "EXTENDED"
		} else if community_type == "both" {
			result["send-community"] = "BOTH"
		} else if community_type == "none" {
			result["send-community"] = "NONE"
		} else if community_type == "large" {
			result["send-community"] = "LARGE"
		} else if community_type == "all" {
			result["send-community"] = "ALL"
		}
	} else {
		log.Info("send_community not found in DB")
	}
	return result, err
}

var DbToYang_bgp_pgrp_name_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_pgrp_name_fld_xfmr : ", data, "inParams : ", inParams)

	entry_key := inParams.key
	peer_group_Key := strings.Split(entry_key, "|")
	peer_group_name := peer_group_Key[1]
	result["peer-group-name"] = peer_group_name

	return result, err
}

var DbToYang_bgp_pgrp_orf_type_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_pgrp_orf_type_fld_xfmr : ", data, "inParams : ", inParams)

	pTbl := data["BGP_PEER_GROUP_AF"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_bgp_pgrp_orf_type_fld_xfmr BGP PEER GROUP AF not found : ", inParams.key)
		return result, errors.New("BGP PEER GROUP AF not found : " + inParams.key)
	}
	pGrpKey := pTbl[inParams.key]
	orf_type, ok := pGrpKey.Field["cap_orf"]

	if ok {
		if orf_type == "send" {
			result["orf-type"] = "SEND"
		} else if orf_type == "receive" {
			result["orf-type"] = "RECEIVE"
		} else if orf_type == "both" {
			result["orf-type"] = "BOTH"
		}
	} else {
		log.Info("cap_orf_direction field not found in DB")
	}
	return result, err
}

var DbToYang_bgp_pgrp_peer_type_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_pgrp_peer_type_fld_xfmr : ", data, "inParams : ", inParams)

	pTbl := data["BGP_PEER_GROUP"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_bgp_pgrp_peer_type_fld_xfmr BGP peer-groups not found : ", inParams.key)
		return result, errors.New("BGP peer-groups not found : " + inParams.key)
	}
	pGrpKey := pTbl[inParams.key]
	peer_type, ok := pGrpKey.Field["peer_type"]

	if ok {
		if peer_type == "internal" {
			result["peer-type"] = "INTERNAL"
		} else if peer_type == "external" {
			result["peer-type"] = "EXTERNAL"
		}
	} else {
		log.Info("peer_type field not found in DB")
	}
	return result, err
}

var DbToYang_bgp_pgrp_tx_add_paths_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_pgrp_tx_add_paths_fld_xfmr: ", data, "inParams : ", inParams)

	pTbl := data["BGP_PEER_GROUP_AF"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_bgp_pgrp_tx_add_paths_fld_xfmr BGP peer group not found : ", inParams.key)
		return result, errors.New("BGP neighbor not found : " + inParams.key)
	}
	pNbrKey := pTbl[inParams.key]
	tx_add_paths_type, ok := pNbrKey.Field["tx_add_paths"]

	if ok {
		if tx_add_paths_type == "tx_all_paths" {
			result["tx-add-paths"] = "TX_ALL_PATHS"
		} else if tx_add_paths_type == "tx_best_path_per_as" {
			result["tx-add-paths"] = "TX_BEST_PATH_PER_AS"
		}
	} else {
		log.Info("Tx add Paths field not found in DB")
	}
	return result, err
}

var DbToYang_bgp_rt_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	entry_key := inParams.key
	routeTargetKey := strings.Split(entry_key, "|")
	routeTarget := routeTargetKey[2]

	result["route-target"] = routeTarget

	return result, err
}

var DbToYang_bgp_rt_type_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	result["route-target-type"] = "import"

	return result, err
}

var DbToYang_bgp_vni_number_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	log.Info("DbToYang_bgp_vni_number_fld_xfmr: ", inParams.key)

	entry_key := inParams.key
	vniKey := strings.Split(entry_key, "|")
	vniNumber, _ := strconv.ParseFloat(vniKey[2], 64)

	result["vni-number"] = vniNumber

	return result, err
}

var DbToYang_community_match_set_options_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	log.Info("DbToYang_community_match_set_options_fld_xfmr", inParams.ygRoot)
	data := (*inParams.dbDataMap)[inParams.curDb]
	opt, ok := data["COMMUNITY_SET"][inParams.key].Field["match_action"]
	if ok {
		match_opt := findInMap(MATCH_SET_ACTION_MAP, opt)
		n, err := strconv.ParseInt(match_opt, 10, 64)
		result["match-set-options"] = ocbinds.E_OpenconfigRoutingPolicy_MatchSetOptionsType(n).ΛMap()["E_OpenconfigRoutingPolicy_MatchSetOptionsType"][n].Name
		log.Info("DbToYang_community_match_set_options_fld_xfmr ", result["match-set-options"])
		return result, err
	}
	return result, err
}

var DbToYang_community_member_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	var result_community string
	data := (*inParams.dbDataMap)[inParams.curDb]

	log.Info("DbToYang_community_member_fld_xfmr", data, inParams.ygRoot, inParams.key)

	set_type := data["COMMUNITY_SET"][inParams.key].Field["set_type"]

	log.Info("DbToYang_community_member_fld_xfmr: type ", set_type)
	var Communities []interface{}

	community_list, ok := data["COMMUNITY_SET"][inParams.key].Field["community_member@"]
	if ok {
		log.Info("DbToYang_community_member_fld_xfmr: DB Memebers ", community_list)
		for _, community := range strings.Split(community_list, ",") {
			if set_type == "EXPANDED" {
				result_community = "REGEX:"
			} else {
				result_community = ""
			}

			if community == "local-AS" {
				result_community += "NO_EXPORT_SUBCONFED"
			} else if community == "no-advertise" {
				result_community += "NO_ADVERTISE"
			} else if community == "no-export" {
				result_community += "NO_EXPORT"
			} else if community == "no-peer" {
				result_community += "NOPEER"
			} else {
				result_community += community
			}
			log.Info("DbToYang_community_member_fld_xfmr: result_community ", result_community)
			Communities = append(Communities, result_community)
		}
	}
	result["community-member"] = Communities
	log.Info("DbToYang_community_member_fld_xfmr: Comminuty Memebers ", result["community-member"])
	return result, err
}

var DbToYang_community_set_name_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error
	log.Info("DbToYang_community_set_name_fld_xfmr: ", inParams.key)

	key := inParams.key
	log.Info("DbToYang_community_set_name_fld_xfmr: ", key)
	setTblKey := strings.Split(key, "|")
	setName := setTblKey[0]

	res_map["community-set-name"] = setName
	log.Info("config/name  ", res_map)
	return res_map, err
}

var DbToYang_ext_community_match_set_options_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	log.Info("DbToYang_ext_community_match_set_options_fld_xfmr", inParams.ygRoot)
	data := (*inParams.dbDataMap)[inParams.curDb]
	opt, ok := data["EXTENDED_COMMUNITY_SET"][inParams.key].Field["match_action"]
	if ok {
		match_opt := findInMap(MATCH_SET_ACTION_MAP, opt)
		n, err := strconv.ParseInt(match_opt, 10, 64)
		result["match-set-options"] = ocbinds.E_OpenconfigRoutingPolicy_MatchSetOptionsType(n).ΛMap()["E_OpenconfigRoutingPolicy_MatchSetOptionsType"][n].Name
		log.Info("DbToYang_ext_community_match_set_options_fld_xfmr ", result["match-set-options"])
		return result, err
	}
	return result, err
}

var DbToYang_ext_community_member_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	var result_community string
	data := (*inParams.dbDataMap)[inParams.curDb]

	log.Info("DbToYang_ext_community_member_fld_xfmr", data, inParams.ygRoot, inParams.key)

	set_type := data["EXTENDED_COMMUNITY_SET"][inParams.key].Field["set_type"]

	log.Info("DbToYang_ext_community_member_fld_xfmr: type ", set_type)
	var Communities []interface{}

	community_list, ok := data["EXTENDED_COMMUNITY_SET"][inParams.key].Field["community_member@"]
	if ok {
		log.Info("DbToYang_ext_community_member_fld_xfmr: DB Memebers ", community_list)
		for _, community := range strings.Split(community_list, ",") {
			if set_type == "EXPANDED" {
				result_community = "REGEX:"
			} else {
				result_community = ""
			}
			result_community += community
			log.Info("DbToYang_ext_community_member_fld_xfmr: result_community ", result_community)
			Communities = append(Communities, result_community)
		}
	}
	result["ext-community-member"] = Communities
	log.Info("DbToYang_ext_community_member_fld_xfmr: Comminuty Memebers ", result["community-member"])
	return result, err
}

var DbToYang_ext_community_set_name_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error
	log.Info("DbToYang_ext_community_set_name_fld_xfmr: ", inParams.key)

	key := inParams.key
	log.Info("DbToYang_ext_community_set_name_fld_xfmr: ", key)
	setTblKey := strings.Split(key, "|")
	setName := setTblKey[0]

	res_map["ext-community-set-name"] = setName
	log.Info("config/name  ", res_map)
	return res_map, err
}

var DbToYang_intf_admin_status_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]

	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_admin_status_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}
	if IntfTypeVxlan == intfType {
		return result, nil
	}
	intTbl := IntfTypeTblMap[intfType]

	tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
	if _, ok := data[tblName]; !ok {
		log.Info("DbToYang_intf_admin_status_xfmr table not found : ", tblName)
		return result, errors.New("table not found : " + tblName)
	}
	pTbl := data[tblName]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_intf_admin_status_xfmr Interface not found : ", inParams.key)
		return result, errors.New("Interface not found : " + inParams.key)
	}
	prtInst := pTbl[inParams.key]
	adminStatus, ok := prtInst.Field[PORT_ADMIN_STATUS]
	var status ocbinds.E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus
	if ok {
		if adminStatus == "up" {
			status = ocbinds.OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_UP
		} else {
			status = ocbinds.OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_DOWN
		}
		result["admin-status"] = ocbinds.E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus.ΛMap(status)["E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus"][int64(status)].Name
	} else {
		log.Info("Admin status field not found in DB")
	}

	return result, err
}

var DbToYang_intf_enabled_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]

	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_enabled_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}
	if IntfTypeVxlan == intfType {
		return result, nil
	}

	intTbl := IntfTypeTblMap[intfType]

	tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
	if _, ok := data[tblName]; !ok {
		log.Info("DbToYang_intf_enabled_xfmr table not found : ", tblName)
		return result, errors.New("table not found : " + tblName)
	}

	pTbl := data[tblName]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_intf_enabled_xfmr Interface not found : ", inParams.key)
		return result, errors.New("Interface not found : " + inParams.key)
	}
	prtInst := pTbl[inParams.key]
	adminStatus, ok := prtInst.Field[PORT_ADMIN_STATUS]
	if ok {
		if adminStatus == "up" {
			result["enabled"] = true
		} else {
			result["enabled"] = false
		}
	} else {
		log.Info("Admin status field not found in DB")
	}
	return result, err
}

var DbToYang_intf_eth_auto_neg_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_eth_auto_neg_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}
	if IntfTypeVxlan == intfType {
		return result, nil
	}
	intTbl := IntfTypeTblMap[intfType]

	tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
	pTbl := data[tblName]
	prtInst := pTbl[inParams.key]
	autoNeg, ok := prtInst.Field[PORT_AUTONEG]
	if ok {
		if autoNeg == "true" {
			result["auto-negotiate"] = true
		} else {
			result["auto-negotiate"] = false
		}
	} else {
		log.Info("auto-negotiate field not found in DB")
	}
	return result, err
}

var DbToYang_intf_eth_port_speed_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_eth_port_speed_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}
	if IntfTypeVxlan == intfType {
		return result, nil
	}

	intTbl := IntfTypeTblMap[intfType]

	tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
	pTbl := data[tblName]
	prtInst := pTbl[inParams.key]
	speed, ok := prtInst.Field[PORT_SPEED]
	portSpeed := ocbinds.OpenconfigIfEthernet_ETHERNET_SPEED_UNSET
	if ok {
		portSpeed, err = getDbToYangSpeed(speed)
		result["port-speed"] = ocbinds.E_OpenconfigIfEthernet_ETHERNET_SPEED.ΛMap(portSpeed)["E_OpenconfigIfEthernet_ETHERNET_SPEED"][int64(portSpeed)].Name
	} else {
		log.Info("Speed field not found in DB")
	}

	return result, err
}

var DbToYang_intf_name_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	log.Info("Entering DbToYang_intf_name_xfmr")
	res_map := make(map[string]interface{})

	pathInfo := NewPathInfo(inParams.uri)
	ifName := pathInfo.Var("name")
	log.Info("Interface Name = ", ifName)
	res_map["name"] = ifName
	return res_map, nil
}

var DbToYang_intf_oper_status_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	var prtInst db.Value

	data := (*inParams.dbDataMap)[inParams.curDb]
	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_oper_status_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}
	if IntfTypeVxlan == intfType {
		return result, nil
	}
	intTbl := IntfTypeTblMap[intfType]
	if intfType == IntfTypeMgmt {
		pathInfo := NewPathInfo(inParams.uri)
		ifName := pathInfo.Var("name")
		entry, dbErr := inParams.dbs[db.StateDB].GetEntry(&db.TableSpec{Name: intTbl.stateDb.portTN}, db.Key{Comp: []string{ifName}})
		if dbErr != nil {
			log.Info("Failed to read mgmt port status from state DB, " + intTbl.stateDb.portTN + " " + ifName)
			return result, dbErr
		}
		prtInst = entry
	} else {
		tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
		pTbl := data[tblName]
		prtInst = pTbl[inParams.key]
	}

	operStatus, ok := prtInst.Field[PORT_OPER_STATUS]
	var status ocbinds.E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus
	if ok {
		if operStatus == "up" {
			status = ocbinds.OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_UP
		} else {
			status = ocbinds.OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_DOWN
		}
		result["oper-status"] = ocbinds.E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus.ΛMap(status)["E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus"][int64(status)].Name
	} else {
		log.Info("Oper status field not found in DB")
	}

	return result, err
}

var DbToYang_intf_type_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var ifName string
	intfsObj := getIntfsRoot(inParams.ygRoot)
	if intfsObj == nil || len(intfsObj.Interface) < 1 {
		return res_map, nil
	} else {
		for infK, _ := range intfsObj.Interface {
			ifName = infK
		}
	}
	intfType, _, _ := getIntfTypeByName(ifName)
	if IntfTypeVxlan == intfType {
		res_map["type"] = "IF_NVE"
		return res_map, nil
	} else {
		return res_map, nil
	}
}

var DbToYang_lag_type_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if ierr != nil || intfType != IntfTypePortChannel {
		return result, err
	}

	data := (*inParams.dbDataMap)[inParams.curDb]
	var agg_type ocbinds.E_OpenconfigIfAggregate_AggregationType
	agg_type = ocbinds.OpenconfigIfAggregate_AggregationType_LACP

	lag_type, ok := data[PORTCHANNEL_TABLE][inParams.key].Field["static"]
	if ok {
		if lag_type == "true" {
			agg_type = ocbinds.OpenconfigIfAggregate_AggregationType_STATIC
		}
	}
	result[LAG_TYPE] = ocbinds.E_OpenconfigIfAggregate_AggregationType.ΛMap(agg_type)["E_OpenconfigIfAggregate_AggregationType"][int64(agg_type)].Name
	log.Infof("Lag Type returned from Field Xfmr: %v\n", result)
	return result, err
}

var DbToYang_mclag_domain_oper_status_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	log.Infof("DbToYang_mclag_domain_oper_status_fld_xfmr --> key: %v", inParams.key)

	stDb := inParams.dbs[db.StateDB]
	mclagEntry, _ := stDb.GetEntry(&db.TableSpec{Name: "MCLAG_TABLE"}, db.Key{Comp: []string{inParams.key}})
	operStatus := mclagEntry.Get("oper_status")
	if operStatus == "up" {
		result["oper-status"], _ = ygot.EnumName(ocbinds.OpenconfigMclag_Mclag_MclagDomains_MclagDomain_State_OperStatus_OPER_UP)
	} else {
		result["oper-status"], _ = ygot.EnumName(ocbinds.OpenconfigMclag_Mclag_MclagDomains_MclagDomain_State_OperStatus_OPER_DOWN)
	}

	return result, err
}

var DbToYang_mclag_domain_role_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	log.Infof("DbToYang_mclag_domain_role_fld_xfmr --> key: %v", inParams.key)

	stDb := inParams.dbs[db.StateDB]
	mclagEntry, _ := stDb.GetEntry(&db.TableSpec{Name: "MCLAG_TABLE"}, db.Key{Comp: []string{inParams.key}})
	role := mclagEntry.Get("role")
	if role == "active" {
		result["role"], _ = ygot.EnumName(ocbinds.OpenconfigMclag_Mclag_MclagDomains_MclagDomain_State_Role_ROLE_ACTIVE)
	} else {
		result["role"], _ = ygot.EnumName(ocbinds.OpenconfigMclag_Mclag_MclagDomains_MclagDomain_State_Role_ROLE_STANDBY)
	}

	return result, err
}

var DbToYang_mclag_domain_system_mac_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	log.Infof("DbToYang_mclag_domain_system_mac_fld_xfmr --> key: %v", inParams.key)

	stDb := inParams.dbs[db.StateDB]
	mclagEntry, _ := stDb.GetEntry(&db.TableSpec{Name: "MCLAG_TABLE"}, db.Key{Comp: []string{inParams.key}})
	sysmac := mclagEntry.Get("system_mac")
	result["system-mac"] = &sysmac

	return result, err
}

var DbToYang_mclag_domainid_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	log.Info("DbToYang_mclag_domainid_fld_xfmr: ", inParams.key)
	result["domain-id"], _ = strconv.ParseUint(inParams.key, 10, 32)

	return result, err
}

var DbToYang_mclag_vlan_name_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	log.Info("DbToYang_mclag_vlan_name_fld_xfmr: ", inParams.key)
	result["name"] = inParams.key

	return result, err
}

var DbToYang_nat_enable_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]

	pTbl := data[NAT_GLOBAL_TN]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_intf_enabled_xfmr Values entry not found : ", inParams.key)
		return result, errors.New("Global Values not found : " + inParams.key)
	}

	prtInst := pTbl[inParams.key]
	adminMode, ok := prtInst.Field["admin_mode"]
	if ok {
		if adminMode == ENABLED {
			result[ENABLE] = true
		} else {
			result[ENABLE] = false
		}
	} else {
		result[ENABLE] = false
		log.Info("Admin Mode field not found in DB")
	}
	return result, err
}

var DbToYang_nat_entry_type_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_nat_entry_type_field_xfmr", data, inParams.ygRoot)
	targetUriPath, err := getYangPathFromUri(inParams.uri)
	var tblName string

	if strings.HasPrefix(targetUriPath, "/openconfig-nat:nat/instances/instance/napt-mapping-table/napt-mapping-entry") {
		tblName = NAPT_TABLE
	} else if strings.HasPrefix(targetUriPath, "/openconfig-nat:nat/instances/instance/napt-twice-mapping-table/napt-twice-entry") {
		tblName = NAPT_TWICE_TABLE
	} else if strings.HasPrefix(targetUriPath, "/openconfig-nat:nat/instances/instance/nat-twice-mapping-table/nat-twice-entry") {
		tblName = NAT_TWICE_TABLE
	} else {
		tblName = NAT_TABLE
	}
	if _, ok := data[tblName]; ok {
		if _, entOk := data[tblName][inParams.key]; entOk {
			entry := data[tblName][inParams.key]
			fldOk := entry.Has(NAT_ENTRY_TYPE)
			if fldOk == true {
				t := findInMap(NAT_ENTRY_TYPE_MAP, data[tblName][inParams.key].Field[NAT_ENTRY_TYPE])
				var n int64
				n, err = strconv.ParseInt(t, 10, 64)
				if err == nil {
					result["entry-type"] = ocbinds.E_OpenconfigNat_NAT_ENTRY_TYPE(n).ΛMap()["E_OpenconfigNat_NAT_ENTRY_TYPE"][n].Name
				}
			}
		}
	}

	return result, err
}

var DbToYang_nat_ip_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	tblName := "NAT_POOL"
	if _, ok := data[tblName]; ok {
		if _, entOk := data[tblName][inParams.key]; entOk {
			entry := data[tblName][inParams.key]
			fldOk := entry.Has("nat_ip")
			if fldOk == true {
				ipStr := entry.Get("nat_ip")
				ipRange := strings.Contains(ipStr, "-")
				if ipRange == true {
					result["IP-ADDRESS-RANGE"] = ipStr
				} else {
					result["IP-ADDRESS"] = ipStr
				}
			}
		}
	}
	return result, err
}

var DbToYang_nat_type_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_nat_type_field_xfmr", data, inParams.ygRoot)

	targetUriPath, err := getYangPathFromUri(inParams.uri)
	var tblName string

	if strings.HasPrefix(targetUriPath, "/openconfig-nat:nat/instances/instance/napt-mapping-table/napt-mapping-entry/config") {
		tblName = STATIC_NAPT
	} else if strings.HasPrefix(targetUriPath, "/openconfig-nat:nat/instances/instance/napt-mapping-table/napt-mapping-entry/state") {
		tblName = NAPT_TABLE
	} else if strings.HasPrefix(targetUriPath, "/openconfig-nat:nat/instances/instance/nat-mapping-table/nat-mapping-entry/config") {
		tblName = STATIC_NAT
	} else if strings.HasPrefix(targetUriPath, "/openconfig-nat:nat/instances/instance/nat-mapping-table/nat-mapping-entry/state") {
		tblName = NAT_TABLE
	} else if strings.HasPrefix(targetUriPath, "/openconfig-nat:nat/instances/instance/nat-acl-pool-binding/nat-acl-pool-binding-entry") {
		tblName = NAT_BINDINGS
	} else {
		log.Info("DbToYang_nat_type_field_xfmr: Invalid URI: %s\n", targetUriPath)
		return result, errors.New("Invalid URI " + targetUriPath)
	}

	if _, ok := data[tblName]; ok {
		if _, entOk := data[tblName][inParams.key]; entOk {
			entry := data[tblName][inParams.key]
			fldOk := entry.Has(NAT_TYPE)
			if fldOk == true {
				t := findInMap(NAT_TYPE_MAP, data[tblName][inParams.key].Field[NAT_TYPE])
				var n int64
				n, err = strconv.ParseInt(t, 10, 64)
				if err == nil {
					result["type"] = ocbinds.E_OpenconfigNat_NAT_TYPE(n).ΛMap()["E_OpenconfigNat_NAT_TYPE"][n].Name
				}
			}
		}
	}

	return result, err
}

var DbToYang_network_instance_enabled_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_network_instance_enabled_field_xfmr: ")

	if mgmtVrfEnabledInDb(inParams) == "true" {
		res_map["enabled"] = true
	} else if mgmtVrfEnabledInDb(inParams) == "false" {
		res_map["enabled"] = false
	}
	return res_map, err
}

var DbToYang_nw_inst_vxlan_source_nve_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})

	entry_key := inParams.key
	if log.V(3) {
		log.Info("DbToYang_nw_inst_vxlan_source_nve_xfmr ==> entry_key  ===> ", entry_key)
	}

	if entry_key != "" {
		keyList := strings.Split(entry_key, "|")
		if log.V(3) {
			log.Info("DbToYang_nw_inst_vxlan_source_nve_xfmr ==> keyList  ===> ", keyList)
		}
		rmap["source-nve"] = keyList[0]
	}

	if log.V(3) {
		log.Info("DbToYang_nw_inst_vxlan_source_nve_xfmr ==> rmap  ===> ", rmap)
	}

	return rmap, nil
}

var DbToYang_nw_inst_vxlan_vni_id_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})

	entry_key := inParams.key
	if log.V(3) {
		log.Info("DbToYang_nw_inst_vxlan_vni_id_xfmr ==> entry_key  ===> ", entry_key)
	}

	if entry_key != "" {
		keyList := strings.Split(entry_key, "|")

		if log.V(3) {
			log.Info("DbToYang_nw_inst_vxlan_vni_id_xfmr ==> keyList  ===> ", keyList)
		}

		mapNameList := strings.Split(keyList[1], "_")

		vniId, _ := strconv.ParseInt(mapNameList[1], 10, 64)
		rmap["vni-id"] = uint32(vniId)
	}

	if log.V(3) {
		log.Info("DbToYang_nw_inst_vxlan_vni_id_xfmr ==> rmap  ===> ", rmap)
	}

	return rmap, nil
}

var DbToYang_prefix_action_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_prefix_action_fld_xfmr", data, "inParams : ", inParams)

	pTbl := data["PREFIX"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_route_map_action_policy_result_xfmr table not found : ", inParams.key)
		return result, errors.New("Policy definition table not found : " + inParams.key)
	}
	niInst := pTbl[inParams.key]
	route_operation, ok := niInst.Field["action"]
	if ok {
		if route_operation == "permit" {
			result["action"] = "PERMIT"
		} else {
			result["action"] = "DENY"
		}
	} else {
		log.Info("DbToYang_prefix_action_fld_xfmr field not found in DB")
	}
	return result, err
}

var DbToYang_prefix_ip_prefix_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error
	log.Info("DbToYang_prefix_ip_prefix_fld_xfmr: ", inParams.key)

	key := inParams.key
	prefixKey := strings.Split(key, "|")
	ip_prefix := prefixKey[1]

	res_map["ip-prefix"] = ip_prefix
	log.Info("prefix-set/prefix/config/ip-prefix ", res_map)
	return res_map, err
}

var DbToYang_prefix_masklength_range_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error
	log.Info("DbToYang_prefix_masklength_range_fld_xfmr: ", inParams.key)

	key := inParams.key
	prefixKey := strings.Split(key, "|")
	mask := prefixKey[2]

	res_map["masklength-range"] = mask
	log.Info("prefix-set/prefix/config/masklength-range ", res_map)
	return res_map, err
}

var DbToYang_prefix_set_mode_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_prefix_set_mode_fld_xfmr: Input", data, inParams.ygRoot)
	mode, ok := data["PREFIX_SET"][inParams.key].Field["mode"]
	if ok {
		oc_mode := findInMap(PREFIX_SET_MODE_MAP, mode)
		n, err := strconv.ParseInt(oc_mode, 10, 64)
		result["mode"] = ocbinds.E_OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_PrefixSets_PrefixSet_Config_Mode(n).ΛMap()["E_OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_PrefixSets_PrefixSet_Config_Mode"][n].Name
		log.Info("DbToYang_prefix_set_mode_fld_xfmr ", result)
		return result, err
	}
	return result, err
}

var DbToYang_prefix_set_name_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error
	log.Info("DbToYang_prefix_set_name_fld_xfmr: ", inParams.key)

	key := inParams.key
	log.Info("DbToYang_prefix_set_name_fld_xfmr: ", key)
	setTblKey := strings.Split(key, "|")
	setName := setTblKey[0]

	res_map["name"] = setName
	log.Info("prefix-set/config/name  ", res_map)
	return res_map, err
}

var DbToYang_ptp_boolean_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	var inval string
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_boolean_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)

	_, field := filepath.Split(inParams.uri)
	if field == "two-step-flag" {
		inval = data["PTP_CLOCK"][inParams.key].Field[field]
	} else if field == "slave-only" {
		inval = data["PTP_CLOCK"][inParams.key].Field[field]
	} else if field == "parent-stats" {
		inval = data["PTP_PARENTDS"][inParams.key].Field[field]
	} else if field == "current-utc-offset-valid" {
		inval = data["PTP_TIMEPROPDS"][inParams.key].Field[field]
	} else if field == "leap59" {
		inval = data["PTP_TIMEPROPDS"][inParams.key].Field[field]
	} else if field == "leap61" {
		inval = data["PTP_TIMEPROPDS"][inParams.key].Field[field]
	} else if field == "time-traceable" {
		inval = data["PTP_TIMEPROPDS"][inParams.key].Field[field]
	} else if field == "frequency-traceable" {
		inval = data["PTP_TIMEPROPDS"][inParams.key].Field[field]
	} else if field == "ptp-timescale" {
		inval = data["PTP_TIMEPROPDS"][inParams.key].Field[field]
	} else if field == "faulty-flag" {
		inval = data["PTP_TC_PORT"][inParams.key].Field[field]
	}

	if inval == "0" {
		result[field] = false
	} else if inval == "1" {
		result[field] = true
	}

	return result, err
}

var DbToYang_ptp_clock_identity_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	var ptp_id ptp_id_bin
	var field, identity, sEnc string
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_clock_identity_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)

	if strings.Contains(inParams.uri, "grandmaster-identity") {
		field = "grandmaster-identity"
		identity = data["PTP_PARENTDS"][inParams.key].Field[field]
	} else if strings.Contains(inParams.uri, "parent-port-identity") {
		field = "clock-identity"
		identity = data["PTP_PARENTDS"][inParams.key].Field[field]
	} else if strings.Contains(inParams.uri, "transparent-clock-default-ds") {
		field = "clock-identity"
		identity = data["PTP_TC_CLOCK"][inParams.key].Field[field]
	} else if strings.Contains(inParams.uri, "default-ds") {
		field = "clock-identity"
		identity = data["PTP_CLOCK"][inParams.key].Field[field]
	}
	if len(identity) >= 18 {
		ptp_id, err = ParseIdentity(identity)
		sEnc = b64.StdEncoding.EncodeToString(ptp_id[:])
		result[field] = sEnc
	} else {
		sEnc = ""
	}

	return result, err
}

var DbToYang_ptp_clock_type_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_clock_type_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)
	log.Info("DbToYang_ptp_clock_type_xfmr inParams.key: ", inParams.key)

	_, field := filepath.Split(inParams.uri)
	log.Info("DbToYang_ptp_clock_type_xfmr field: ", field)
	value := data["PTP_CLOCK"][inParams.key].Field[field]
	result[field] = value
	log.Info("DbToYang_ptp_clock_type_xfmr value: ", value)
	return result, err
}

var DbToYang_ptp_delay_mech_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})
	var inval string
	var outval string
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_delay_mech_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)

	_, field := filepath.Split(inParams.uri)

	if strings.Contains(inParams.uri, "port-ds-list") {
		inval = data["PTP_PORT"][inParams.key].Field[field]
	} else if strings.Contains(inParams.uri, "transparent-clock-default-ds") {
		inval = data["PTP_TC_CLOCK"][inParams.key].Field[field]
	}

	switch inval {
	case "1":
		outval = "e2e"
	case "2":
		outval = "p2p"
	default:
		outval = ""
	}
	log.Info("DbToYang_ptp_delay_mech_xfmr result: ", outval, " inval: ", inval)
	if outval != "" {
		result[field] = outval
	}

	return result, err
}

var DbToYang_ptp_domain_number_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_domain_number_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)
	log.Info("DbToYang_ptp_domain_number_xfmr inParams.key: ", inParams.key)

	_, field := filepath.Split(inParams.uri)
	log.Info("DbToYang_ptp_domain_number_xfmr field: ", field)
	value := data["PTP_CLOCK"][inParams.key].Field[field]
	result[field], _ = strconv.ParseUint(value, 10, 64)
	log.Info("DbToYang_ptp_domain_number_xfmr value: ", value)
	return result, err
}

var DbToYang_ptp_domain_profile_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_domain_profile_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)
	log.Info("DbToYang_ptp_domain_profile_xfmr inParams.key: ", inParams.key)

	_, field := filepath.Split(inParams.uri)
	log.Info("DbToYang_ptp_domain_profile_xfmr field: ", field)
	value := data["PTP_CLOCK"][inParams.key].Field[field]
	result[field] = value
	log.Info("DbToYang_ptp_domain_profile_xfmr value: ", value)
	return result, err
}

var DbToYang_ptp_inst_number_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	/* do nothing */
	var err error
	result := make(map[string]interface{})
	return result, err
}

var DbToYang_ptp_network_transport_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_network_transport_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)
	log.Info("DbToYang_ptp_network_transport_xfmr inParams.key: ", inParams.key)

	_, field := filepath.Split(inParams.uri)
	log.Info("DbToYang_ptp_network_transport_xfmr field: ", field)
	value := data["PTP_CLOCK"][inParams.key].Field[field]
	result[field] = value
	log.Info("DbToYang_ptp_network_transport_xfmr value: ", value)
	return result, err
}

var DbToYang_ptp_port_state_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	var inval string
	var outval string
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_port_state_xfmr :", data, inParams.ygRoot)

	inval = data["PTP_PORT"][inParams.key].Field["port-state"]
	switch inval {
	case "1":
		outval = "initializing"
	case "2":
		outval = "faulty"
	case "3":
		outval = "disabled"
	case "4":
		outval = "listening"
	case "5":
		outval = "pre-master"
	case "6":
		outval = "master"
	case "7":
		outval = "passive"
	case "8":
		outval = "uncalibrated"
	case "9":
		outval = "slave"
	default:
		goto done
	}
	result["port-state"] = outval
done:
	return result, err
}

var DbToYang_ptp_udp6_scope_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error

	result := make(map[string]interface{})
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_udp6_scope_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)
	log.Info("DbToYang_ptp_udp6_scope_xfmr inParams.key: ", inParams.key)

	_, field := filepath.Split(inParams.uri)
	log.Info("DbToYang_ptp_udp6_scope_xfmr field: ", field)
	log.Info("DbToYang_ptp_udp6_scope_xfmr data: ", data["PTP_CLOCK"][inParams.key].Field[field])
	value, _ := strconv.ParseInt(strings.Replace(data["PTP_CLOCK"][inParams.key].Field[field], "0x", "", -1), 16, 64)
	result[field] = uint8(value)
	log.Info("DbToYang_ptp_udp6_scope_xfmr value: ", value)
	return result, err
}

var DbToYang_ptp_unicast_multicast_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_unicast_multicast_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)
	log.Info("DbToYang_ptp_unicast_multicast_xfmr inParams.key: ", inParams.key)

	_, field := filepath.Split(inParams.uri)
	log.Info("DbToYang_ptp_unicast_multicast_xfmr field: ", field)
	value := data["PTP_CLOCK"][inParams.key].Field[field]
	result[field] = value
	log.Info("DbToYang_ptp_unicast_multicast_xfmr value: ", value)
	return result, err
}

var DbToYang_ptp_unicast_table_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error

	result := make(map[string]interface{})
	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_ptp_unicast_table_xfmr ygRoot: ", *inParams.ygRoot, " Xpath: ", inParams.uri, " data: ", data)
	log.Info("DbToYang_ptp_unicast_table_xfmr inParams.key: ", inParams.key)

	_, field := filepath.Split(inParams.uri)
	log.Info("DbToYang_ptp_unicast_table_xfmr field: ", field)
	value := data["PTP_PORT"][inParams.key].Field[field]
	result[field] = value
	log.Info("DbToYang_ptp_unicast_table_xfmr value: ", value)
	return result, err
}

var DbToYang_route_map_action_policy_result_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_bgp_external_compare_router_id_xfmr", data, "inParams : ", inParams)

	pTbl := data["ROUTE_MAP"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_route_map_action_policy_result_xfmr table not found : ", inParams.key)
		return result, errors.New("Policy definition table not found : " + inParams.key)
	}
	niInst := pTbl[inParams.key]
	route_operation, ok := niInst.Field["route_operation"]
	if ok {
		if route_operation == "permit" {
			result["policy-result"] = "ACCEPT_ROUTE"
		} else {
			result["policy-result"] = "REJECT_ROUTE"
		}
	} else {
		log.Info("DbToYang_route_map_action_policy_result_xfmr field not found in DB")
	}
	return result, err
}

var DbToYang_route_map_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	entry_key := inParams.key
	log.Info("DbToYang_route_map_field_xfmr: ", entry_key)

	dynKey := strings.Split(entry_key, "|")

	rmap["name"] = dynKey[0]

	return rmap, err
}

var DbToYang_route_map_key_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	entry_key := inParams.key
	log.Info("DbToYang_route_map_key_xfmr: ", entry_key)

	dynKey := strings.Split(entry_key, "|")

	rmap["name"] = dynKey[1]

	return rmap, err
}

var DbToYang_route_map_match_protocol_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	log.Info("DbToYang_route_map_match_protocol_xfmr", data, "inParams : ", inParams)

	pTbl := data["ROUTE_MAP"]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_route_map_match_protocol_xfmr table not found : ", inParams.key)
		return result, errors.New("Policy definition table not found : " + inParams.key)
	}
	niInst := pTbl[inParams.key]
	protocol, ok := niInst.Field["match_protocol"]
	if ok {
		switch protocol {
		case "bgp":
			result["install-protocol-eq"] = "BGP"
		case "connected":
			result["install-protocol-eq"] = "DIRECTLY_CONNECTED"
		case "isis":
			result["install-protocol-eq"] = "ISIS"
		case "ospf":
			result["install-protocol-eq"] = "OSPF"
		case "ospf3":
			result["install-protocol-eq"] = "OSPF3"
		case "static":
			result["install-protocol-eq"] = "STATIC"
		default:
		}
	} else {
		log.Info("DbToYang_route_map_match_protocol_xfmr field not found in DB")
	}
	return result, err
}

var DbToYang_route_map_match_set_options_restrict_type_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	result["match-set-options"] = "ANY"
	return result, err
}

var DbToYang_route_map_match_set_options_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	result["match-set-options"] = "ANY"
	return result, err
}

var DbToYang_route_map_stmt_field_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	entry_key := inParams.key
	log.Info("DbToYang_route_map_stmt_field_xfmr: ", entry_key)

	dynKey := strings.Split(entry_key, "|")

	rmap["name"] = dynKey[1]

	return rmap, err
}

var DbToYang_route_table_addr_family_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	var err error
	result := make(map[string]interface{})

	entry_key := inParams.key
	key := strings.Split(entry_key, "|")
	family := key[3]
	af := ""

	if family == "ipv4" {
		af = "IPV4"
	} else if family == "ipv6" {
		af = "IPV6"
	} else {
		return result, errors.New("Unsupported family " + family)
	}

	result["address-family"] = af

	return result, err
}

var DbToYang_sag_ipv4_enable_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]

	tblName := "IP"
	if _, ok := data[tblName]; !ok {
		log.Info("DbToYang_sag_ipv4_enable_xfmr table not found : ", tblName)
		return result, errors.New("table not found : " + tblName)
	}

	pTbl := data[tblName]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_sag_ipv4_enable_xfmr SAG not found : ", inParams.key)
		return result, errors.New("SAG not found : " + inParams.key)
	}
	prtInst := pTbl[inParams.key]
	adminStatus, ok := prtInst.Field["IPv4"]
	if ok {
		if adminStatus == "enable" {
			result["ipv4-enable"] = true
		} else {
			result["ipv4-enable"] = false
		}
	} else {
		log.Info("Admin status field not found in DB")
	}
	return result, err
}

var DbToYang_sag_ipv6_enable_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]

	tblName := "SAG_GLOBAL|IP"
	if _, ok := data[tblName]; !ok {
		log.Info("DbToYang_sag_ipv6_enable_xfmr table not found : ", tblName)
		return result, errors.New("table not found : " + tblName)
	}

	pTbl := data[tblName]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_sag_ipv6_enable_xfmr SAG not found : ", inParams.key)
		return result, errors.New("SAG not found : " + inParams.key)
	}
	prtInst := pTbl[inParams.key]
	adminStatus, ok := prtInst.Field["IPv6"]
	if ok {
		if adminStatus == "enable" {
			result["ipv6-enable"] = true
		} else {
			result["ipv6-enable"] = false
		}
	} else {
		log.Info("Admin status field not found in DB")
	}
	return result, err
}

var DbToYang_vlan_nd_suppress_fld_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})

	pathInfo := NewPathInfo(inParams.uri)
	vlanIdStr := pathInfo.Var("name")
	data := (*inParams.dbDataMap)[inParams.curDb]

	log.Infof("vlan_nd_suppress_fld_xfmr: key: %v, data: %v", vlanIdStr, data)
	if data != nil && len(data) > 0 {
		val := data["SUPPRESS_VLAN_NEIGH"][vlanIdStr]
		if val.Get("suppress") == "on" {
			res_map["arp-and-nd-suppress"], _ = ygot.EnumName(ocbinds.OpenconfigNetworkInstance_NetworkInstances_NetworkInstance_NeighbourSuppress_Config_ArpAndNdSuppress_enable)
		}
	}

	return res_map, nil
}

var DbToYang_vxlan_state_peer_tunnel_type_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})

	rmap["tunnel-type"] = "dynamic"
	if log.V(3) {
		log.Info("DbToYang_vxlan_state_peer_tunnel_type_xfmr ==> returning  tunnel-type field ==> ", rmap)
	}
	return rmap, nil
}

var DbToYang_vxlan_state_tunnel_info_tunnel_type_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	rmap["type"] = "dynamic"
	if log.V(3) {
		log.Info("DbToYang_vxlan_state_tunnel_info_tunnel_type_xfmr ==> returning  type field ==> ", rmap)
	}
	return rmap, nil
}

var YangToDb_acl_destination_port_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		res_map["L4_DST_PORT_RANGE"] = ""
		return res_map, err
	}
	destportType := reflect.TypeOf(inParams.param).Elem()
	log.Info("YangToDb_acl_ip_protocol_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " destportType: ", destportType)
	switch destportType {
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort_Union_E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort_Union_E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort)
		res_map["L4_DST_PORT"] = v.E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort.ΛMap()["E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort"][int64(v.E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort)].Name
		break
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort_Union_String{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort_Union_String)
		res_map["L4_DST_PORT_RANGE"] = strings.Replace(v.String, "..", "-", 1)
		break
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort_Union_Uint16{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_DestinationPort_Union_Uint16)
		res_map["L4_DST_PORT"] = strconv.FormatInt(int64(v.Uint16), 10)
		break
	}
	return res_map, err
}

var YangToDb_acl_forwarding_action_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		res_map["PACKET_ACTION"] = ""
		return res_map, err
	}
	action, _ := inParams.param.(ocbinds.E_OpenconfigAcl_FORWARDING_ACTION)
	log.Info("YangToDb_acl_forwarding_action_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " forwarding_action: ", action)
	res_map["PACKET_ACTION"] = findInMap(ACL_FORWARDING_ACTION_MAP, strconv.FormatInt(int64(action), 10))
	return res_map, err
}

var YangToDb_acl_ip_protocol_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	if inParams.param == nil {
		res_map["IP_PROTOCOL"] = ""
		return res_map, err
	}
	protocolType := reflect.TypeOf(inParams.param).Elem()
	log.Info("YangToDb_acl_ip_protocol_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " protocolType: ", protocolType)
	switch protocolType {
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Ipv4_Config_Protocol_Union_E_OpenconfigPacketMatchTypes_IP_PROTOCOL{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Ipv4_Config_Protocol_Union_E_OpenconfigPacketMatchTypes_IP_PROTOCOL)
		res_map["IP_PROTOCOL"] = findInMap(IP_PROTOCOL_MAP, strconv.FormatInt(int64(v.E_OpenconfigPacketMatchTypes_IP_PROTOCOL), 10))
		v = nil
		break
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Ipv4_Config_Protocol_Union_Uint8{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Ipv4_Config_Protocol_Union_Uint8)
		res_map["IP_PROTOCOL"] = strconv.FormatInt(int64(v.Uint8), 10)
		break
	}
	return res_map, err
}

var YangToDb_acl_l2_ethertype_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	if inParams.param == nil {
		res_map["ETHER_TYPE"] = ""
		return res_map, err
	}
	ethertypeType := reflect.TypeOf(inParams.param).Elem()
	log.Info("YangToDb_acl_ip_protocol_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " ethertypeType: ", ethertypeType)
	var b bytes.Buffer
	switch ethertypeType {
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_L2_Config_Ethertype_Union_E_OpenconfigPacketMatchTypes_ETHERTYPE{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_L2_Config_Ethertype_Union_E_OpenconfigPacketMatchTypes_ETHERTYPE)
		fmt.Fprintf(&b, "0x%0.4x", ETHERTYPE_MAP[v.E_OpenconfigPacketMatchTypes_ETHERTYPE])
		res_map["ETHER_TYPE"] = b.String()
		break
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_L2_Config_Ethertype_Union_Uint16{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_L2_Config_Ethertype_Union_Uint16)
		fmt.Fprintf(&b, "0x%0.4x", v.Uint16)
		res_map["ETHER_TYPE"] = b.String()
		break
	}
	return res_map, err
}

var YangToDb_acl_source_port_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		res_map["L4_SRC_PORT"] = ""
		return res_map, err
	}
	sourceportType := reflect.TypeOf(inParams.param).Elem()
	log.Info("YangToDb_acl_ip_protocol_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " sourceportType: ", sourceportType)
	switch sourceportType {
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort_Union_E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort_Union_E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort)
		res_map["L4_SRC_PORT"] = v.E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort.ΛMap()["E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort"][int64(v.E_OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort)].Name
		break
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort_Union_String{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort_Union_String)
		res_map["L4_SRC_PORT_RANGE"] = strings.Replace(v.String, "..", "-", 1)
		break
	case reflect.TypeOf(ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort_Union_Uint16{}):
		v := (inParams.param).(*ocbinds.OpenconfigAcl_Acl_AclSets_AclSet_AclEntries_AclEntry_Transport_Config_SourcePort_Union_Uint16)
		res_map["L4_SRC_PORT"] = strconv.FormatInt(int64(v.Uint16), 10)
		break
	}
	return res_map, err
}

var YangToDb_acl_tcp_flags_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	log.Info("YangToDb_acl_tcp_flags_xfmr: ")
	var tcpFlags uint32 = 0x00
	var b bytes.Buffer
	if inParams.param == nil {
		res_map["TCP_FLAGS"] = b.String()
		return res_map, err
	}
	log.Info("YangToDb_acl_tcp_flags_xfmr: ", inParams.ygRoot, inParams.uri)
	v := reflect.ValueOf(inParams.param)

	flags := v.Interface().([]ocbinds.E_OpenconfigPacketMatchTypes_TCP_FLAGS)
	for _, flag := range flags {
		fmt.Println("TCP Flag name: " + flag.ΛMap()["E_OpenconfigPacketMatchTypes_TCP_FLAGS"][int64(flag)].Name)
		switch flag {
		case ocbinds.OpenconfigPacketMatchTypes_TCP_FLAGS_TCP_FIN:
			tcpFlags |= 0x01
			break
		case ocbinds.OpenconfigPacketMatchTypes_TCP_FLAGS_TCP_SYN:
			tcpFlags |= 0x02
			break
		case ocbinds.OpenconfigPacketMatchTypes_TCP_FLAGS_TCP_RST:
			tcpFlags |= 0x04
			break
		case ocbinds.OpenconfigPacketMatchTypes_TCP_FLAGS_TCP_PSH:
			tcpFlags |= 0x08
			break
		case ocbinds.OpenconfigPacketMatchTypes_TCP_FLAGS_TCP_ACK:
			tcpFlags |= 0x10
			break
		case ocbinds.OpenconfigPacketMatchTypes_TCP_FLAGS_TCP_URG:
			tcpFlags |= 0x20
			break
		case ocbinds.OpenconfigPacketMatchTypes_TCP_FLAGS_TCP_ECE:
			tcpFlags |= 0x40
			break
		case ocbinds.OpenconfigPacketMatchTypes_TCP_FLAGS_TCP_CWR:
			tcpFlags |= 0x80
			break
		}
	}
	fmt.Fprintf(&b, "0x%0.2x/0x%0.2x", tcpFlags, tcpFlags)
	res_map["TCP_FLAGS"] = b.String()
	return res_map, err
}

var YangToDb_acl_type_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		res_map[ACL_TYPE] = ""
		return res_map, err
	}

	acltype, _ := inParams.param.(ocbinds.E_OpenconfigAcl_ACL_TYPE)
	log.Info("YangToDb_acl_type_field_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " acltype: ", acltype)
	res_map[ACL_TYPE] = findInMap(ACL_TYPE_MAP, strconv.FormatInt(int64(acltype), 10))
	return res_map, err
}

var YangToDb_as_path_set_name_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	log.Info("YangToDb_as_path_set_name_fld_xfmr: ", inParams.key)
	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_auth_method_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	if log.V(3) {
		log.Info("YangToDb_auth_method_xfmr: root: ", inParams.ygRoot,
			", uri: ", inParams.uri, "param: ", inParams.param)
	}

	var db_auth_method string

	auth_method, _ := inParams.param.([]ocbinds.OpenconfigSystem_System_Aaa_Authentication_Config_AuthenticationMethod_Union)
	for _, method := range auth_method {
		v := (method).(*ocbinds.OpenconfigSystem_System_Aaa_Authentication_Config_AuthenticationMethod_Union_String)
		log.Info("YangToDb_auth_method_xfmr: method - ", v.String)

		if len(db_auth_method) == 0 {
			db_auth_method = v.String
		} else {
			db_auth_method = db_auth_method + "," + v.String
		}
	}

	log.Info("YangToDb_auth_method_xfmr: auth-method: ", db_auth_method)
	res_map := make(map[string]string)
	res_map["login"] = db_auth_method
	return res_map, nil
}

var YangToDb_bgp_advertise_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	var err error
	afi_safi_list, _ := inParams.param.([]ocbinds.E_OpenconfigBgpTypes_AFI_SAFI_TYPE)
	log.Info("YangToDb_bgp_advertise_fld_xfmr: afi_safi_list:", afi_safi_list)

	for _, afi_safi := range afi_safi_list {

		if afi_safi == ocbinds.OpenconfigBgpTypes_AFI_SAFI_TYPE_IPV4_UNICAST {
			res_map["advertise-ipv4-unicast"] = "true"
		} else if afi_safi == ocbinds.OpenconfigBgpTypes_AFI_SAFI_TYPE_IPV6_UNICAST {
			res_map["advertise-ipv6-unicast"] = "true"
		} else {
			err = errors.New("Unsupported afi_safi")
			return res_map, err
		}
	}
	return res_map, nil
}

var YangToDb_bgp_dyn_neigh_listen_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	rmap := make(map[string]string)
	var err error

	log.Info("YangToDb_bgp_dyn_neigh_listen_field_xfmr")
	rmap["NULL"] = "NULL"

	return rmap, err
}

var YangToDb_bgp_gbl_afi_safi_addr_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	rmap := make(map[string]string)
	var err error

	log.Info("YangToDb_bgp_gbl_afi_safi_addr_field_xfmr")
	rmap["NULL"] = "NULL"

	return rmap, err
}

var YangToDb_bgp_gbl_afi_safi_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	rmap := make(map[string]string)
	var err error

	log.Info("YangToDb_bgp_gbl_afi_safi_field_xfmr")
	rmap["NULL"] = "NULL"

	return rmap, err
}

var YangToDb_bgp_local_asn_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	rmap := make(map[string]string)
	var err error
	if inParams.param == nil {
		rmap["local_asn"] = ""
		return rmap, err
	}

	if inParams.oper == DELETE {
		rmap["local_asn"] = ""
		return rmap, nil
	}

	log.Info("YangToDb_bgp_local_asn_fld_xfmr")
	pathInfo := NewPathInfo(inParams.uri)

	niName := pathInfo.Var("name")

	asn, _ := inParams.param.(*uint32)

	curr_asn, err_val := bgp_global_get_local_asn(inParams.d, niName, "BGP_GLOBALS")
	if err_val == nil {
		local_asn64, err_conv := strconv.ParseUint(curr_asn, 10, 32)
		local_asn := uint32(local_asn64)
		if err_conv == nil && local_asn != *asn {
			log.Info("YangToDb_bgp_local_asn_fld_xfmr Local ASN is already present", local_asn, *asn)
			return rmap, tlerr.InvalidArgs("BGP is already running with AS number %s",
				strconv.FormatUint(local_asn64, 10))
		}
	}
	rmap["local_asn"] = strconv.FormatUint(uint64(*asn), 10)
	return rmap, err
}

var YangToDb_bgp_nbr_address_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_bgp_nbr_afi_safi_name_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_bgp_nbr_community_type_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	var err error
	if inParams.param == nil {
		err = errors.New("No Params")
		return res_map, err
	}

	if inParams.oper == DELETE {
		subOpMap := make(map[db.DBNum]map[string]map[string]db.Value)

		if _, ok := subOpMap[db.ConfigDB]; !ok {
			subOpMap[db.ConfigDB] = make(map[string]map[string]db.Value)
		}
		if _, ok := subOpMap[db.ConfigDB]["BGP_NEIGHBOR_AF"]; !ok {
			subOpMap[db.ConfigDB]["BGP_NEIGHBOR_AF"] = make(map[string]db.Value)
		}
		subOpMap[db.ConfigDB]["BGP_NEIGHBOR_AF"][inParams.key] = db.Value{Field: make(map[string]string)}
		subOpMap[db.ConfigDB]["BGP_NEIGHBOR_AF"][inParams.key].Field["send_community"] = "both"

		inParams.subOpDataMap[UPDATE] = &subOpMap
		return res_map, nil
	}

	community_type, _ := inParams.param.(ocbinds.E_OpenconfigBgpExt_BgpExtCommunityType)
	log.Info("YangToDb_bgp_nbr_community_type_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " community_type: ", community_type)

	if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_STANDARD {
		res_map["send_community"] = "standard"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_EXTENDED {
		res_map["send_community"] = "extended"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_BOTH {
		res_map["send_community"] = "both"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_NONE {
		res_map["send_community"] = "none"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_LARGE {
		res_map["send_community"] = "large"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_ALL {
		res_map["send_community"] = "all"
	} else {
		err = errors.New("send_community  Missing")
		return res_map, err
	}

	return res_map, nil

}

var YangToDb_bgp_nbr_orf_type_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	var err error
	if inParams.param == nil {
		err = errors.New("No Params")
		return res_map, err
	}

	if inParams.oper == DELETE {
		res_map["cap_orf"] = ""
		return res_map, nil
	}

	orf_type, _ := inParams.param.(ocbinds.E_OpenconfigBgpExt_BgpOrfType)
	log.Info("YangToDb_bgp_nbr_orf_type_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " orf_type: ", orf_type)

	if orf_type == ocbinds.OpenconfigBgpExt_BgpOrfType_SEND {
		res_map["cap_orf"] = "send"
	} else if orf_type == ocbinds.OpenconfigBgpExt_BgpOrfType_RECEIVE {
		res_map["cap_orf"] = "receive"
	} else if orf_type == ocbinds.OpenconfigBgpExt_BgpOrfType_BOTH {
		res_map["cap_orf"] = "both"
	} else {
		err = errors.New("ORF type Missing")
		return res_map, err
	}

	return res_map, nil

}

var YangToDb_bgp_nbr_peer_type_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	var err error
	if inParams.param == nil {
		err = errors.New("No Params")
		return res_map, err
	}

	if inParams.oper == DELETE {
		res_map["peer_type"] = ""
		return res_map, nil
	}

	peer_type, _ := inParams.param.(ocbinds.E_OpenconfigBgp_PeerType)
	log.Info("YangToDb_bgp_nbr_peer_type_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " peer-type: ", peer_type)

	if peer_type == ocbinds.OpenconfigBgp_PeerType_INTERNAL {
		res_map["peer_type"] = "internal"
	} else if peer_type == ocbinds.OpenconfigBgp_PeerType_EXTERNAL {
		res_map["peer_type"] = "external"
	} else {
		err = errors.New("Peer Type Missing")
		return res_map, err
	}

	return res_map, nil

}

var YangToDb_bgp_nbr_tx_add_paths_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	var err error
	if inParams.param == nil {
		err = errors.New("No Params")
		return res_map, err
	}

	if inParams.oper == DELETE {
		res_map["tx_add_paths"] = ""
		return res_map, nil
	}

	tx_add_paths_type, _ := inParams.param.(ocbinds.E_OpenconfigBgpExt_TxAddPathsType)
	log.Info("YangToDb_bgp_nbr_tx_add_paths_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " add-paths-type: ", tx_add_paths_type)

	if tx_add_paths_type == ocbinds.OpenconfigBgpExt_TxAddPathsType_TX_ALL_PATHS {
		res_map["tx_add_paths"] = "tx_all_paths"
	} else if tx_add_paths_type == ocbinds.OpenconfigBgpExt_TxAddPathsType_TX_BEST_PATH_PER_AS {
		res_map["tx_add_paths"] = "tx_best_path_per_as"
	} else {
		err = errors.New("Invalid add Paths type Missing")
		return res_map, err
	}

	return res_map, err

}

var YangToDb_bgp_pgrp_afi_safi_name_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_bgp_pgrp_community_type_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	var err error
	if inParams.param == nil {
		err = errors.New("No Params")
		return res_map, err
	}

	if inParams.oper == DELETE {
		subOpMap := make(map[db.DBNum]map[string]map[string]db.Value)

		if _, ok := subOpMap[db.ConfigDB]; !ok {
			subOpMap[db.ConfigDB] = make(map[string]map[string]db.Value)
		}
		if _, ok := subOpMap[db.ConfigDB]["BGP_PEER_GROUP_AF"]; !ok {
			subOpMap[db.ConfigDB]["BGP_PEER_GROUP_AF"] = make(map[string]db.Value)
		}
		subOpMap[db.ConfigDB]["BGP_PEER_GROUP_AF"][inParams.key] = db.Value{Field: make(map[string]string)}
		subOpMap[db.ConfigDB]["BGP_PEER_GROUP_AF"][inParams.key].Field["send_community"] = "both"

		inParams.subOpDataMap[UPDATE] = &subOpMap
		return res_map, nil
	}

	community_type, _ := inParams.param.(ocbinds.E_OpenconfigBgpExt_BgpExtCommunityType)
	log.Info("YangToDb_bgp_pgrp_community_type_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " community_type: ", community_type)

	if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_STANDARD {
		res_map["send_community"] = "standard"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_EXTENDED {
		res_map["send_community"] = "extended"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_BOTH {
		res_map["send_community"] = "both"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_NONE {
		res_map["send_community"] = "none"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_LARGE {
		res_map["send_community"] = "large"
	} else if community_type == ocbinds.OpenconfigBgpExt_BgpExtCommunityType_ALL {
		res_map["send_community"] = "all"
	} else {
		err = errors.New("send_community  Missing")
		return res_map, err
	}

	return res_map, nil

}

var YangToDb_bgp_pgrp_name_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_bgp_pgrp_orf_type_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	var err error
	if inParams.param == nil {
		err = errors.New("No Params")
		return res_map, err
	}
	if inParams.oper == DELETE {
		res_map["cap_orf"] = ""
		return res_map, nil
	}

	orf_type, _ := inParams.param.(ocbinds.E_OpenconfigBgpExt_BgpOrfType)
	log.Info("YangToDb_bgp_pgrp_orf_type_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " orf_type: ", orf_type)

	if orf_type == ocbinds.OpenconfigBgpExt_BgpOrfType_SEND {
		res_map["cap_orf"] = "send"
	} else if orf_type == ocbinds.OpenconfigBgpExt_BgpOrfType_RECEIVE {
		res_map["cap_orf"] = "receive"
	} else if orf_type == ocbinds.OpenconfigBgpExt_BgpOrfType_BOTH {
		res_map["cap_orf"] = "both"
	} else {
		err = errors.New("ORF type Missing")
		return res_map, err
	}

	return res_map, nil
}

var YangToDb_bgp_pgrp_peer_type_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	var err error
	if inParams.param == nil {
		err = errors.New("No Params")
		return res_map, err
	}
	if inParams.oper == DELETE {
		res_map["peer_type"] = ""
		return res_map, nil
	}

	peer_type, _ := inParams.param.(ocbinds.E_OpenconfigBgp_PeerType)
	log.Info("YangToDb_bgp_pgrp_peer_type_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " peer-type: ", peer_type)

	if peer_type == ocbinds.OpenconfigBgp_PeerType_INTERNAL {
		res_map["peer_type"] = "internal"
	} else if peer_type == ocbinds.OpenconfigBgp_PeerType_EXTERNAL {
		res_map["peer_type"] = "external"
	} else {
		err = errors.New("Peer Type Missing")
		return res_map, err
	}

	return res_map, nil

}

var YangToDb_bgp_pgrp_tx_add_paths_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	var err error
	if inParams.param == nil {
		err = errors.New("No Params")
		return res_map, err
	}
	if inParams.oper == DELETE {
		res_map["tx_add_paths"] = ""
		return res_map, nil
	}

	tx_add_paths_type, _ := inParams.param.(ocbinds.E_OpenconfigBgpExt_TxAddPathsType)
	log.Info("YangToDb_pgrp_tx_add_paths_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " add-paths-type: ", tx_add_paths_type)

	if tx_add_paths_type == ocbinds.OpenconfigBgpExt_TxAddPathsType_TX_ALL_PATHS {
		res_map["tx_add_paths"] = "tx_all_paths"
	} else if tx_add_paths_type == ocbinds.OpenconfigBgpExt_TxAddPathsType_TX_BEST_PATH_PER_AS {
		res_map["tx_add_paths"] = "tx_best_path_per_as"
	} else {
		err = errors.New("Invalid add Paths type Missing")
		return res_map, err
	}

	return res_map, nil

}

var YangToDb_bgp_rt_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_bgp_rt_type_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	res_map["route-target-type"] = "import"
	return res_map, nil
}

var YangToDb_bgp_vni_number_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_community_match_set_options_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		res_map["match_action"] = ""
		return res_map, err
	}
	if inParams.oper == DELETE {
		res_map["match_action"] = ""
		return res_map, nil
	}

	log.Info("YangToDb_community_match_set_options_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri)

	pathInfo := NewPathInfo(inParams.uri)
	if len(pathInfo.Vars) < 1 {
		err = errors.New("Invalid Key length")
		log.Error("Invalid Key length", len(pathInfo.Vars))
		return res_map, err
	}

	setName := pathInfo.Var("community-set-name")
	log.Info("YangToDb_community_match_set_options_fld_xfmr: setName ", setName)
	if len(setName) == 0 {
		err = errors.New("set name is missing")
		log.Error("Set Name is Missing")
		return res_map, err
	}

	prev_match_action, _ := community_set_match_options_get_by_set_name(inParams.d, setName, "COMMUNITY_SET")

	match_opt, _ := inParams.param.(ocbinds.E_OpenconfigRoutingPolicy_MatchSetOptionsType)
	new_match_action := findInMap(MATCH_SET_ACTION_MAP, strconv.FormatInt(int64(match_opt), 10))
	log.Info("YangToDb_community_match_set_options_fld_xfmr: New match Opt: ", new_match_action)
	if len(prev_match_action) > 0 {
		if prev_match_action != new_match_action {
			log.Error("YangToDb_community_match_set_options_fld_xfmr: Match option difference, Error previous", prev_match_action, " new ", new_match_action)
			err = errors.New("Match option difference")
			return nil, err
		} else {
			prev_match_action = new_match_action
		}
	}

	res_map["match_action"] = new_match_action

	return res_map, err
}

var YangToDb_community_member_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	var community_list string
	var new_type string
	var prev_type string

	log.Info("YangToDb_community_member_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, "inParams : ", inParams)
	if inParams.param == nil {
		res_map["community_member@"] = ""
		return res_map, errors.New("Invalid Inputs")
	}

	pathInfo := NewPathInfo(inParams.uri)
	if len(pathInfo.Vars) < 1 {
		err = errors.New("Invalid Key length")
		log.Error("Invalid Key length", len(pathInfo.Vars))
		return res_map, err
	}

	setName := pathInfo.Var("community-set-name")
	log.Info("YangToDb_community_member_fld_xfmr: setName ", setName)
	if len(setName) == 0 {
		err = errors.New("set name is missing")
		log.Error("Set Name is Missing")
		return res_map, err
	}
	is_member_exits, _ := community_set_is_community_members_exits(inParams.d, setName, "COMMUNITY_SET", "community_member@")
	if is_member_exits == true {
		prev_type, _ = community_set_type_get_by_set_name(inParams.d, setName, "COMMUNITY_SET")

		log.Info("YangToDb_community_member_fld_xfmr: prev_type ", prev_type)
	}
	members := inParams.param.([]ocbinds.OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_BgpDefinedSets_CommunitySets_CommunitySet_Config_CommunityMember_Union)

	for _, member := range members {

		memberType := reflect.TypeOf(member).Elem()
		log.Info("YangToDb_community_member_fld_xfmr: member - ", member, " memberType: ", memberType)
		var b bytes.Buffer
		switch memberType {

		case reflect.TypeOf(ocbinds.OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_BgpDefinedSets_CommunitySets_CommunitySet_Config_CommunityMember_Union_E_OpenconfigBgpTypes_BGP_WELL_KNOWN_STD_COMMUNITY{}):
			v := (member).(*ocbinds.OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_BgpDefinedSets_CommunitySets_CommunitySet_Config_CommunityMember_Union_E_OpenconfigBgpTypes_BGP_WELL_KNOWN_STD_COMMUNITY)
			switch v.E_OpenconfigBgpTypes_BGP_WELL_KNOWN_STD_COMMUNITY {
			case ocbinds.OpenconfigBgpTypes_BGP_WELL_KNOWN_STD_COMMUNITY_NOPEER:
				community_list += "no-peer" + ","
				break
			case ocbinds.OpenconfigBgpTypes_BGP_WELL_KNOWN_STD_COMMUNITY_NO_ADVERTISE:
				community_list += "no-advertise" + ","
				break
			case ocbinds.OpenconfigBgpTypes_BGP_WELL_KNOWN_STD_COMMUNITY_NO_EXPORT:
				community_list += "no-export" + ","
				break
			case ocbinds.OpenconfigBgpTypes_BGP_WELL_KNOWN_STD_COMMUNITY_NO_EXPORT_SUBCONFED:
				community_list += "local-AS" + ","
				break
			}
			new_type = "STANDARD"
			break
		case reflect.TypeOf(ocbinds.OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_BgpDefinedSets_CommunitySets_CommunitySet_Config_CommunityMember_Union_Uint32{}):
			v := (member).(*ocbinds.OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_BgpDefinedSets_CommunitySets_CommunitySet_Config_CommunityMember_Union_Uint32)
			fmt.Fprintf(&b, "%d", v.Uint32)
			community_list += b.String() + ","
			new_type = "STANDARD"
			break
		case reflect.TypeOf(ocbinds.OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_BgpDefinedSets_CommunitySets_CommunitySet_Config_CommunityMember_Union_String{}):
			v := (member).(*ocbinds.OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_BgpDefinedSets_CommunitySets_CommunitySet_Config_CommunityMember_Union_String)

			has_regex := strings.HasPrefix(v.String, "REGEX:")
			if has_regex == true {
				new_type = "EXPANDED"
			} else {
				new_type = "STANDARD"
			}
			community_list += strings.TrimPrefix(v.String, "REGEX:") + ","
			break
		}

		log.Info("YangToDb_community_member_fld_xfmr: new_type: ", new_type, " prev_type ", prev_type)
		if (len(prev_type) > 0) && (prev_type != new_type) {
			log.Error("YangToDb_community_member_fld_xfmr: Type Difference Error, previous", prev_type, " newType: ", new_type)
			err = errors.New("Type difference, Quit Operation")
			return res_map, err
		} else {
			prev_type = new_type
		}
	}

	res_map["community_member@"] = strings.TrimSuffix(community_list, ",")

	if (inParams.oper != DELETE) && (prev_type != "") {
		res_map["set_type"] = prev_type
	}

	log.Info("YangToDb_community_member_fld_xfmr: ", res_map["community_member@"], " type ", res_map["set_type"])
	return res_map, err
}

var YangToDb_community_set_name_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	log.Info("YangToDb_community_set_name_fld_xfmr: ", inParams.key)
	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_ext_community_match_set_options_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		res_map["match_action"] = ""
		return res_map, err
	}
	if inParams.oper == DELETE {
		res_map["match_action"] = ""
		return res_map, nil
	}

	log.Info("YangToDb_ext_community_match_set_options_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri)

	pathInfo := NewPathInfo(inParams.uri)
	if len(pathInfo.Vars) < 1 {
		err = errors.New("Invalid Key length")
		log.Error("Invalid Key length", len(pathInfo.Vars))
		return res_map, err
	}

	setName := pathInfo.Var("ext-community-set-name")
	log.Info("YangToDb_ext_community_match_set_options_fld_xfmr: setName ", setName)
	if len(setName) == 0 {
		err = errors.New("set name is missing")
		log.Error("Set Name is Missing")
		return res_map, err
	}

	prev_match_action, _ := community_set_match_options_get_by_set_name(inParams.d, setName, "EXTENDED_COMMUNITY_SET")

	match_opt, _ := inParams.param.(ocbinds.E_OpenconfigRoutingPolicy_MatchSetOptionsType)
	new_match_action := findInMap(MATCH_SET_ACTION_MAP, strconv.FormatInt(int64(match_opt), 10))
	log.Info("YangToDb_ext_community_match_set_options_fld_xfmr: New match Opt: ", new_match_action)
	if len(prev_match_action) > 0 {
		if prev_match_action != new_match_action {
			log.Error("YangToDb_ext_community_match_set_options_fld_xfmr: Match option difference, Error previous", prev_match_action, " new ", new_match_action)
			err = errors.New("Match option difference")
			return nil, err
		} else {
			prev_match_action = new_match_action
		}
	}

	res_map["match_action"] = new_match_action

	return res_map, err
}

var YangToDb_ext_community_member_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	var community_list string
	var new_type string
	var prev_type string

	log.Info("YangToDb_ext_community_member_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, "inParams : ", inParams)
	if inParams.param == nil {
		res_map["community_member@"] = ""
		return res_map, errors.New("Invalid Inputs")
	}

	pathInfo := NewPathInfo(inParams.uri)
	if len(pathInfo.Vars) < 1 {
		err = errors.New("Invalid Key length")
		log.Error("Invalid Key length", len(pathInfo.Vars))
		return res_map, err
	}

	setName := pathInfo.Var("ext-community-set-name")
	log.Info("YangToDb_ext_community_member_fld_xfmr: setName ", setName)
	if len(setName) == 0 {
		err = errors.New("set name is missing")
		log.Error("Set Name is Missing")
		return res_map, err
	}
	is_member_exits, _ := community_set_is_community_members_exits(inParams.d, setName, "EXTENDED_COMMUNITY_SET", "community_member@")
	if is_member_exits == true {
		prev_type, _ = community_set_type_get_by_set_name(inParams.d, setName, "EXTENDED_COMMUNITY_SET")

		log.Info("YangToDb_ext_community_member_fld_xfmr: prev_type ", prev_type)
	}

	members := inParams.param.([]string)

	log.Info("YangToDb_ext_community_member_fld_xfmr: members", members)
	for _, member := range members {

		has_regex := strings.HasPrefix(member, "REGEX:")
		if has_regex == true {
			new_type = "EXPANDED"
		} else {
			new_type = "STANDARD"
		}
		member = strings.TrimPrefix(member, "REGEX:")

		has_rt := strings.HasPrefix(member, "route-target")
		has_ro := strings.HasPrefix(member, "route-origin")
		if (new_type == "STANDARD") && (has_rt == false) && (has_ro == false) {
			err = errors.New("Community member is not of type route-target or route-origin")
			log.Error("Community member is not of type route-target or route-origin")
			return res_map, err
		}
		community_list += member + ","
		log.Info("YangToDb_ext_community_member_fld_xfmr: new_type: ", new_type, " prev_type ", prev_type)
		if (len(prev_type) > 0) && (prev_type != new_type) {
			log.Error("YangToDb_ext_community_member_fld_xfmr: Type Difference Error, previous", prev_type, " newType: ", new_type)
			err = errors.New("Type difference, Quit Operation")
			return res_map, err
		} else {
			prev_type = new_type
		}
	}
	res_map["community_member@"] = strings.TrimSuffix(community_list, ",")

	if (inParams.oper != DELETE) && (prev_type != "") {
		res_map["set_type"] = prev_type
	}

	log.Info("YangToDb_ext_community_member_fld_xfmr: ", res_map["community_member@"], " type ", res_map["set_type"])
	return res_map, err
}

var YangToDb_ext_community_set_name_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	log.Info("YangToDb_ext_community_set_name_fld_xfmr: ", inParams.key)
	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_global_sg_name_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	if log.V(3) {
		log.Info("YangToDb_global_sg_name_xfmr: root: ", inParams.ygRoot,
			", uri: ", inParams.uri)
	}

	res_map := make(map[string]string)
	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_intf_enabled_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var ifName string
	intfsObj := getIntfsRoot(inParams.ygRoot)
	if intfsObj == nil || len(intfsObj.Interface) < 1 {
		return res_map, nil
	} else {
		for infK, _ := range intfsObj.Interface {
			ifName = infK
		}
	}

	intfType, _, _ := getIntfTypeByName(ifName)
	if IntfTypeVxlan == intfType {
		return res_map, nil
	}

	enabled, _ := inParams.param.(*bool)
	var enStr string
	if *enabled == true {
		enStr = "up"
	} else {
		enStr = "down"
	}
	res_map[PORT_ADMIN_STATUS] = enStr

	return res_map, nil
}

var YangToDb_intf_name_empty_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	return res_map, err
}

var YangToDb_intf_name_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	ifName := pathInfo.Var("name")

	if strings.HasPrefix(ifName, VXLAN) == true {
		res_map["NULL"] = "NULL"
	} else if strings.HasPrefix(ifName, VLAN) == true {
		vlanId := ifName[len("Vlan"):len(ifName)]
		res_map["vlanid"] = vlanId
	} else if strings.HasPrefix(ifName, PORTCHANNEL) == true {
		res_map["NULL"] = "NULL"
	} else if strings.HasPrefix(ifName, LOOPBACK) == true {
		res_map["NULL"] = "NULL"
	} else if strings.HasPrefix(ifName, ETHERNET) == true {
		intTbl := IntfTypeTblMap[IntfTypeEthernet]

		err = validateIntfExists(inParams.d, intTbl.cfgDb.portTN, ifName)
		if err != nil {
			errStr := "Interface " + ifName + " cannot be configured."
			return res_map, tlerr.InvalidArgsError{Format: errStr}
		}
	}
	log.Info("YangToDb_intf_name_xfm: res_map:", res_map)
	return res_map, err
}

var YangToDb_intf_type_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var ifName string
	intfsObj := getIntfsRoot(inParams.ygRoot)
	if intfsObj == nil || len(intfsObj.Interface) < 1 {
		return res_map, nil
	} else {
		for infK, _ := range intfsObj.Interface {
			ifName = infK
		}
	}
	intfType, _, _ := getIntfTypeByName(ifName)
	if IntfTypeVxlan == intfType {
		return res_map, nil
	} else {
		intfTypeVal, _ := inParams.param.(int64)
		intTypeValStr := strconv.FormatInt(intfTypeVal, 10)
		res_map["type"] = intTypeValStr
		return res_map, nil
	}
}

var YangToDb_lag_fallback_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	err = can_configure_fallback(inParams)
	if err != nil {
		return res_map, err
	}

	fallback, _ := inParams.param.(*bool)
	res_map["fallback"] = strconv.FormatBool(*fallback)
	return res_map, nil
}

var YangToDb_lag_min_links_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	ifKey := pathInfo.Var("name")

	log.Infof("Received Min links config for path: %s; template: %s vars: %v ifKey: %s", pathInfo.Path, pathInfo.Template, pathInfo.Vars, ifKey)

	var links uint16
	err = get_min_links(inParams.d, &ifKey, &links)

	if err == nil && links != *(inParams.param.(*uint16)) {
		errStr := "Cannot reconfigure min links for an existing PortChannel: " + ifKey
		log.Info(errStr)
		err = tlerr.InvalidArgsError{Format: errStr}
		return res_map, err
	}

	minLinks, _ := inParams.param.(*uint16)
	res_map["min_links"] = strconv.Itoa(int(*minLinks))
	return res_map, nil
}

var YangToDb_lag_type_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	result := make(map[string]string)
	var err error

	if inParams.param == nil {
		return result, err
	}

	pathInfo := NewPathInfo(inParams.uri)
	ifKey := pathInfo.Var("name")

	log.Infof("Received Mode configuration for path: %s; template: %s vars: %v ifKey: %s", pathInfo.Path, pathInfo.Template, pathInfo.Vars, ifKey)

	var mode string
	err = get_lag_type(inParams.d, &ifKey, &mode)

	t, _ := inParams.param.(ocbinds.E_OpenconfigIfAggregate_AggregationType)
	user_mode := findInMap(LAG_TYPE_MAP, strconv.FormatInt(int64(t), 10))

	if err == nil && mode != user_mode {
		errStr := "Cannot configure Mode for an existing PortChannel: " + ifKey
		err = tlerr.InvalidArgsError{Format: errStr}
		return result, err
	}

	log.Info("YangToDb_lag_type_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " type: ", t)
	result["static"] = user_mode
	return result, nil

}

var YangToDb_mclag_domainid_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	log.Info("YangToDb_mclag_domainid_fld_xfmr: ", inParams.key)

	return res_map, err
}

var YangToDb_mclag_vlan_name_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	log.Info("YangToDb_mclag_vlan_name_fld_xfmr: ", inParams.key)

	return res_map, err
}

var YangToDb_nat_enable_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	enabled, _ := inParams.param.(*bool)
	var enStr string
	if *enabled == true {
		enStr = ENABLED
	} else {
		enStr = DISABLED
	}
	res_map[ADMIN_MODE] = enStr

	return res_map, nil
}

var YangToDb_nat_entry_type_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	result := make(map[string]string)
	var err error

	if inParams.param == nil {
		return result, err
	}

	t, _ := inParams.param.(ocbinds.E_OpenconfigNat_NAT_ENTRY_TYPE)
	log.Info("YangToDb_nat_entry_type_field_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " type: ", t)
	result[NAT_ENTRY_TYPE] = findInMap(NAT_ENTRY_TYPE_MAP, strconv.FormatInt(int64(t), 10))
	return result, err
}

var YangToDb_nat_ip_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	ipPtr, _ := inParams.param.(*string)
	res_map["nat_ip"] = *ipPtr
	return res_map, nil
}

var YangToDb_nat_type_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	result := make(map[string]string)
	var err error

	if inParams.param == nil {
		return result, err
	}

	t, _ := inParams.param.(ocbinds.E_OpenconfigNat_NAT_TYPE)
	log.Info("YangToDb_nat_type_field_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " type: ", t)
	result[NAT_TYPE] = findInMap(NAT_TYPE_MAP, strconv.FormatInt(int64(t), 10))
	return result, err

}

var YangToDb_network_instance_description_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	log.Info("YangToDb_network_instance_description_field_xfmr")

	return res_map, err
}

var YangToDb_network_instance_enabled_addr_family_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	log.Info("YangToDb_network_instance_enabled_addr_fam_field_xfmr")

	return res_map, err
}

var YangToDb_network_instance_enabled_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	log.Info("YangToDb_network_instance_enabled_field_xfmr")

	nwInstObj := getNwInstRoot(inParams.ygRoot)
	if nwInstObj.NetworkInstance == nil {
		return res_map, errors.New("Network instance not set")
	}

	if strings.HasPrefix(inParams.key, "Vlan") {
		log.Infof("YangToDb Vlan key %s, do not add fallback attriubtes.", inParams.key)
		return res_map, err
	}

	pathInfo := NewPathInfo(inParams.uri)

	if len(pathInfo.Vars) < 1 {

		return res_map, errors.New("Invalid xpath, key attributes not found")
	}

	targetUriPath, err := getYangPathFromUri(pathInfo.Path)

	log.Info("YangToDb_network_instance_enabled_field_xfmr targetUri: ", targetUriPath)

	keyName := pathInfo.Var("name")
	if keyName != "mgmt" {
		log.Info("YangToDb_network_instance_enabled_field_xfmr, not mgmt vrf ", keyName)

		res_map["fallback"] = "false"
		return res_map, err
	}

	enabled, _ := inParams.param.(*bool)

	var enStr string
	if *enabled == true {
		enStr = "true"
	} else {
		enStr = "false"
	}

	res_map[MGMT_VRF_ENABLE] = enStr
	log.Info("YangToDb_network_instance_enabled_field_xfmr: ", res_map)

	return res_map, err
}

var YangToDb_network_instance_mtu_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	log.Info("YangToDb_network_instance_mtu_field_xfmr")

	return res_map, err
}

var YangToDb_network_instance_name_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	log.Info("YangToDb_network_instance_name_field_xfmr")

	if inParams.key != "" && strings.HasPrefix(inParams.key, "Vlan") {
		vlanIdStr := strings.TrimPrefix(inParams.key, "Vlan")
		res_map["vlanid"] = vlanIdStr
	} else {

		res_map["NULL"] = "NULL"
	}

	return res_map, err
}

var YangToDb_network_instance_name_key_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	log.Info("YangToDb_network_instance_name_key_xfmr")

	return res_map, err
}

var YangToDb_network_instance_route_distinguisher_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	log.Info("YangToDb_network_instance_route_distinguisher_field_xfmr")

	return res_map, err
}

var YangToDb_network_instance_router_id_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	log.Info("YangToDb_network_instance_router_id_field_xfmr")

	return res_map, err
}

var YangToDb_network_instance_type_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	log.Info("YangToDb_network_instance_type_field_xfmr")

	return res_map, err
}

var YangToDb_nw_inst_vxlan_source_nve_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_source_nve_xfmr ==> printing target object request ==> ", inParams.param)
	}

	path, err := getVxlanNiUriPath(inParams.uri)

	if err != nil {
		return res_map, err
	}

	reqP := &vxlanReqProcessor{&inParams.requestUri, &inParams.uri, path, inParams.oper, (*inParams.ygRoot).(*ocbinds.Device), inParams.param, inParams.d, inParams.dbs, nil, nil, nil, nil, &inParams}

	if err = reqP.setVxlanNetInstObjFromReq(); err != nil {
		return res_map, err
	}

	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_source_nve_xfmr ==> printing vxlanNetInstObj object request ==> ", (*reqP.vxlanNetInstObj))
	}

	niName := *(reqP.vxlanNetInstObj.Name)
	res_map["vlan"] = niName

	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_source_nve_xfmr ==> res_map  ===> ", res_map)
	}

	return res_map, err
}

var YangToDb_nw_inst_vxlan_vni_id_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_vni_id_xfmr ==> printing target object inParams.uri ==> ", (inParams.uri))
	}

	path, err := getVxlanNiUriPath(inParams.uri)

	if err != nil {
		return res_map, err
	}

	reqP := &vxlanReqProcessor{&inParams.requestUri, &inParams.uri, path, inParams.oper, (*inParams.ygRoot).(*ocbinds.Device), inParams.param, inParams.d, inParams.dbs, nil, nil, nil, nil, &inParams}

	if err := reqP.setVxlanNetInstObjFromReq(); err != nil {
		return nil, err
	}

	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_vni_id_xfmr ==> printing vxlanNetInstObj object request ==> ", (*reqP.vxlanNetInstObj))
	}

	if reqP.vxlanNetInstObj.VxlanVniInstances == nil {
		return res_map, tlerr.NotFound("Resource Not Found")
	}

	for _, vxlanNiMap := range reqP.vxlanNetInstObj.VxlanVniInstances.VniInstance {
		res_map["vni"] = strconv.Itoa(int(*vxlanNiMap.Config.VniId))
		break
	}

	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_vni_id_xfmr ==> res_map  ===> ", res_map)
	}

	return res_map, err
}

var YangToDb_prefix_action_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {

	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		return res_map, err
	}
	if inParams.oper == DELETE {
		res_map["action"] = ""
		return res_map, nil
	}

	action, _ := inParams.param.(ocbinds.E_OpenconfigRoutingPolicyExt_RoutingPolicyExtActionType)
	log.Info("YangToDb_prefix_action_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " route-operation: ", action)
	if action == ocbinds.OpenconfigRoutingPolicyExt_RoutingPolicyExtActionType_PERMIT {
		res_map["action"] = "permit"
	} else if action == ocbinds.OpenconfigRoutingPolicyExt_RoutingPolicyExtActionType_DENY {
		res_map["action"] = "deny"
	}
	return res_map, err
}

var YangToDb_prefix_empty_ip_prefix_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	log.Info("YangToDb_prefix_empty_ip_prefix_fld_xfmr: ", inParams.key)
	return res_map, nil
}

var YangToDb_prefix_empty_masklength_range_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	log.Info("YangToDb_prefix_empty_masklength_range_fld_xfmr: ", inParams.key)
	return res_map, nil
}

var YangToDb_prefix_empty_set_name_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	log.Info("YangToDb_prefix_empty_set_name_fld_xfmr: ", inParams.key)
	return res_map, nil
}

var YangToDb_prefix_ip_prefix_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	log.Info("YangToDb_prefix_ip_prefix_fld_xfmr: ", inParams.key)
	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_prefix_masklength_range_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	log.Info("YangToDb_prefix_masklength_range_fld_xfmr: ", inParams.key)
	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_prefix_set_mode_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		res_map["mode"] = ""
		return res_map, err
	}
	if inParams.oper == DELETE {
		res_map["mode"] = ""
		return res_map, nil
	}

	pathInfo := NewPathInfo(inParams.uri)

	setName := pathInfo.Var("name")
	if len(setName) == 0 {
		err = errors.New("set name is missing")
		log.Error("Set Name is Missing")
		return res_map, err
	}
	is_prefixes_exits := prefixes_exits_by_set_name(inParams.d, setName, "PREFIX")
	log.Info("YangToDb_prefix_set_mode_fld_xfmr: setName ", setName, "is_prefixes_exits ", is_prefixes_exits)

	mode, _ := inParams.param.(ocbinds.E_OpenconfigRoutingPolicy_RoutingPolicy_DefinedSets_PrefixSets_PrefixSet_Config_Mode)
	log.Info("YangToDb_prefix_set_mode_fld_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " Mode: ", mode)
	new_mode := findInMap(PREFIX_SET_MODE_MAP, strconv.FormatInt(int64(mode), 10))

	prev_mode, _ := prefix_set_mode_get_by_set_name(inParams.d, setName, "PREFIX_SET")

	log.Info("YangToDb_prefix_set_mode_fld_xfmr: prev_mode ", prev_mode, "new mode ", res_map["mode"], "is_prefixes_exits ", is_prefixes_exits)
	if (is_prefixes_exits == true) && (prev_mode != new_mode) {
		err = errors.New("Prefixes Configured already, Mode Change not supported")
		log.Error("Prefixes Configured already, Mode Change not supported")
		return res_map, err
	}
	res_map["mode"] = new_mode
	return res_map, err
}

var YangToDb_prefix_set_name_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	log.Info("YangToDb_prefix_cfg_set_name_fld_xfmr: ", inParams.key)
	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_ptp_boolean_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	var outval string
	if inParams.param == nil {
		log.Info("YangToDb_ptp_boolean_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_boolean_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_boolean_xfmr inParams.key: ", inParams.key)
	log.Info("YangToDb_ptp_boolean_xfmr inParams.curDb: ", inParams.curDb)

	inval, _ := inParams.param.(*bool)
	_, field := filepath.Split(inParams.uri)
	log.Info("YangToDb_ptp_boolean_xfmr inval: ", *inval, " field: ", field)

	if *inval {
		outval = "1"
	} else {
		outval = "0"
	}

	log.Info("YangToDb_ptp_boolean_xfmr outval: ", outval, " field: ", field)
	res_map[field] = outval
	return res_map, err
}

var YangToDb_ptp_clock_identity_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	var field string
	var identity []byte
	if inParams.param == nil {
		log.Info("YangToDb_ptp_clock_identity_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_clock_identity_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_clock_identity_xfmr inParams.key: ", inParams.key)

	ptpObj := getPtpRoot(inParams.ygRoot)

	if strings.Contains(inParams.uri, "grandmaster-identity") {
		identity = ptpObj.InstanceList[0].ParentDs.GrandmasterIdentity
		field = "grandmaster-identity"
	} else if strings.Contains(inParams.uri, "parent-port-identity") {
		identity = ptpObj.InstanceList[0].ParentDs.ParentPortIdentity.ClockIdentity
		field = "clock-identity"

	} else if strings.Contains(inParams.uri, "default-ds") {
		identity = ptpObj.InstanceList[0].DefaultDs.ClockIdentity
		field = "clock-identity"
	}

	enc := fmt.Sprintf("%02x%02x%02x.%02x%02x.%02x%02x%02x",
		identity[0], identity[1], identity[2], identity[3], identity[4], identity[5], identity[6], identity[7])

	log.Info("YangToDb_ptp_clock_identity_xfmr enc: ", enc, " field: ", field)
	res_map[field] = enc
	return res_map, err
}

var YangToDb_ptp_clock_type_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var outval string
	var err error
	if inParams.param == nil {
		log.Info("YangToDb_ptp_clock_type_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_clock_type_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_clock_type_xfmr inParams.key: ", inParams.key)

	pathInfo := NewPathInfo(inParams.uri)
	instance_id, _ := strconv.ParseUint(pathInfo.Var("instance-number"), 10, 64)
	log.Info("YangToDb_ptp_clock_type_xfmr instance_number : ", instance_id)

	ptpObj := getPtpRoot(inParams.ygRoot)
	outval = *ptpObj.InstanceList[uint32(instance_id)].DefaultDs.ClockType

	if outval == "P2P_TC" {
		return res_map, tlerr.InvalidArgsError{Format: "peer-to-peer-transparent-clock is not supported"}
	}

	log.Info("YangToDb_ptp_clock_type_xfmr outval: ", outval)
	_, field := filepath.Split(inParams.uri)
	domain_profile := ""
	network_transport := ""
	unicast_multicast := ""

	ts := db.TableSpec{Name: "PTP_CLOCK"}
	ca := make([]string, 1, 1)

	ca[0] = "GLOBAL"
	akey := db.Key{Comp: ca}
	entry, err := inParams.d.GetEntry(&ts, akey)
	if entry.Has("domain-profile") {
		domain_profile = entry.Get("domain-profile")
	}
	if entry.Has("network-transport") {
		network_transport = entry.Get("network-transport")
	}
	if entry.Has("unicast-multicast") {
		unicast_multicast = entry.Get("unicast-multicast")
	}

	log.Info("YangToDb_ptp_clock_type_xfmr domain_profile : ", domain_profile, " network-transport : ", network_transport,
		" unicast-multicast : ", unicast_multicast)

	if outval == "P2P_TC" || outval == "E2E_TC" {
		if domain_profile == "G.8275.x" {
			return res_map, tlerr.InvalidArgsError{Format: "transparent-clock not supported with G.8275.2"}
		}
		if domain_profile == "ieee1588" && unicast_multicast == "unicast" {
			return res_map, tlerr.InvalidArgsError{Format: "transparent-clock not supported with default profile and unicast"}
		}
	}
	if outval == "BC" {
		if domain_profile == "G.8275.x" && network_transport == "L2" {
			return res_map, tlerr.InvalidArgsError{Format: "boundary-clock not supported with G.8275.2 and L2"}
		}
		if domain_profile == "G.8275.x" && unicast_multicast == "multicast" {
			return res_map, tlerr.InvalidArgsError{Format: "boundary-clock not supported with G.8275.2 and multicast"}
		}
		if domain_profile == "G.8275.x" && network_transport == "UDPv6" {
			return res_map, tlerr.InvalidArgsError{Format: "boundary-clock not supported with G.8275.2 and ipv6"}
		}
	}

	log.Info("YangToDb_ptp_clock_type_xfmr outval: ", outval, " field: ", field)
	res_map[field] = outval
	return res_map, nil
}

var YangToDb_ptp_delay_mech_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	var outval string
	if inParams.param == nil {
		log.Info("YangToDb_ptp_delay_mech_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_delay_mech_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_delay_mech_xfmr inParams.key: ", inParams.key)

	inval, _ := inParams.param.(ocbinds.E_IETFPtp_DelayMechanismEnumeration)
	_, field := filepath.Split(inParams.uri)

	log.Info("YangToDb_ptp_delay_mech_xfmr outval: ", outval, " field: ", field)
	res_map[field] = findInMap(PTP_DELAY_MECH_MAP, strconv.FormatInt(int64(inval), 10))

	return res_map, err
}

var YangToDb_ptp_domain_number_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var outval uint8
	var err error
	if inParams.param == nil {
		log.Info("YangToDb_ptp_domain_number_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_domain_number_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_domain_number_xfmr inParams.key: ", inParams.key)

	pathInfo := NewPathInfo(inParams.uri)
	instance_id, _ := strconv.ParseUint(pathInfo.Var("instance-number"), 10, 64)
	log.Info("YangToDb_ptp_domain_number_xfmr instance_number : ", instance_id)

	ptpObj := getPtpRoot(inParams.ygRoot)
	outval = *ptpObj.InstanceList[uint32(instance_id)].DefaultDs.DomainNumber
	log.Info("YangToDb_ptp_domain_number_xfmr outval: ", outval)
	_, field := filepath.Split(inParams.uri)
	domain_profile := ""

	ts := db.TableSpec{Name: "PTP_CLOCK"}
	ca := make([]string, 1, 1)

	ca[0] = "GLOBAL"
	akey := db.Key{Comp: ca}
	entry, err := inParams.d.GetEntry(&ts, akey)
	if entry.Has("domain-profile") {
		domain_profile = entry.Get("domain-profile")
	}

	log.Info("YangToDb_ptp_domain_number_xfmr domain_profile : ", domain_profile)

	if domain_profile == "G.8275.x" {
		if outval < 44 || outval > 63 {
			return res_map, tlerr.InvalidArgsError{Format: "domain must be in range 44-63 with G.8275.2"}
		}
	}

	log.Info("YangToDb_ptp_domain_number_xfmr outval: ", outval, " field: ", field)
	res_map[field] = strconv.FormatInt(int64(outval), 10)
	return res_map, nil
}

var YangToDb_ptp_domain_profile_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var outval string
	var err error
	if inParams.param == nil {
		log.Info("YangToDb_ptp_domain_profile_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_domain_profile_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_domain_profile_xfmr inParams.key: ", inParams.key)

	pathInfo := NewPathInfo(inParams.uri)
	instance_id, _ := strconv.ParseUint(pathInfo.Var("instance-number"), 10, 64)
	log.Info("YangToDb_ptp_domain_profile_xfmr instance_number : ", instance_id)

	ptpObj := getPtpRoot(inParams.ygRoot)
	outval = *ptpObj.InstanceList[uint32(instance_id)].DefaultDs.DomainProfile

	if outval == "G.8275.1" {
		return res_map, tlerr.InvalidArgsError{Format: "g8275.1 is not supported"}
	}
	if outval == "G.8275.2" {
		outval = "G.8275.x"
	}

	log.Info("YangToDb_ptp_domain_profile_xfmr outval: ", outval)
	_, field := filepath.Split(inParams.uri)
	var domain_number uint64
	network_transport := ""
	unicast_multicast := ""
	clock_type := ""

	ts := db.TableSpec{Name: "PTP_CLOCK"}
	ca := make([]string, 1, 1)

	ca[0] = "GLOBAL"
	akey := db.Key{Comp: ca}
	entry, err := inParams.d.GetEntry(&ts, akey)
	if entry.Has("domain-number") {
		domain_number, _ = strconv.ParseUint(entry.Get("domain-number"), 10, 64)
	}
	if entry.Has("network-transport") {
		network_transport = entry.Get("network-transport")
	}
	if entry.Has("unicast-multicast") {
		unicast_multicast = entry.Get("unicast-multicast")
	}
	if entry.Has("clock-type") {
		clock_type = entry.Get("clock-type")
	}

	log.Info("YangToDb_ptp_domain_profile_xfmr domain_number : ", domain_number, " network-transport : ", network_transport,
		" unicast-multicast : ", unicast_multicast, " clock-type : ", clock_type)

	if outval == "G.8275.x" {
		if clock_type == "BC" && network_transport == "L2" {
			return res_map, tlerr.InvalidArgsError{Format: "G.8275.2 not supported with L2 transport"}
		}
		if clock_type == "BC" && unicast_multicast == "multicast" {
			return res_map, tlerr.InvalidArgsError{Format: "G.8275.2 not supported with multicast transport"}
		}
		if clock_type == "BC" && (domain_number < 44 || domain_number > 63) {
			return res_map, tlerr.InvalidArgsError{Format: "domain must be in range 44-63 with G.8275.2"}
		}
		if clock_type == "BC" && network_transport == "UDPv6" {
			return res_map, tlerr.InvalidArgsError{Format: "ipv6 not supported with boundary-clock and G.8275.2"}
		}
		if clock_type == "P2P_TC" || clock_type == "E2E_TC" {
			return res_map, tlerr.InvalidArgsError{Format: "G.8275.2 not supported with transparent-clock"}
		}
	}
	if outval == "ieee1588" {
		if unicast_multicast == "unicast" && (clock_type == "PTP_TC" || clock_type == "E2E_TC") {
			return res_map, tlerr.InvalidArgsError{Format: "default profile not supported with transparent-clock and unicast"}
		}
	}

	log.Info("YangToDb_ptp_domain_profile_xfmr outval: ", outval, " field: ", field)
	res_map[field] = outval
	return res_map, nil
}

var YangToDb_ptp_inst_number_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_ptp_network_transport_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var outval string
	var err error
	if inParams.param == nil {
		log.Info("YangToDb_ptp_network_transport_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_network_transport_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_network_transport_xfmr inParams.key: ", inParams.key)

	pathInfo := NewPathInfo(inParams.uri)
	instance_id, _ := strconv.ParseUint(pathInfo.Var("instance-number"), 10, 64)
	log.Info("YangToDb_ptp_network_transport_xfmr instance_number : ", instance_id)

	ptpObj := getPtpRoot(inParams.ygRoot)
	outval = *ptpObj.InstanceList[uint32(instance_id)].DefaultDs.NetworkTransport
	log.Info("YangToDb_ptp_network_transport_xfmr outval: ", outval)
	_, field := filepath.Split(inParams.uri)
	domain_profile := ""

	ts := db.TableSpec{Name: "PTP_CLOCK"}
	ca := make([]string, 1, 1)

	ca[0] = "GLOBAL"
	akey := db.Key{Comp: ca}
	entry, err := inParams.d.GetEntry(&ts, akey)
	if entry.Has("domain-profile") {
		domain_profile = entry.Get("domain-profile")
	}

	log.Info("YangToDb_ptp_network_transport_xfmr domain_profile : ", domain_profile)

	if outval == "L2" && domain_profile == "G.8275.x" {
		return res_map, tlerr.InvalidArgsError{Format: "L2 not supported with G.8275.2"}
	}

	log.Info("YangToDb_ptp_network_transport_xfmr outval: ", outval, " field: ", field)
	res_map[field] = outval
	return res_map, nil
}

var YangToDb_ptp_port_state_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	var outval string
	if inParams.param == nil {
		log.Info("YangToDb_ptp_port_state_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_port_state_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_port_state_xfmr inParams.key: ", inParams.key)

	inval, _ := inParams.param.(ocbinds.E_IETFPtp_PortStateEnumeration)
	_, field := filepath.Split(inParams.uri)

	switch inval {
	case ocbinds.IETFPtp_PortStateEnumeration_initializing:
		outval = "1"
	case ocbinds.IETFPtp_PortStateEnumeration_faulty:
		outval = "2"
	case ocbinds.IETFPtp_PortStateEnumeration_disabled:
		outval = "3"
	case ocbinds.IETFPtp_PortStateEnumeration_listening:
		outval = "4"
	case ocbinds.IETFPtp_PortStateEnumeration_pre_master:
		outval = "5"
	case ocbinds.IETFPtp_PortStateEnumeration_master:
		outval = "6"
	case ocbinds.IETFPtp_PortStateEnumeration_passive:
		outval = "7"
	case ocbinds.IETFPtp_PortStateEnumeration_uncalibrated:
		outval = "8"
	case ocbinds.IETFPtp_PortStateEnumeration_slave:
		outval = "9"
	}

	log.Info("YangToDb_ptp_port_state_xfmr outval: ", outval, " field: ", field)
	res_map[field] = outval
	return res_map, err
}

var YangToDb_ptp_udp6_scope_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var inval uint8
	var err error

	if inParams.param == nil {
		log.Info("YangToDb_ptp_udp6_scope_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_udp6_scope_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_udp6_scope_xfmr inParams.key: ", inParams.key)
	pathInfo := NewPathInfo(inParams.uri)
	instance_id, _ := strconv.ParseUint(pathInfo.Var("instance-number"), 10, 64)
	port_number, _ := strconv.ParseUint(pathInfo.Var("port-number"), 10, 64)
	log.Info("YangToDb_ptp_udp6_scope_xfmr instance_number : ", instance_id, " port_number: ", port_number)

	ptpObj := getPtpRoot(inParams.ygRoot)
	inval = *ptpObj.InstanceList[uint32(instance_id)].DefaultDs.Udp6Scope
	log.Info("YangToDb_ptp_udp6_scope_xfmr inval: ", inval)
	_, field := filepath.Split(inParams.uri)

	if inval > 0xf {
		return res_map, tlerr.InvalidArgsError{Format: "Invalid value passed for udp6-scope"}
	}
	outval := fmt.Sprintf("0x%x", inval)

	log.Info("YangToDb_ptp_udp6_scope_xfmr outval: ", outval, " field: ", field)
	res_map[field] = outval
	return res_map, nil
}

var YangToDb_ptp_unicast_multicast_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var outval string
	var err error
	if inParams.param == nil {
		log.Info("YangToDb_ptp_unicast_multicast_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_unicast_multicast_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_unicast_multicast_xfmr inParams.key: ", inParams.key)

	pathInfo := NewPathInfo(inParams.uri)
	instance_id, _ := strconv.ParseUint(pathInfo.Var("instance-number"), 10, 64)
	log.Info("YangToDb_ptp_unicast_multicast_xfmr instance_number : ", instance_id)

	ptpObj := getPtpRoot(inParams.ygRoot)
	outval = *ptpObj.InstanceList[uint32(instance_id)].DefaultDs.UnicastMulticast
	log.Info("YangToDb_ptp_unicast_multicast_xfmr outval: ", outval)
	_, field := filepath.Split(inParams.uri)
	domain_profile := ""
	network_transport := ""
	clock_type := ""

	ts := db.TableSpec{Name: "PTP_CLOCK"}
	ca := make([]string, 1, 1)

	ca[0] = "GLOBAL"
	akey := db.Key{Comp: ca}
	entry, err := inParams.d.GetEntry(&ts, akey)
	if entry.Has("domain-profile") {
		domain_profile = entry.Get("domain-profile")
	}
	if entry.Has("network-transport") {
		network_transport = entry.Get("network-transport")
	}
	if entry.Has("clock-type") {
		clock_type = entry.Get("clock-type")
	}

	log.Info("YangToDb_ptp_unicast_multicast_xfmr domain_profile : ", domain_profile,
		" network_transport : ", network_transport, " clock_type : ", clock_type)

	if outval == "multicast" {
		if domain_profile == "G.8275.x" {
			return res_map, tlerr.InvalidArgsError{Format: "multicast not supported with G.8275.2"}
		}
		keys, tblErr := inParams.d.GetKeys(&db.TableSpec{Name: "PTP_PORT|GLOBAL"})
		if tblErr == nil {
			for _, key := range keys {
				entry2, err2 := inParams.d.GetEntry(&db.TableSpec{Name: "PTP_PORT"}, key)
				if err2 == nil {
					if entry2.Has("unicast-table") {
						log.Info("YangToDb_ptp_unicast_multicast_xfmr unicast-table : ", entry2.Get("unicast-table"))
						if entry2.Get("unicast-table") != "" {
							return res_map, tlerr.InvalidArgsError{Format: "master table must be removed from " + key.Comp[1]}
						}
					}
				}
			}
		}
	}
	if outval == "unicast" {
		if domain_profile == "ieee1588" && (clock_type == "PTP_TC" || clock_type == "E2E_TC") {
			return res_map, tlerr.InvalidArgsError{Format: "unicast not supported with transparent-clock and default profile"}
		}
		if network_transport == "UDPv6" {
			return res_map, tlerr.InvalidArgsError{Format: "ipv6 not supported with unicast"}
		}
	}

	log.Info("YangToDb_ptp_unicast_multicast_xfmr outval: ", outval, " field: ", field)
	res_map[field] = outval
	return res_map, nil
}

var YangToDb_ptp_unicast_table_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var outval string
	var err error
	if inParams.param == nil {
		log.Info("YangToDb_ptp_unicast_table_xfmr Error: ")
		return res_map, err
	}
	log.Info("YangToDb_ptp_unicast_table_xfmr : ", *inParams.ygRoot, " Xpath: ", inParams.uri)
	log.Info("YangToDb_ptp_unicast_table_xfmr inParams.key: ", inParams.key)
	pathInfo := NewPathInfo(inParams.uri)
	instance_id, _ := strconv.ParseUint(pathInfo.Var("instance-number"), 10, 64)
	port_number, _ := strconv.ParseUint(pathInfo.Var("port-number"), 10, 64)
	log.Info("YangToDb_ptp_unicast_table_xfmr instance_number : ", instance_id, " port_number: ", port_number)

	ptpObj := getPtpRoot(inParams.ygRoot)
	outval = *ptpObj.InstanceList[uint32(instance_id)].PortDsList[uint16(port_number)].UnicastTable
	log.Info("YangToDb_ptp_unicast_table_xfmr outval: ", outval)
	_, field := filepath.Split(inParams.uri)
	unicast_multicast := ""

	ts := db.TableSpec{Name: "PTP_CLOCK"}
	ca := make([]string, 1, 1)

	ca[0] = "GLOBAL"
	akey := db.Key{Comp: ca}
	entry, err := inParams.d.GetEntry(&ts, akey)
	if entry.Has("unicast-multicast") {
		unicast_multicast = entry.Get("unicast-multicast")
	}

	if unicast_multicast == "multicast" {
		return res_map, tlerr.InvalidArgsError{Format: "master-table is not needed in with multicast transport"}
	}

	if outval != "" {
		addresses := strings.Split(outval, ",")
		var prev_tmp E_Ptp_AddressTypeEnumeration
		var tmp E_Ptp_AddressTypeEnumeration
		var first bool
		first = true
		for _, address := range addresses {
			tmp = check_address(address)
			if PTP_ADDRESSTYPE_UNKNOWN == tmp {
				return res_map, tlerr.InvalidArgsError{Format: "Invalid value passed for unicast-table"}
			}
			if !first && tmp != prev_tmp {
				return res_map, tlerr.InvalidArgsError{Format: "Mismatched addresses passed in unicast-table"}
			}
			prev_tmp = tmp
			first = false
		}
	}

	log.Info("YangToDb_ptp_unicast_table_xfmr outval: ", outval, " field: ", field)
	res_map[field] = outval
	return res_map, nil
}

var YangToDb_route_map_action_policy_result_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {

	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		return res_map, err
	}

	if inParams.oper == DELETE {
		res_map["route_operation"] = ""
		return res_map, nil
	}

	action, _ := inParams.param.(ocbinds.E_OpenconfigRoutingPolicy_PolicyResultType)
	log.Info("YangToDb_route_map_action_policy_result_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " route-operation: ", action)
	if action == ocbinds.OpenconfigRoutingPolicy_PolicyResultType_ACCEPT_ROUTE {
		res_map["route_operation"] = "permit"
	} else if action == ocbinds.OpenconfigRoutingPolicy_PolicyResultType_REJECT_ROUTE {
		res_map["route_operation"] = "deny"
	}
	return res_map, err
}

var YangToDb_route_map_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	rmap := make(map[string]string)
	var err error

	log.Info("YangToDb_route_map_field_xfmr")
	rmap["NULL"] = "NULL"

	return rmap, err
}

var YangToDb_route_map_match_protocol_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {

	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		return res_map, err
	}

	if inParams.oper == DELETE {
		res_map["match_protocol"] = ""
		return res_map, nil
	}

	protocol, _ := inParams.param.(ocbinds.E_OpenconfigPolicyTypes_INSTALL_PROTOCOL_TYPE)
	log.Info("YangToDb_route_map_match_protocol_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " protocol: ", protocol)
	switch protocol {
	case ocbinds.OpenconfigPolicyTypes_INSTALL_PROTOCOL_TYPE_BGP:
		res_map["match_protocol"] = "bgp"
	case ocbinds.OpenconfigPolicyTypes_INSTALL_PROTOCOL_TYPE_DIRECTLY_CONNECTED:
		res_map["match_protocol"] = "connected"
	case ocbinds.OpenconfigPolicyTypes_INSTALL_PROTOCOL_TYPE_ISIS:
		res_map["match_protocol"] = "isis"
	case ocbinds.OpenconfigPolicyTypes_INSTALL_PROTOCOL_TYPE_OSPF:
		res_map["match_protocol"] = "ospf"
	case ocbinds.OpenconfigPolicyTypes_INSTALL_PROTOCOL_TYPE_OSPF3:
		res_map["match_protocol"] = "ospf3"
	case ocbinds.OpenconfigPolicyTypes_INSTALL_PROTOCOL_TYPE_STATIC:
		res_map["match_protocol"] = "static"
	default:
	}
	return res_map, err
}

var YangToDb_route_map_match_set_options_restrict_type_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {

	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		return res_map, err
	}
	action, _ := inParams.param.(ocbinds.E_OpenconfigRoutingPolicy_MatchSetOptionsRestrictedType)
	log.Info("YangToDb_route_map_match_set_options_restrict_type_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " match-set-option: ", action)
	if action != ocbinds.OpenconfigRoutingPolicy_MatchSetOptionsRestrictedType_ANY {
		err = errors.New("Invalid match set option")
		return res_map, err
	}
	return res_map, err
}

var YangToDb_route_map_match_set_options_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {

	res_map := make(map[string]string)
	var err error
	if inParams.param == nil {
		return res_map, err
	}
	action, _ := inParams.param.(ocbinds.E_OpenconfigRoutingPolicy_MatchSetOptionsType)
	log.Info("YangToDb_route_map_match_set_options_xfmr: ", inParams.ygRoot, " Xpath: ", inParams.uri, " match-set-option: ", action)
	if action != ocbinds.OpenconfigRoutingPolicy_MatchSetOptionsType_ANY {
		err = errors.New("Invalid match set option")
		return res_map, err
	}
	return res_map, err
}

var YangToDb_route_map_stmt_field_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	rmap := make(map[string]string)
	var err error

	log.Info("YangToDb_route_map_stmt_field_xfmr")
	rmap["NULL"] = "NULL"

	return rmap, err
}

var YangToDb_route_table_addr_family_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_sag_ipv4_enable_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	enabled, _ := inParams.param.(*bool)
	var enStr string
	if *enabled == true {
		enStr = "enable"
	} else {
		enStr = "disable"
	}
	res_map["IPv4"] = enStr

	return res_map, nil
}

var YangToDb_sag_ipv6_enable_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	enabled, _ := inParams.param.(*bool)
	var enStr string
	if *enabled == true {
		enStr = "enable"
	} else {
		enStr = "disable"
	}
	res_map["IPv6"] = enStr

	return res_map, nil
}

var YangToDb_server_name_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	if log.V(3) {
		log.Info("YangToDb_server_name_xfmr: root: ", inParams.ygRoot,
			", uri: ", inParams.uri)
	}

	res_map := make(map[string]string)
	res_map["NULL"] = "NULL"
	return res_map, nil
}

var YangToDb_vlan_nd_suppress_fld_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)

	pathInfo := NewPathInfo(inParams.uri)
	vlanIdStr := pathInfo.Var("name")

	if !strings.HasPrefix(vlanIdStr, "Vlan") {
		return res_map, tlerr.InvalidArgs("Invalid key: %v", vlanIdStr)
	}
	log.Infof("YangToDb_vlan_nd_suppress_fld_xfmr: Params: %v", inParams.param)

	if inParams.param != nil {
		val, _ := inParams.param.(ocbinds.E_OpenconfigNetworkInstance_NetworkInstances_NetworkInstance_NeighbourSuppress_Config_ArpAndNdSuppress)
		if val == ocbinds.OpenconfigNetworkInstance_NetworkInstances_NetworkInstance_NeighbourSuppress_Config_ArpAndNdSuppress_enable {
			res_map["suppress"] = "on"
		}
	}

	return res_map, nil
}

var YangToDb_vxlan_state_peer_tunnel_type_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	if log.V(3) {
		log.Info("Entering YangToDb_vxlan_state_peer_tunnel_type_xfmr ===> ")
	}
	return res_map, err
}

var YangToDb_vxlan_state_tunnel_info_tunnel_type_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error
	if log.V(3) {
		log.Info("Entering YangToDb_vxlan_state_tunnel_info_tunnel_type_xfmr ===> ")
	}
	return res_map, err
}

var DbToYang_acl_entry_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	entry_key := inParams.key
	log.Info("DbToYang_acl_entry_key_xfmr: ", entry_key)

	key := strings.Split(entry_key, "|")
	if len(key) < 2 {
		err = errors.New("Invalid key for acl entries.")
		log.Info("Invalid Keys for acl enmtries", entry_key)
		return rmap, err
	}

	dbAclRule := key[1]
	seqId := strings.Replace(dbAclRule, "RULE_", "", 1)
	rmap["sequence-id"], _ = strconv.ParseFloat(seqId, 64)
	return rmap, err
}

var DbToYang_acl_set_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	var aclNameStr string
	var aclTypeStr string
	aclkey := inParams.key
	log.Info("DbToYang_acl_set_key_xfmr: ", aclkey)
	if strings.Contains(aclkey, "_"+OPENCONFIG_ACL_TYPE_IPV4) {
		aclNameStr = strings.Replace(aclkey, "_"+OPENCONFIG_ACL_TYPE_IPV4, "", 1)
		aclTypeStr = "ACL_IPV4"
	} else if strings.Contains(aclkey, "_"+OPENCONFIG_ACL_TYPE_IPV6) {
		aclNameStr = strings.Replace(aclkey, "_"+OPENCONFIG_ACL_TYPE_IPV6, "", 1)
		aclTypeStr = "ACL_IPV6"
	} else if strings.Contains(aclkey, "_"+OPENCONFIG_ACL_TYPE_L2) {
		aclNameStr = strings.Replace(aclkey, "_"+OPENCONFIG_ACL_TYPE_L2, "", 1)
		aclTypeStr = "ACL_L2"
	} else {
		err = errors.New("Invalid key for acl set.")
		log.Info("Invalid Keys for acl acl set", aclkey)
	}
	rmap["name"] = aclNameStr
	rmap["type"] = aclTypeStr
	return rmap, err
}

var DbToYang_auth_method_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	if log.V(3) {
		log.Info("DbToYang_auth_method_xfmr: root: ", inParams.ygRoot,
			", uri: ", inParams.uri)
	}

	var err error
	rmap := make(map[string]interface{})
	data := (*inParams.dbDataMap)[inParams.curDb]
	db_auth_method, ok := data["AAA"][inParams.key].Field["login"]
	if ok {
		log.Info("DbToYang_auth_method_xfmr: db_auth_method: ", db_auth_method)
		rmap["authentication-method"] = strings.Split(db_auth_method, ",")
	}
	return rmap, err
}

var DbToYang_bgp_af_nbr_proto_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var afName string
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_af_nbr_proto_tbl_key_xfmr: ", entry_key)

	nbrAfKey := strings.Split(entry_key, "|")

	switch nbrAfKey[2] {
	case "ipv4_unicast":
		afName = "IPV4_UNICAST"
	case "ipv6_unicast":
		afName = "IPV6_UNICAST"
	case "l2vpn_evpn":
		afName = "L2VPN_EVPN"
	default:
		return rmap, nil
	}

	rmap["afi-safi-name"] = afName

	return rmap, nil
}

var DbToYang_bgp_af_nbr_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var afName string
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_af_nbr_tbl_key: ", entry_key)

	nbrAfKey := strings.Split(entry_key, "|")

	switch nbrAfKey[2] {
	case "ipv4_unicast":
		afName = "IPV4_UNICAST"
	case "ipv6_unicast":
		afName = "IPV6_UNICAST"
	case "l2vpn_evpn":
		afName = "L2VPN_EVPN"
	default:
		return rmap, nil
	}

	rmap["afi-safi-name"] = afName

	return rmap, nil
}

var DbToYang_bgp_af_pgrp_proto_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_af_pgrp_proto_tbl_key_xfmr: ", entry_key)

	afPgrpKey := strings.Split(entry_key, "|")
	afName := ""

	switch afPgrpKey[2] {
	case "ipv4_unicast":
		afName = "IPV4_UNICAST"
	case "ipv6_unicast":
		afName = "IPV6_UNICAST"
	case "l2vpn_evpn":
		afName = "L2VPN_EVPN"
	}

	rmap["afi-safi-name"] = afName

	return rmap, nil
}

var DbToYang_bgp_af_pgrp_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_af_pgrp_tbl_key: ", entry_key)

	afPgrpKey := strings.Split(entry_key, "|")
	afName := ""

	switch afPgrpKey[2] {
	case "ipv4_unicast":
		afName = "IPV4_UNICAST"
	case "ipv6_unicast":
		afName = "IPV6_UNICAST"
	case "l2vpn_evpn":
		afName = "L2VPN_EVPN"
	}

	rmap["afi-safi-name"] = afName

	return rmap, nil
}

var DbToYang_bgp_dyn_neigh_listen_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_dyn_neigh_listen_key_xfmr: ", entry_key)

	dynKey := strings.Split(entry_key, "|")

	rmap["prefix"] = dynKey[1]

	log.Info("DbToYang_bgp_dyn_neigh_listen_key_xfmr: rmap:", rmap)
	return rmap, nil
}

var DbToYang_bgp_evpn_rt_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_evpn_rt_key_xfmr: ", entry_key)

	routeTargetKey := strings.Split(entry_key, "|")
	routeTarget := routeTargetKey[2]

	rmap["route-target"] = routeTarget

	return rmap, nil
}

var DbToYang_bgp_evpn_vni_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_evpn_vni_key_xfmr: ", entry_key)

	vniNumberKey := strings.Split(entry_key, "|")
	vniNumber, _ := strconv.ParseFloat(vniNumberKey[2], 64)

	rmap["vni-number"] = vniNumber

	log.Info("Rmap", rmap)

	return rmap, nil
}

var DbToYang_bgp_evpn_vni_rt_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_evpn_vni_rt_key_xfmr: ", entry_key)

	vniRouteTargetKey := strings.Split(entry_key, "|")
	routeTarget := vniRouteTargetKey[3]

	rmap["route-target"] = routeTarget

	return rmap, nil
}

var DbToYang_bgp_gbl_afi_safi_addr_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_gbl_afi_safi_addr_key_xfmr: ", entry_key)

	mpathKey := strings.Split(entry_key, "|")

	rmap["prefix"] = mpathKey[2]

	log.Info("DbToYang_bgp_gbl_afi_safi_addr_key_xfmr: rmap:", rmap)
	return rmap, nil
}

var DbToYang_bgp_gbl_afi_safi_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_gbl_afi_safi_key_xfmr: ", entry_key)

	mpathKey := strings.Split(entry_key, "|")
	afi := ""

	switch mpathKey[1] {
	case "ipv4_unicast":
		afi = "IPV4_UNICAST"
	case "ipv6_unicast":
		afi = "IPV6_UNICAST"
	case "l2vpn_evpn":
		afi = "L2VPN_EVPN"
	default:
		return rmap, nil
	}

	rmap["afi-safi-name"] = afi

	log.Info("DbToYang_bgp_gbl_afi_safi_key_xfmr: rmap:", rmap)
	return rmap, nil
}

var DbToYang_bgp_gbl_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	entry_key := inParams.key
	log.Info("DbToYang_bgp_gbl_tbl_key: ", entry_key)

	rmap["name"] = entry_key
	return rmap, err
}

var DbToYang_bgp_nbr_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_nbr_tbl_key: ", entry_key)

	nbrKey := strings.Split(entry_key, "|")
	nbrName := nbrKey[1]

	rmap["neighbor-address"] = nbrName

	return rmap, nil
}

var DbToYang_bgp_pgrp_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_bgp_pgrp_tbl_key: ", entry_key)

	pgrpKey := strings.Split(entry_key, "|")
	pgrpName := pgrpKey[1]

	rmap["peer-group-name"] = pgrpName

	return rmap, nil
}

var DbToYang_global_sg_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_global_sg_key_xfmr: ", inParams.key)

	return res_map, err
}

var DbToYang_igmp_snooping_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	fmt.Println("DbToYang_igmp_snooping_key_xfmr ==> ", inParams)
	rmap := make(map[string]interface{})
	return rmap, nil
}

var DbToYang_igmp_snooping_mrouter_config_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	fmt.Println("DbToYang_igmp_snooping_mrouter_config_key_xfmr ==> ", inParams)
	rmap := make(map[string]interface{})
	return rmap, nil
}

var DbToYang_igmp_snooping_mrouter_state_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	fmt.Println("DbToYang_igmp_snooping_mrouter_state_key_xfmr ==> ", inParams)
	rmap := make(map[string]interface{})
	return rmap, nil
}

var DbToYang_igmp_snooping_static_group_config_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	fmt.Println("DbToYang_igmp_snooping_static_group_config_key_xfmr ==> ", inParams)
	rmap := make(map[string]interface{})
	return rmap, nil
}

var DbToYang_igmp_snooping_static_member_state_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	fmt.Println("DbToYang_igmp_snooping_static_member_state_key_xfmr ==> ", inParams)
	rmap := make(map[string]interface{})
	return rmap, nil
}

var DbToYang_intf_counters_key KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	return rmap, err
}

var DbToYang_intf_subintfs_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	rmap["index"] = 0
	return rmap, err
}

var DbToYang_intf_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	log.Info("Entering DbToYang_intf_tbl_key_xfmr")
	res_map := make(map[string]interface{})

	log.Info("Interface Name = ", inParams.key)
	res_map["name"] = inParams.key
	return res_map, nil
}

var DbToYang_napt_twice_mapping_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	var key_sep string
	nat_key := inParams.key
	key_sep = ":"

	key := strings.Split(nat_key, key_sep)
	if len(key) < 5 {
		err = errors.New("Invalid key for NAPT mapping entry.")
		log.Info("Invalid Keys, NAPT Mapping entry", nat_key)
		return rmap, err
	}
	oc_protocol := findProtocolByValue(protocol_map, key[0])

	rmap["protocol"] = oc_protocol
	rmap["src-ip"] = key[1]
	rmap["src-port"], _ = strconv.Atoi(key[2])
	rmap["dst-ip"] = key[3]
	rmap["dst-port"], _ = strconv.Atoi(key[4])

	log.Info("DbToYang_nat_twice_mapping_key_xfmr : - ", rmap)
	return rmap, err
}

var DbToYang_nat_binding_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	key := inParams.key
	rmap["name"] = key
	log.Info("YangToDb_nat_binding_key_xfmr : - ", rmap)
	return rmap, err
}

var DbToYang_nat_global_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	return rmap, err
}

var DbToYang_nat_instance_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	rmap[INSTANCE_ID] = 0
	return rmap, err
}

var DbToYang_nat_mapping_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	nat_key := inParams.key
	rmap["external-address"] = nat_key
	log.Info("DbToYang_nat_mapping_key_xfmr : - ", rmap)
	return rmap, err
}

var DbToYang_nat_pool_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	key := inParams.key
	rmap["pool-name"] = key
	log.Info("YangToDb_nat_pool_key_xfmr : - ", rmap)
	return rmap, err
}

var DbToYang_nat_twice_mapping_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	nat_key := inParams.key
	var key_sep string
	key_sep = ":"

	key := strings.Split(nat_key, key_sep)
	if len(key) < 2 {
		err = errors.New("Invalid key for NAT mapping entry.")
		log.Info("Invalid Keys, NAT Mapping entry", nat_key)
		return rmap, err
	}

	rmap["src-ip"] = key[0]
	rmap["dst-ip"] = key[1]
	log.Info("DbToYang_nat_twice_mapping_key_xfmr : - ", rmap)
	return rmap, err
}

var DbToYang_nat_zone_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	key := inParams.key
	rmap["zone-id"], _ = strconv.Atoi(key)
	log.Info("YangToDb_nat_zone_key_xfmr : - ", rmap)
	return rmap, err
}

var DbToYang_neigh_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error

	log.Info("DbToYang_neigh_tbl_key_xfmr - inParams: ", inParams)
	mykey := strings.Split(inParams.key, ":")

	rmap["ip"] = inParams.key[(len(mykey[0]) + 1):]
	return rmap, err
}

var DbToYang_network_instance_description_field_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_network_instance_description_field_xfmr")

	return res_map, err
}

var DbToYang_network_instance_enabled_addr_family_field_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_network_instance_enabled_addr_fam_field_xfmr")

	return res_map, err
}

var DbToYang_network_instance_mtu_field_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_network_instance_mtu_field_xfmr")

	return res_map, err
}

var DbToYang_network_instance_name_field_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_network_instance_name_field_xfmr")

	if inParams.key != "" {
		if ((inParams.key == "default") ||
			(strings.HasPrefix(inParams.key, "Vrf"))) &&
			(isVrfDbTbl(inParams) == true) {
			res_map["name"] = inParams.key
		} else if (strings.HasPrefix(inParams.key, "vrf_global")) &&
			(isMgmtVrfDbTbl(inParams) == true) {
			res_map["name"] = "mgmt"
		}

	} else {
		log.Info("DbToYang_network_instance_name_field_xfmr, empty key")
	}

	return res_map, err
}

var DbToYang_network_instance_protocol_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	dynKey := strings.Split(entry_key, "|")
	rmap["identifier"] = dynKey[0]
	rmap["name"] = dynKey[1]
	return rmap, nil
}

var DbToYang_network_instance_route_distinguisher_field_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_network_instance_route_distinguisher_field_xfmr")

	return res_map, err
}

var DbToYang_network_instance_router_id_field_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_network_instance_router_id_field_xfmr")

	return res_map, err
}

var DbToYang_network_instance_table_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_network_instance_table_key_xfmr: ", inParams.key)

	if inParams.key != "" {
		if (inParams.key == "default") || (strings.HasPrefix(inParams.key, "Vrf")) {
			res_map["name"] = inParams.key
		} else if strings.HasPrefix(inParams.key, "vrf_global") {
			res_map["name"] = "mgmt"
		}
	} else {
		log.Info("DbToYang_network_instance_table_key_xfmr, empty key")
	}

	return res_map, err
}

var DbToYang_network_instance_type_field_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})
	var err error

	log.Info("DbToYang_network_instance_type_field_xfmr")

	if ((inParams.key == "vrf_global") && (isMgmtVrfDbTbl(inParams) == true)) ||
		((strings.HasPrefix(inParams.key, "Vrf")) && (isVrfDbTbl(inParams) == true)) {
		res_map["type"] = "L3VRF"
	} else if (inParams.key == "default") && (isVrfDbTbl(inParams) == true) {
		res_map["type"] = "DEFAULT_INSTANCE"
	} else if strings.HasPrefix(inParams.key, "Vlan") {
		res_map["type"] = "L2L3"
	}

	return res_map, err
}

var DbToYang_nw_inst_vxlan_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	if log.V(3) {
		log.Info("DbToYang_nw_inst_vxlan_key_xfmr ==> entry_key  ===> ", entry_key)
	}

	if entry_key != "" {
		keyList := strings.Split(entry_key, "|")
		if log.V(3) {
			log.Info("DbToYang_nw_inst_vxlan_key_xfmr ==> keyList  ===> ", keyList)
		}

		rmap["source-nve"] = keyList[0]
		mapNameList := strings.Split(keyList[1], "_")

		vniId, _ := strconv.ParseInt(mapNameList[1], 10, 64)
		rmap["vni-id"] = uint32(vniId)
	}

	if log.V(3) {
		log.Info("DbToYang_nw_inst_vxlan_key_xfmr ==> rmap  ===> ", rmap)
	}

	return rmap, nil
}

var DbToYang_prefix_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	key := inParams.key

	log.Info("DbToYang_prefix_key_xfmr: ", key)

	prefixTblKey := strings.Split(key, "|")
	ipPrefix := prefixTblKey[1]
	masklenrange := prefixTblKey[2]

	rmap["ip-prefix"] = ipPrefix
	rmap["masklength-range"] = masklenrange

	log.Info("DbToYang_prefix_key_xfmr:  ipPrefix ", ipPrefix, "masklength-range ", masklenrange)

	return rmap, nil
}

var DbToYang_ptp_entry_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	log.Info("DbToYang_ptp_entry_key_xfmr root, uri: ", inParams.ygRoot, inParams.uri)

	return rmap, err
}

var DbToYang_ptp_global_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	log.Info("DbToYang_ptp_global_key_xfmr root, uri: ", inParams.ygRoot, inParams.uri)
	rmap["instance-number"] = 0
	return rmap, err
}

var DbToYang_ptp_port_entry_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	var port_num string
	var is_vlan bool

	log.Info("DbToYang_ptp_port_entry_key_xfmr root, uri: ", inParams.ygRoot, inParams.uri)
	entry_key := inParams.key
	log.Info("DbToYang_ptp_port_entry_key_xfmr: ", entry_key)

	portName := entry_key
	if strings.Contains(portName, "Ethernet") {
		port_num = strings.Replace(portName, "GLOBAL|Ethernet", "", 1)
		is_vlan = false
	} else {
		port_num = strings.Replace(portName, "GLOBAL|Vlan", "", 1)
		is_vlan = true
	}

	port_num_int, _ := strconv.ParseInt(port_num, 10, 16)
	if is_vlan {
		port_num_int += 1000
	}
	rmap["port-number"] = port_num_int
	log.Info("DbToYang_ptp_port_entry_key_xfmr port-number: ", port_num)
	return rmap, err
}

var DbToYang_ptp_tcport_entry_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	var err error
	log.Info("DbToYang_ptp_tcport_entry_key_xfmr root, uri: ", inParams.ygRoot, inParams.uri)

	entry_key := inParams.key
	log.Info("DbToYang_ptp_tcport_entry_key_xfmr: ", entry_key)

	portName := entry_key
	port_num := strings.Replace(portName, "Ethernet", "", 1)
	rmap["port-number"], _ = strconv.ParseInt(port_num, 10, 16)
	log.Info("DbToYang_ptp_tcport_entry_key_xfmr port-number: ", port_num)
	return rmap, err
}

var DbToYang_route_table_conn_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_route_table_conn_key_xfmr: ", entry_key)

	key := strings.Split(entry_key, "|")
	source := key[1]
	destination := key[2]
	family := key[3]

	var src_proto string
	var dst_proto string
	var af string

	if source == "connected" {
		src_proto = "DIRECTLY_CONNECTED"
	} else if source == "static" {
		src_proto = "STATIC"
	} else if source == "ospf" {
		src_proto = "OSPF"
	} else if source == "ospf3" {
		src_proto = "OSPF3"
	} else {
		return rmap, errors.New("Unsupported src protocol " + source)
	}

	if destination == "bgp" {
		dst_proto = "BGP"
	} else {
		return rmap, errors.New("Unsupported dst protocol " + destination)
	}

	if family == "ipv4" {
		af = "IPV4"
	} else if family == "ipv6" {
		af = "IPV6"
	} else {
		return rmap, errors.New("Unsupported family " + family)
	}
	rmap["src-protocol"] = src_proto
	rmap["dst-protocol"] = dst_proto
	rmap["address-family"] = af

	return rmap, nil
}

var DbToYang_sag_global_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_sag_global_key_xfmr: ", entry_key)

	rmap["name"] = "default"

	log.Info("DbToYang_sag_global_key_xfmr")

	return rmap, nil
}

var DbToYang_sag_ipv4_if_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_sag_ipv4_if_key_xfmr: ", entry_key)

	sagKey := strings.Split(entry_key, "|")
	ifname := sagKey[1]

	rmap["name"] = ifname
	rmap["index"] = 0

	log.Info("DbToYang_sag_ipv4_if_key_xfmr:  ifname ", ifname)

	return rmap, nil
}

var DbToYang_sag_ipv6_if_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	entry_key := inParams.key
	log.Info("DbToYang_sag_ipv6_if_key_xfmr: ", entry_key)

	sagKey := strings.Split(entry_key, "|")
	ifname := sagKey[1]

	rmap["name"] = ifname
	rmap["index"] = 0

	log.Info("DbToYang_sag_ipv6_if_key_xfmr:  ifname ", ifname)

	return rmap, nil
}

var DbToYang_server_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{}, 1)
	var err error

	log.Info("DbToYang_server_key_xfmr: ", inParams.key)

	res_map["address"] = inParams.key

	return res_map, err
}

var DbToYang_sys_config_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	rmap := make(map[string]interface{})
	log.Info("DbToYang_sys_config_key_xfmr root, uri: ", inParams.ygRoot, inParams.uri)
	return rmap, nil
}

var DbToYang_vlan_nd_suppress_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})

	log.Info("Vlan Name = ", inParams.key)
	res_map["name"] = inParams.key
	return res_map, nil
}

var DbToYang_vxlan_state_tunnel_info_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	log.Info("DbToYang_vxlan_state_tunnel_info_key_xfmr ==> inParams.key => ", inParams.key)

	pathOrigInfo := NewPathInfo(inParams.requestUri)
	peerIpOrigStr := pathOrigInfo.Var("peer-ip")

	log.Info("DbToYang_vxlan_state_tunnel_info_key_xfmr ==> peerIpOrigStr => ", peerIpOrigStr)

	rmap := make(map[string]interface{})
	if inParams.key != "" {

		keyListTmp := strings.Split(inParams.key, "EVPN_")
		if peerIpOrigStr != "" && peerIpOrigStr != keyListTmp[1] {
			log.Info("DbToYang_vxlan_state_tunnel_info_key_xfmr ==> returning ERROR => peer-ip not exist => ", peerIpOrigStr)
			return rmap, tlerr.NotFound("Resource Not Found")
		}
		if log.V(3) {
			log.Info("DbToYang_vxlan_state_tunnel_info_key_xfmr ==> keyListTmp => ", keyListTmp)
		}
		if len(keyListTmp) == 2 {
			rmap["peer-ip"] = keyListTmp[1]
		}
	}

	log.Info("DbToYang_vxlan_state_tunnel_info_key_xfmr ==> returning RESTULT map rmap => ", rmap)

	return rmap, nil
}

var DbToYang_vxlan_vni_state_peer_info_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr Entering ==> ", inParams)

	rmap := make(map[string]interface{})

	if inParams.key != "" {

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> inParams.key => ", inParams.key)

		evpnKeyList := strings.Split(inParams.key, ":")

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> evpnKeyList => ", evpnKeyList)

		var VXLAN_TUNNEL_TABLE_TS *db.TableSpec = &db.TableSpec{Name: "VXLAN_TUNNEL"}
		tunnelTblData, err := configDbPtr.GetTable(VXLAN_TUNNEL_TABLE_TS)
		if err != nil {
			log.Error("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> returning ERROR => ", err)
			return rmap, tlerr.NotFound("Resource Not Found")
		}

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> tunnelTblData ==> ", tunnelTblData)

		tunnelKeys, err := tunnelTblData.GetKeys()
		if err != nil || len(tunnelKeys) != 1 {
			log.Error("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> returning ERROR => ", err)
			return rmap, tlerr.NotFound("Resource Not Found")
		}

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> tunnelKeys ==> ", tunnelKeys)

		tunnelEntry, err := tunnelTblData.GetEntry(tunnelKeys[0])

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> tunnelEntry ==> ", tunnelEntry)

		if err != nil || len(tunnelEntry.Field) == 0 {
			log.Error("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> returning ERROR")
			return rmap, tlerr.NotFound("Resource Not Found")
		}

		var VXLAN_TUNNEL_MAP_TABLE_TS *db.TableSpec = &db.TableSpec{Name: "VXLAN_TUNNEL_MAP"}

		tunnelMapKeyStr := tunnelKeys[0].Comp[0] + "|map_" + "*_" + evpnKeyList[0]

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> tunnelMapKeyStr ==> ", tunnelMapKeyStr)

		tblVxlanMapKeys, err := configDbPtr.GetKeysPattern(VXLAN_TUNNEL_MAP_TABLE_TS, db.Key{[]string{tunnelMapKeyStr}})

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> tblVxlanMapKeys ==> ", tblVxlanMapKeys)

		if len(tblVxlanMapKeys) != 1 {
			log.Error("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> returning ERROR")
			return rmap, tlerr.NotFound("Resource Not Found")
		}

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> tblVxlanMapKeys ==> ", tblVxlanMapKeys)
		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> tblVxlanMapKeys[1].Comp[0] ==> ", tblVxlanMapKeys[0].Comp[1])

		tunnelMapList := strings.Split(tblVxlanMapKeys[0].Comp[1], "_")

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> tunnelMapList ==> ", tunnelMapList)

		if len(tunnelMapList) != 3 {
			log.Error("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> returning ERROR")
			return rmap, tlerr.NotFound("Resource Not Found")
		}

		vniIdInt, _ := strconv.ParseInt(tunnelMapList[1], 10, 64)
		rmap["vni-id"] = uint32(vniIdInt)
		rmap["source-ip"] = tunnelEntry.Field["src_ip"]
		rmap["peer-ip"] = evpnKeyList[1]

		log.Info("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> final result map ==> ", rmap)

		return rmap, nil
	} else {
		log.Error("DbToYang_vxlan_vni_state_peer_info_key_xfmr ==> returning ERROR ==> Resource Not Found with empty result => ", rmap)
		return rmap, tlerr.NotFound("Resource Not Found")
	}
}

var YangToDb_acl_entry_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var entry_key string
	var err error
	var oc_aclType ocbinds.E_OpenconfigAcl_ACL_TYPE
	log.Info("YangToDb_acl_entry_key_xfmr: ", inParams.ygRoot, inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	if len(pathInfo.Vars) < 3 {
		err = errors.New("Invalid xpath, key attributes not found")
		return entry_key, err
	}

	oc_aclType, err = getAclTypeOCEnumFromName(pathInfo.Var("type"))
	if err != nil {
		err = errors.New("OC Acl type name to OC Acl Enum failed")
		return entry_key, err
	}

	aclkey := getAclKeyStrFromOCKey(pathInfo.Var("name"), oc_aclType)
	var rulekey string
	if strings.Contains(pathInfo.Template, "/acl-entry{sequence-id}") {
		rulekey = "RULE_" + pathInfo.Var("sequence-id")
	}
	entry_key = aclkey + "|" + rulekey

	log.Info("YangToDb_acl_entry_key_xfmr - entry_key : ", entry_key)

	return entry_key, err
}

var YangToDb_acl_set_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var aclkey string
	var err error
	var oc_aclType ocbinds.E_OpenconfigAcl_ACL_TYPE
	log.Info("YangToDb_acl_set_key_xfmr: ", inParams.ygRoot, inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	if len(pathInfo.Vars) < 2 {
		err = errors.New("Invalid xpath, key attributes not found")
		return aclkey, err
	}

	oc_aclType, err = getAclTypeOCEnumFromName(pathInfo.Var("type"))
	if err != nil {
		err = errors.New("OC Acl type name to OC Acl Enum failed")
		return aclkey, err
	}

	aclkey = getAclKeyStrFromOCKey(pathInfo.Var("name"), oc_aclType)
	log.Info("YangToDb_acl_set_key_xfmr - acl_set_key : ", aclkey)

	return aclkey, err
}

var YangToDb_auth_set_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	return "authentication", nil
}

var YangToDb_bgp_af_nbr_proto_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error
	var vrfName string

	log.Info("YangToDb_bgp_af_nbr_proto_tbl_key_xfmr***", inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	vrfName = pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	pNbr := pathInfo.Var("neighbor-address")
	afName := pathInfo.Var("afi-safi-name")

	if len(pathInfo.Vars) < 4 {
		err = errors.New("Invalid Key length")
		log.Info("Invalid Key length", len(pathInfo.Vars))
		return vrfName, err
	}

	if len(vrfName) == 0 {
		err = errors.New("vrf name is missing")
		log.Info("VRF Name is Missing")
		return vrfName, err
	}
	if strings.Contains(bgpId, "BGP") == false {
		err = errors.New("BGP ID is missing")
		log.Info("BGP ID is missing")
		return bgpId, err
	}
	if len(protoName) == 0 {
		err = errors.New("Protocol Name is missing")
		log.Info("Protocol Name is Missing")
		return protoName, err
	}
	if len(pNbr) == 0 {
		err = errors.New("Neighbor missing")
		log.Info("Neighbo Missing")
		return pNbr, err
	}

	if len(afName) == 0 {
		err = errors.New("AFI SAFI is missing")
		log.Info("AFI SAFI is Missing")
		return afName, err
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afName = "ipv4_unicast"
		if strings.Contains(inParams.uri, "ipv6-unicast") ||
			strings.Contains(inParams.uri, "l2vpn-evpn") {
			err = errors.New("IPV4_UNICAST supported only on ipv4-config container")
			log.Info("IPV4_UNICAST supported only on ipv4-config container: ", afName)
			return afName, err
		}
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afName = "ipv6_unicast"
		if strings.Contains(inParams.uri, "ipv4-unicast") ||
			strings.Contains(inParams.uri, "l2vpn-evpn") {
			err = errors.New("IPV6_UNICAST supported only on ipv6-config container")
			log.Info("IPV6_UNICAST supported only on ipv6-config container: ", afName)
			return afName, err
		}
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afName = "l2vpn_evpn"
		if strings.Contains(inParams.uri, "ipv6-unicast") ||
			strings.Contains(inParams.uri, "ipv4-unicast") {
			err = errors.New("L2VPN_EVPN supported only on l2vpn-evpn container")
			log.Info("L2VPN_EVPN supported only on l2vpn-evpn container: ", afName)
			return afName, err
		}
	} else {
		err = errors.New("Unsupported AFI SAFI")
		log.Info("Unsupported AFI SAFI ", afName)
		return afName, err
	}

	log.Info("URI VRF ", vrfName)
	log.Info("URI Nbr ", pNbr)
	log.Info("URI AFI SAFI ", afName)

	var nbrAfKey string

	nbrAfKey = vrfName + "|" + pNbr + "|" + afName

	log.Info("YangToDb_bgp_af_nbr_proto_tbl_key_xfmr: nbrAfKey:", nbrAfKey)
	return nbrAfKey, nil
}

var YangToDb_bgp_af_nbr_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error
	var vrfName string

	log.Info("YangToDb_bgp_af_nbr_tbl_key_xfmr ***", inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	vrfName = pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	pNbr := pathInfo.Var("neighbor-address")
	afName := pathInfo.Var("afi-safi-name")

	if len(pathInfo.Vars) < 4 {
		err = errors.New("Invalid Key length")
		log.Info("Invalid Key length", len(pathInfo.Vars))
		return vrfName, err
	}

	if len(vrfName) == 0 {
		err = errors.New("vrf name is missing")
		log.Info("VRF Name is Missing")
		return vrfName, err
	}
	if strings.Contains(bgpId, "BGP") == false {
		err = errors.New("BGP ID is missing")
		log.Info("BGP ID is missing")
		return bgpId, err
	}
	if len(protoName) == 0 {
		err = errors.New("Protocol Name is missing")
		log.Info("Protocol Name is Missing")
		return protoName, err
	}
	if len(pNbr) == 0 {
		err = errors.New("Neighbor is missing")
		log.Info("Neighbor is Missing")
		return pNbr, err
	}

	if len(afName) == 0 {
		err = errors.New("AFI SAFI is missing")
		log.Info("AFI SAFI is Missing")
		return afName, err
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afName = "ipv4_unicast"
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afName = "ipv6_unicast"
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afName = "l2vpn_evpn"
	} else {
		err = errors.New("Unsupported AFI SAFI")
		log.Info("Unsupported AFI SAFI ", afName)
		return afName, err
	}

	log.Info("URI VRF ", vrfName)
	log.Info("URI Nbr ", pNbr)
	log.Info("URI AFI SAFI ", afName)

	var nbrAfKey string

	nbrAfKey = vrfName + "|" + pNbr + "|" + afName

	log.Info("YangToDb_bgp_af_nbr_tbl_key_xfmr: afPgrpKey:", nbrAfKey)
	return nbrAfKey, nil
}

var YangToDb_bgp_af_pgrp_proto_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error
	var vrfName string

	log.Info("YangToDb_bgp_af_pgrp_proto_tbl_key_xfmr***", inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	vrfName = pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	pGrpName := pathInfo.Var("peer-group-name")
	afName := pathInfo.Var("afi-safi-name")

	if len(pathInfo.Vars) < 4 {
		err = errors.New("Invalid Key length")
		log.Info("Invalid Key length", len(pathInfo.Vars))
		return vrfName, err
	}

	if len(vrfName) == 0 {
		err = errors.New("vrf name is missing")
		log.Info("VRF Name is Missing")
		return vrfName, err
	}
	if strings.Contains(bgpId, "BGP") == false {
		err = errors.New("BGP ID is missing")
		log.Info("BGP ID is missing")
		return bgpId, err
	}
	if len(protoName) == 0 {
		err = errors.New("Protocol Name is missing")
		log.Info("Protocol Name is Missing")
		return protoName, err
	}
	if len(pGrpName) == 0 {
		err = errors.New("Peer Group Name is missing")
		log.Info("Peer Group Name is Missing")
		return pGrpName, err
	}

	if len(afName) == 0 {
		err = errors.New("AFI SAFI is missing")
		log.Info("AFI SAFI is Missing")
		return pGrpName, err
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afName = "ipv4_unicast"
		if strings.Contains(inParams.uri, "ipv6-unicast") ||
			strings.Contains(inParams.uri, "l2vpn-evpn") {
			err = errors.New("IPV4_UNICAST supported only on ipv4-config container")
			log.Info("IPV4_UNICAST supported only on ipv4-config container: ", afName)
			return afName, err
		}
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afName = "ipv6_unicast"
		if strings.Contains(inParams.uri, "ipv4-unicast") ||
			strings.Contains(inParams.uri, "l2vpn-evpn") {
			err = errors.New("IPV6_UNICAST supported only on ipv6-config container")
			log.Info("IPV6_UNICAST supported only on ipv6-config container: ", afName)
			return afName, err
		}
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afName = "l2vpn_evpn"
		if strings.Contains(inParams.uri, "ipv6-unicast") ||
			strings.Contains(inParams.uri, "ipv4-unicast") {
			err = errors.New("L2VPN_EVPN supported only on l2vpn-evpn container")
			log.Info("L2VPN_EVPN supported only on l2vpn-evpn container: ", afName)
			return afName, err
		}
	} else {
		err = errors.New("Unsupported AFI SAFI")
		log.Info("Unsupported AFI SAFI ", afName)
		return afName, err
	}

	log.Info("URI VRF ", vrfName)
	log.Info("URI Peer Group ", pGrpName)
	log.Info("URI AFI SAFI ", afName)

	var afPgrpKey string

	afPgrpKey = vrfName + "|" + pGrpName + "|" + afName

	log.Info("YangToDb_bgp_af_pgrp_tbl_key_xfmr: afPgrpKey:", afPgrpKey)
	return afPgrpKey, nil
}

var YangToDb_bgp_af_pgrp_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error
	var vrfName string

	log.Info("YangToDb_bgp_af_pgrp_tbl_key_xfmr ***", inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	vrfName = pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	pGrpName := pathInfo.Var("peer-group-name")
	afName := pathInfo.Var("afi-safi-name")

	if len(pathInfo.Vars) < 4 {
		err = errors.New("Invalid Key length")
		log.Info("Invalid Key length", len(pathInfo.Vars))
		return vrfName, err
	}

	if len(vrfName) == 0 {
		err = errors.New("vrf name is missing")
		log.Info("VRF Name is Missing")
		return vrfName, err
	}
	if strings.Contains(bgpId, "BGP") == false {
		err = errors.New("BGP ID is missing")
		log.Info("BGP ID is missing")
		return bgpId, err
	}
	if len(protoName) == 0 {
		err = errors.New("Protocol Name is missing")
		log.Info("Protocol Name is Missing")
		return protoName, err
	}
	if len(pGrpName) == 0 {
		err = errors.New("Peer Group Name is missing")
		log.Info("Peer Group Name is Missing")
		return pGrpName, err
	}

	if len(afName) == 0 {
		err = errors.New("AFI SAFI is missing")
		log.Info("AFI SAFI is Missing")
		return pGrpName, err
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afName = "ipv4_unicast"
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afName = "ipv6_unicast"
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afName = "l2vpn_evpn"
	} else {
		err = errors.New("Unsupported AFI SAFI")
		log.Info("Unsupported AFI SAFI ", afName)
		return afName, err
	}

	log.Info("URI VRF ", vrfName)
	log.Info("URI Peer Group ", pGrpName)
	log.Info("URI AFI SAFI ", afName)

	var afPgrpKey string

	afPgrpKey = vrfName + "|" + pGrpName + "|" + afName

	log.Info("YangToDb_bgp_af_pgrp_tbl_key_xfmr: afPgrpKey:", afPgrpKey)
	return afPgrpKey, nil
}

var YangToDb_bgp_dyn_neigh_listen_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	log.Info("YangToDb_bgp_dyn_neigh_listen_key_xfmr key: ", inParams.uri)

	pathInfo := NewPathInfo(inParams.uri)

	niName := pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	prefix := pathInfo.Var("prefix")

	if len(pathInfo.Vars) < 4 {
		return "", errors.New("Invalid Key length")
	}

	if len(niName) == 0 {
		return "", errors.New("vrf name is missing")
	}

	if strings.Contains(bgpId, "BGP") == false {
		return "", errors.New("BGP ID is missing")
	}

	if len(protoName) == 0 {
		return "", errors.New("Protocol Name is missing")
	}

	key := niName + "|" + prefix

	log.Info("YangToDb_bgp_dyn_neigh_listen_key_xfmr key: ", key)

	return key, nil
}

var YangToDb_bgp_evpn_rt_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error
	var vrfName string

	log.Info("YangToDb_bgp_evpn_rt_key_xfmr ***", inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	vrfName = pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	routeTarget := pathInfo.Var("route-target")
	afName := pathInfo.Var("afi-safi-name")

	if len(pathInfo.Vars) < 4 {
		err = errors.New("Invalid Key length")
		log.Info("Invalid Key length", len(pathInfo.Vars))
		return vrfName, err
	}

	if len(vrfName) == 0 {
		err = errors.New("vrf name is missing")
		log.Info("VRF Name is Missing")
		return vrfName, err
	}
	if strings.Contains(bgpId, "BGP") == false {
		err = errors.New("BGP ID is missing")
		log.Info("BGP ID is missing")
		return bgpId, err
	}
	if len(protoName) == 0 {
		err = errors.New("Protocol Name is missing")
		log.Info("Protocol Name is Missing")
		return protoName, err
	}
	if len(routeTarget) == 0 {
		err = errors.New("routeTarget is missing")
		log.Info("routeTarget is Missing")
		return routeTarget, err
	}

	if len(afName) == 0 {
		err = errors.New("AFI SAFI is missing")
		log.Info("AFI SAFI is Missing")
		return afName, err
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afName = "IPV4_UNICAST"
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afName = "IPV6_UNICAST"
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afName = "L2VPN_EVPN"
	} else {
		err = errors.New("Unsupported AFI SAFI")
		log.Info("Unsupported AFI SAFI ", afName)
		return afName, err
	}

	log.Info("URI VRF ", vrfName)
	log.Info("URI Route Target ", routeTarget)
	log.Info("URI AFI SAFI ", afName)

	var routeTargetKey string

	routeTargetKey = vrfName + "|" + afName + "|" + routeTarget

	log.Info("YangToDb_bgp_evpn_rt_key_xfmr: routeTargetKey:", routeTargetKey)
	return routeTargetKey, nil
}

var YangToDb_bgp_evpn_vni_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error
	var vrfName string

	log.Info("YangToDb_bgp_evpn_vni_key_xfmr ***", inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	vrfName = pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	vniNumber := pathInfo.Var("vni-number")
	afName := pathInfo.Var("afi-safi-name")

	if len(pathInfo.Vars) < 4 {
		err = errors.New("Invalid Key length")
		log.Info("Invalid Key length", len(pathInfo.Vars))
		return vrfName, err
	}

	if len(vrfName) == 0 {
		err = errors.New("vrf name is missing")
		log.Info("VRF Name is Missing")
		return vrfName, err
	}
	if strings.Contains(bgpId, "BGP") == false {
		err = errors.New("BGP ID is missing")
		log.Info("BGP ID is missing")
		return bgpId, err
	}
	if len(protoName) == 0 {
		err = errors.New("Protocol Name is missing")
		log.Info("Protocol Name is Missing")
		return protoName, err
	}
	if len(vniNumber) == 0 {
		err = errors.New("VNI number is missing")
		log.Info("VNI number is Missing")
		return vniNumber, err
	}

	if len(afName) == 0 {
		err = errors.New("AFI SAFI is missing")
		log.Info("AFI SAFI is Missing")
		return afName, err
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afName = "IPV4_UNICAST"
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afName = "IPV6_UNICAST"
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afName = "L2VPN_EVPN"
	} else {
		err = errors.New("Unsupported AFI SAFI")
		log.Info("Unsupported AFI SAFI ", afName)
		return afName, err
	}

	log.Info("URI VRF ", vrfName)
	log.Info("URI VNI NUMBER ", vniNumber)
	log.Info("URI AFI SAFI ", afName)

	var vniTableKey string

	vniTableKey = vrfName + "|" + afName + "|" + vniNumber

	log.Info("YangToDb_bgp_evpn_vni_key_xfmr: vniTableKey:", vniTableKey)
	return vniTableKey, nil
}

var YangToDb_bgp_evpn_vni_rt_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error
	var vrfName string

	log.Info("YangToDb_bgp_evpn_vni_rt_key_xfmr ***", inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	vrfName = pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	vniNumber := pathInfo.Var("vni-number")
	afName := pathInfo.Var("afi-safi-name")
	routeTarget := pathInfo.Var("route-target")

	if len(pathInfo.Vars) < 5 {
		err = errors.New("Invalid Key length")
		log.Info("Invalid Key length", len(pathInfo.Vars))
		return vrfName, err
	}

	if len(vrfName) == 0 {
		err = errors.New("vrf name is missing")
		log.Info("VRF Name is Missing")
		return vrfName, err
	}
	if strings.Contains(bgpId, "BGP") == false {
		err = errors.New("BGP ID is missing")
		log.Info("BGP ID is missing")
		return bgpId, err
	}
	if len(protoName) == 0 {
		err = errors.New("Protocol Name is missing")
		log.Info("Protocol Name is Missing")
		return protoName, err
	}
	if len(vniNumber) == 0 {
		err = errors.New("vniNumber is missing")
		log.Info("vniNumber is Missing")
		return vniNumber, err
	}

	if len(afName) == 0 {
		err = errors.New("AFI SAFI is missing")
		log.Info("AFI SAFI is Missing")
		return afName, err
	}

	if len(routeTarget) == 0 {
		err = errors.New("Route-target is missing")
		log.Info("route-target is Missing")
		return routeTarget, err
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afName = "IPV4_UNICAST"
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afName = "IPV6_UNICAST"
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afName = "L2VPN_EVPN"
	} else {
		err = errors.New("Unsupported AFI SAFI")
		log.Info("Unsupported AFI SAFI ", afName)
		return afName, err
	}

	log.Info("URI VRF ", vrfName)
	log.Info("URI VNI NUMBER ", vniNumber)
	log.Info("URI AFI SAFI ", afName)
	log.Info("URI Route-target ", routeTarget)

	var vniRouteTargetKey string

	vniRouteTargetKey = vrfName + "|" + afName + "|" + vniNumber + "|" + routeTarget

	log.Info("YangToDb_bgp_evpn_vni_rt_key_xfmr: vniRouteTargetKey:", vniRouteTargetKey)
	return vniRouteTargetKey, nil
}

var YangToDb_bgp_gbl_afi_safi_addr_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {

	pathInfo := NewPathInfo(inParams.uri)

	niName := pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	afName := pathInfo.Var("afi-safi-name")
	prefix := pathInfo.Var("prefix")
	afi := ""
	var err error

	if len(pathInfo.Vars) < 5 {
		return afi, errors.New("Invalid Key length")
	}

	if len(niName) == 0 {
		return afi, errors.New("vrf name is missing")
	}

	if strings.Contains(bgpId, "BGP") == false {
		return afi, errors.New("BGP ID is missing")
	}

	if len(protoName) == 0 {
		return afi, errors.New("Protocol Name is missing")
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afi = "ipv4_unicast"
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afi = "ipv6_unicast"
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afi = "l2vpn_evpn"
	} else {
		log.Info("Unsupported AFI type " + afName)
		return afi, errors.New("Unsupported AFI type " + afName)
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afName = "IPV4_UNICAST"
		if strings.Contains(inParams.uri, "ipv6-unicast") ||
			strings.Contains(inParams.uri, "l2vpn-evpn") {
			err = errors.New("IPV4_UNICAST supported only on ipv4-config container")
			log.Info("IPV4_UNICAST supported only on ipv4-config container: ", afName)
			return afName, err
		}
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afName = "IPV6_UNICAST"
		if strings.Contains(inParams.uri, "ipv4-unicast") ||
			strings.Contains(inParams.uri, "l2vpn-evpn") {
			err = errors.New("IPV6_UNICAST supported only on ipv6-config container")
			log.Info("IPV6_UNICAST supported only on ipv6-config container: ", afName)
			return afName, err
		}
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afName = "L2VPN_EVPN"
		if strings.Contains(inParams.uri, "ipv6-unicast") ||
			strings.Contains(inParams.uri, "ipv4-unicast") {
			err = errors.New("L2VPN_EVPN supported only on l2vpn-evpn container")
			log.Info("L2VPN_EVPN supported only on l2vpn-evpn container: ", afName)
			return afName, err
		}
	} else {
		err = errors.New("Unsupported AFI SAFI")
		log.Info("Unsupported AFI SAFI ", afName)
		return afName, err
	}

	key := niName + "|" + afi + "|" + prefix

	log.Info("YangToDb_bgp_gbl_afi_safi_addr_key_xfmr AFI key: ", key)

	return key, nil
}

var YangToDb_bgp_gbl_afi_safi_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {

	pathInfo := NewPathInfo(inParams.uri)

	niName := pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	afName := pathInfo.Var("afi-safi-name")
	afi := ""
	var err error

	if len(pathInfo.Vars) < 4 {
		return afi, errors.New("Invalid Key length")
	}

	if len(niName) == 0 {
		return afi, errors.New("vrf name is missing")
	}

	if strings.Contains(bgpId, "BGP") == false {
		return afi, errors.New("BGP ID is missing")
	}

	if len(protoName) == 0 {
		return afi, errors.New("Protocol Name is missing")
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afi = "ipv4_unicast"
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afi = "ipv6_unicast"
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afi = "l2vpn_evpn"
	} else {
		log.Info("Unsupported AFI type " + afName)
		return afi, errors.New("Unsupported AFI type " + afName)
	}

	if strings.Contains(afName, "IPV4_UNICAST") {
		afName = "IPV4_UNICAST"
		if strings.Contains(inParams.uri, "ipv6-unicast") ||
			strings.Contains(inParams.uri, "l2vpn-evpn") {
			err = errors.New("IPV4_UNICAST supported only on ipv4-config container")
			log.Info("IPV4_UNICAST supported only on ipv4-config container: ", afName)
			return afName, err
		}
	} else if strings.Contains(afName, "IPV6_UNICAST") {
		afName = "IPV6_UNICAST"
		if strings.Contains(inParams.uri, "ipv4-unicast") ||
			strings.Contains(inParams.uri, "l2vpn-evpn") {
			err = errors.New("IPV6_UNICAST supported only on ipv6-config container")
			log.Info("IPV6_UNICAST supported only on ipv6-config container: ", afName)
			return afName, err
		}
	} else if strings.Contains(afName, "L2VPN_EVPN") {
		afName = "L2VPN_EVPN"
		if strings.Contains(inParams.uri, "ipv6-unicast") ||
			strings.Contains(inParams.uri, "ipv4-unicast") {
			err = errors.New("L2VPN_EVPN supported only on l2vpn-evpn container")
			log.Info("L2VPN_EVPN supported only on l2vpn-evpn container: ", afName)
			return afName, err
		}
	} else {
		err = errors.New("Unsupported AFI SAFI")
		log.Info("Unsupported AFI SAFI ", afName)
		return afName, err
	}

	key := niName + "|" + afi

	log.Info("AFI key: ", key)

	return key, nil
}

var YangToDb_bgp_gbl_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error

	pathInfo := NewPathInfo(inParams.uri)

	niName := pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")

	if len(pathInfo.Vars) < 3 {
		return "", errors.New("Invalid Key length")
	}

	if len(niName) == 0 {
		return "", errors.New("vrf name is missing")
	}

	if strings.Contains(bgpId, "BGP") == false {
		return "", errors.New("BGP ID is missing")
	}

	if len(protoName) == 0 {
		return "", errors.New("Protocol Name is missing")
	}

	log.Info("URI VRF ", niName)

	if inParams.oper == DELETE && niName == "default" {
		xpath, _ := XfmrRemoveXPATHPredicates(inParams.requestUri)
		switch xpath {
		case "/openconfig-network-instance:network-instances/network-instance/protocols/protocol/bgp":
			fallthrough
		case "/openconfig-network-instance:network-instances/network-instance/protocols/protocol/bgp/global":
			fallthrough
		case "/openconfig-network-instance:network-instances/network-instance/protocols/protocol/bgp/global/config":
			log.Info("DELELE op for niName: ", niName, " XPATH: ", xpath)
			bgpGblTblTs := &db.TableSpec{Name: "BGP_GLOBALS"}
			if bgpGblTblKeys, err := inParams.d.GetKeys(bgpGblTblTs); err == nil {
				for _, key := range bgpGblTblKeys {

					if key.Get(0) == niName && len(bgpGblTblKeys) > 1 {
						return "", tlerr.NotSupported("Delete not allowed, since non-default-VRF BGP-instance present in system")
					}
				}
			}
		}
	}

	return niName, err
}

var YangToDb_bgp_nbr_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error
	var vrfName string

	log.Info("YangToDb_bgp_nbr_tbl_key_xfmr: ", inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	vrfName = pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	pNbrAddr := pathInfo.Var("neighbor-address")

	if len(pathInfo.Vars) < 3 {
		err = errors.New("Invalid Key length")
		log.Info("Invalid Key length", len(pathInfo.Vars))
		return vrfName, err
	}

	if len(vrfName) == 0 {
		err = errors.New("vrf name is missing")
		log.Info("VRF Name is Missing")
		return "", err
	}
	if strings.Contains(bgpId, "BGP") == false {
		err = errors.New("BGP ID is missing")
		log.Info("BGP ID is missing")
		return "", err
	}
	if len(protoName) == 0 {
		err = errors.New("Protocol Name is missing")
		log.Info("Protocol Name is Missing")
		return "", err
	}
	if len(pNbrAddr) == 0 {
		err = errors.New("Neighbor address is missing")
		log.Info("Neighbor address is Missing")
		return "", nil
	}

	log.Info("URI VRF", vrfName)
	log.Info("URI Neighbor address", pNbrAddr)

	var pNbrKey string

	pNbrKey = vrfName + "|" + pNbrAddr

	log.Info("YangToDb_bgp_nbr_tbl_key_xfmr: pNbrKey:", pNbrKey)
	return pNbrKey, nil
}

var YangToDb_bgp_pgrp_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error
	var vrfName string

	log.Info("YangToDb_bgp_pgrp_tbl_key_xfmr ***", inParams.uri)
	pathInfo := NewPathInfo(inParams.uri)

	vrfName = pathInfo.Var("name")
	bgpId := pathInfo.Var("identifier")
	protoName := pathInfo.Var("name#2")
	pGrpName := pathInfo.Var("peer-group-name")

	if len(pathInfo.Vars) < 3 {
		err = errors.New("Invalid Key length")
		log.Info("Invalid Key length", len(pathInfo.Vars))
		return vrfName, err
	}

	if len(vrfName) == 0 {
		err = errors.New("vrf name is missing")
		log.Info("VRF Name is Missing")
		return vrfName, err
	}
	if strings.Contains(bgpId, "BGP") == false {
		err = errors.New("BGP ID is missing")
		log.Info("BGP ID is missing")
		return bgpId, err
	}
	if len(protoName) == 0 {
		err = errors.New("Protocol Name is missing")
		log.Info("Protocol Name is Missing")
		return protoName, err
	}
	if len(pGrpName) == 0 {
		err = errors.New("Peer Group Name is missing")
		log.Info("Peer Group Name is Missing")
		return pGrpName, err
	}

	log.Info("URI VRF", vrfName)
	log.Info("URI Peer Group", pGrpName)

	var pGrpKey string

	pGrpKey = vrfName + "|" + pGrpName

	log.Info("YangToDb_bgp_pgrp_tbl_key_xfmr: pGrpKey:", pGrpKey)
	return pGrpKey, nil
}

var YangToDb_global_sg_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	if log.V(3) {
		log.Info("YangToDb_global_sg_key_xfmr: root: ", inParams.ygRoot,
			", uri: ", inParams.uri)
	}

	return "global", nil
}

var YangToDb_igmp_snooping_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	fmt.Println("YangToDb_igmp_snooping_key_xfmr ==> ", inParams)
	return "", nil
}

var YangToDb_igmp_snooping_mrouter_config_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	fmt.Println("YangToDb_igmp_snooping_mrouter_config_key_xfmr ==> ", inParams)
	return "", nil
}

var YangToDb_igmp_snooping_mrouter_state_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	fmt.Println("YangToDb_igmp_snooping_mrouter_state_key_xfmr ==> ", inParams)
	return "", nil
}

var YangToDb_igmp_snooping_static_group_config_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	fmt.Println("YangToDb_igmp_snooping_static_group_config_key_xfmr ==> ", inParams)
	return "", nil
}

var YangToDb_igmp_snooping_static_member_state_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	fmt.Println("YangToDb_igmp_snooping_static_member_state_key_xfmr ==> ", inParams)
	return "", nil
}

var YangToDb_intf_counters_key KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var entry_key string
	var err error
	pathInfo := NewPathInfo(inParams.uri)
	intfName := pathInfo.Var("name")
	oid, oiderr := getIntfCountersTblKey(inParams.dbs[inParams.curDb], intfName)

	if oiderr == nil {
		entry_key = oid
	}
	return entry_key, err
}

var YangToDb_intf_subintfs_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var subintf_key string
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	idx := pathInfo.Var("index")
	if idx != "0" {
		errStr := "Invalid sub-interface index: " + idx
		log.Error(errStr)
		err := tlerr.InvalidArgsError{Format: errStr}
		return idx, err
	}
	return subintf_key, err
}

var YangToDb_intf_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	log.Info("Entering YangToDb_intf_tbl_key_xfmr")
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	ifName := pathInfo.Var("name")

	log.Info("Intf name: ", ifName)
	log.Info("Exiting YangToDb_intf_tbl_key_xfmr")
	intfType, _, ierr := getIntfTypeByName(ifName)
	if ierr != nil {
		log.Errorf("Extracting Interface type for Interface: %s failed!", ifName)
		return "", tlerr.New(ierr.Error())
	}
	requestUriPath, err := getYangPathFromUri(inParams.requestUri)
	log.Info("inParams.requestUri: ", requestUriPath)
	err = performIfNameKeyXfmrOp(&inParams, &requestUriPath, &ifName, intfType)
	if err != nil {
		return "", tlerr.InvalidArgsError{Format: err.Error()}
	}
	return ifName, err
}

var YangToDb_napt_twice_mapping_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var napt_key string
	var err error

	var key_sep string

	pathInfo := NewPathInfo(inParams.uri)
	proto := pathInfo.Var("protocol")
	srcIp := pathInfo.Var("src-ip")
	srcPort := pathInfo.Var("src-port")
	dstIp := pathInfo.Var("dst-ip")
	dstPort := pathInfo.Var("dst-port")

	if proto == "" || srcIp == "" || srcPort == "" || dstIp == "" || dstPort == "" {
		log.Info("YangToDb_napt_twice_mapping_key_xfmr : Invalid key params.")
		return napt_key, nil
	}

	protocol, _ := strconv.Atoi(proto)
	if _, ok := protocol_map[uint8(protocol)]; !ok {
		log.Info("YangToDb_napt_twice_mapping_key_xfmr - Invalid protocol : ", protocol)
		return napt_key, nil
	}

	key_sep = ":"

	napt_key = protocol_map[uint8(protocol)] + key_sep + srcIp + key_sep + srcPort + key_sep + dstIp + key_sep + dstPort
	log.Info("YangToDb_napt_twice_mapping_key_xfmr : Key : ", napt_key)
	return napt_key, err
}

var YangToDb_nat_binding_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var key string
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	name := pathInfo.Var("name")

	key = name
	log.Info("YangToDb_nat_binding_key_xfmr : Key : ", key)
	return key, err
}

var YangToDb_nat_global_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var nat_global_key string
	var err error

	nat_global_key = GLOBAL_KEY

	return nat_global_key, err
}

var YangToDb_nat_instance_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var nat_inst_key string
	var err error
	nat_inst_key = "0"
	return nat_inst_key, err
}

var YangToDb_nat_mapping_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var nat_key string
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	extAddress := pathInfo.Var("external-address")

	nat_key = extAddress
	log.Info("YangToDb_nat_mapping_key_xfmr : Key : ", nat_key)
	return nat_key, err
}

var YangToDb_nat_pool_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var key string
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	name := pathInfo.Var("pool-name")

	key = name
	log.Info("YangToDb_nat_pool_key_xfmr: Key : ", key)
	return key, err
}

var YangToDb_nat_twice_mapping_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var nat_key string
	var err error

	var key_sep string

	pathInfo := NewPathInfo(inParams.uri)
	srcIp := pathInfo.Var("src-ip")
	dstIp := pathInfo.Var("dst-ip")

	if srcIp == "" || dstIp == "" {
		log.Info("YangToDb_nat_twice_mapping_key_xfmr : Invalid key params.")
		return nat_key, err
	}
	key_sep = ":"

	nat_key = srcIp + key_sep + dstIp
	log.Info("YangToDb_nat_twice_mapping_key_xfmr : Key : ", nat_key)
	return nat_key, err
}

var YangToDb_nat_zone_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var key string
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	name := pathInfo.Var("zone-id")

	key = name
	log.Info("YangToDb_nat_zone_key_xfmr : Key : ", key)
	return key, err
}

var YangToDb_neigh_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var neightbl_key string
	var err error

	log.Info("YangToDb_neigh_tbl_key_xfmr - inParams: ", inParams)
	pathInfo := NewPathInfo(inParams.uri)
	intfName := pathInfo.Var("name")
	ipAddr := pathInfo.Var("ip")

	neightbl_key = intfName + ":" + ipAddr
	log.Info("YangToDb_neigh_tbl_key_xfmr - key returned: ", neightbl_key)

	return neightbl_key, err
}

var YangToDb_network_instance_protocol_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var key string
	log.Info("YangToDb_network_instance_protocol_key_xfmr - URI: ", inParams.uri)
	if inParams.oper == GET {
		pathInfo := NewPathInfo(inParams.uri)
		protoId := pathInfo.Var("identifier")
		protoName := pathInfo.Var("name#2")
		key = protoId + "|" + protoName
	}
	log.Info("returned Key: ", key)
	return key, nil
}

var YangToDb_network_instance_table_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var vrfTbl_key string
	var err error

	log.Info("YangToDb_network_instance_table_key_xfmr: ")

	pathInfo := NewPathInfo(inParams.uri)

	vrfTbl_key = getVrfTblKeyByName(pathInfo.Var("name"))

	log.Info("YangToDb_network_instance_table_key_xfmr: ", vrfTbl_key)

	if (inParams.oper == CREATE) ||
		(inParams.oper == REPLACE) ||
		(inParams.oper == UPDATE) ||
		(inParams.oper == DELETE) {
		keyName := pathInfo.Var("name")

		if keyName == "mgmt" {
			subOpMap := make(map[db.DBNum]map[string]map[string]db.Value)
			resMap := make(map[string]map[string]db.Value)
			sshVrfMap := make(map[string]db.Value)

			sshVrfDbValues := db.Value{Field: map[string]string{}}
			(&sshVrfDbValues).Set("port", "22")
			sshVrfMap["mgmt"] = sshVrfDbValues

			log.Infof("ssh server vrf %v", sshVrfMap)
			resMap["SSH_SERVER_VRF"] = sshVrfMap
			subOpMap[db.ConfigDB] = resMap
			inParams.subOpDataMap[inParams.oper] = &subOpMap
		}
	}

	return vrfTbl_key, err
}

var YangToDb_nw_inst_vxlan_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error

	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_key_xfmr ==> printing target object request ==> ", (inParams.param))
	}

	path, err := getVxlanNiUriPath(inParams.uri)

	if err != nil {
		return "", err
	}

	reqP := &vxlanReqProcessor{&inParams.requestUri, &inParams.uri, path, inParams.oper, (*inParams.ygRoot).(*ocbinds.Device), inParams.param, inParams.d, inParams.dbs, nil, nil, nil, nil, &inParams}

	if err = reqP.setVxlanNetInstObjFromReq(); err != nil {
		return "", err
	}

	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_key_xfmr ==> printing vxlanNetInstObj object request ==> ", (*reqP.vxlanNetInstObj))
	}

	var keyStr string
	var srcVetpName string
	var vniIdStr string

	if reqP.opcode == 5 || reqP.opcode == 1 {
		pathInfo := NewPathInfo(inParams.uri)
		srcVetpName = pathInfo.Var("source-nve")
		vniIdStr = pathInfo.Var("vni-id")
		if reqP.vxlanNetInstObj.VxlanVniInstances == nil || len(reqP.vxlanNetInstObj.VxlanVniInstances.VniInstance) == 0 && srcVetpName == "" {
			log.Error("YangToDb_nw_inst_vxlan_key_xfmr ==> returning EMPTY key, since there is no key in the request")
			return "", nil
		}
	}

	if srcVetpName == "" && vniIdStr == "" {
		if reqP.vxlanNetInstObj.VxlanVniInstances == nil {
			log.Error("YangToDb_nw_inst_vxlan_key_xfmr ==> returning EMPTY key, since there is no key in the request")
			return "", tlerr.NotFound("Resource Not Found")
		}

		for _, vxlanNiObj := range reqP.vxlanNetInstObj.VxlanVniInstances.VniInstance {
			srcVetpName = *vxlanNiObj.SourceNve
			vniIdStr = strconv.Itoa(int(*vxlanNiObj.VniId))
			break
		}
	}

	niName := *(reqP.vxlanNetInstObj.Name)
	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_key_xfmr ==> niName  ===> ", niName)
	}

	keyStr = srcVetpName + "|" + "map_" + vniIdStr + "_" + niName

	if log.V(3) {
		log.Info("YangToDb_nw_inst_vxlan_key_xfmr ==> keyStr  ===> ", keyStr)
	}

	return keyStr, nil
}