fv_bd.go

package models


import (
	"fmt"
	"strconv"

	"github.com/ciscoecosystem/aci-go-client/container"
)

const FvbdClassName = "fvBD"

type BridgeDomain struct {
	BaseAttributes
    BridgeDomainAttributes 
}
  
type BridgeDomainAttributes struct {
	
	
	Name string `json:",omitempty"`
	
	
    
	OptimizeWanBandwidth       string `json:",omitempty"`
	
    
	Annotation       string `json:",omitempty"`
	
    
	ArpFlood       string `json:",omitempty"`
	
    
	EpClear       string `json:",omitempty"`
	
    
	EpMoveDetectMode       string `json:",omitempty"`
	
    
	HostBasedRouting       string `json:",omitempty"`
	
    
	IntersiteBumTrafficAllow       string `json:",omitempty"`
	
    
	IntersiteL2Stretch       string `json:",omitempty"`
	
    
	IpLearning       string `json:",omitempty"`
	
    
	Ipv6McastAllow       string `json:",omitempty"`
	
    
	LimitIpLearnToSubnets       string `json:",omitempty"`
	
    
	LlAddr       string `json:",omitempty"`
	
    
	Mac       string `json:",omitempty"`
	
    
	McastAllow       string `json:",omitempty"`
	
    
	MultiDstPktAct       string `json:",omitempty"`
	
    
	NameAlias       string `json:",omitempty"`
	
    
	BridgeDomain_type       string `json:",omitempty"`
	
    
	UnicastRoute       string `json:",omitempty"`
	
    
	UnkMacUcastAct       string `json:",omitempty"`
	
    
	UnkMcastAct       string `json:",omitempty"`
	
    
	V6unkMcastAct       string `json:",omitempty"`
	
    
	Vmac       string `json:",omitempty"`
	
    
}
   

func NewBridgeDomain(fvBDRn, parentDn, description string, fvBDattr BridgeDomainAttributes) *BridgeDomain {
	dn := fmt.Sprintf("%s/%s", parentDn, fvBDRn)  
	return &BridgeDomain{
		BaseAttributes: BaseAttributes{
			DistinguishedName: dn,
			Description:       description,
			Status:            "created, modified",
			ClassName:         FvbdClassName,
			Rn:                fvBDRn,
		},
        
		BridgeDomainAttributes: fvBDattr,
         
	}
}

func (fvBD *BridgeDomain) ToMap() (map[string]string, error) {
	fvBDMap, err := fvBD.BaseAttributes.ToMap()
	if err != nil {
		return nil, err
	}

	
	
	A(fvBDMap, "name",fvBD.Name)
	
	
    
	A(fvBDMap, "OptimizeWanBandwidth",fvBD.OptimizeWanBandwidth)
	
    
	A(fvBDMap, "annotation",fvBD.Annotation)
	
    
	A(fvBDMap, "arpFlood",fvBD.ArpFlood)
	
    
	A(fvBDMap, "epClear",fvBD.EpClear)
	
    
	A(fvBDMap, "epMoveDetectMode",fvBD.EpMoveDetectMode)
	
    
	A(fvBDMap, "hostBasedRouting",fvBD.HostBasedRouting)
	
    
	A(fvBDMap, "intersiteBumTrafficAllow",fvBD.IntersiteBumTrafficAllow)
	
    
	A(fvBDMap, "intersiteL2Stretch",fvBD.IntersiteL2Stretch)
	
    
	A(fvBDMap, "ipLearning",fvBD.IpLearning)
	
    
	A(fvBDMap, "ipv6McastAllow",fvBD.Ipv6McastAllow)
	
    
	A(fvBDMap, "limitIpLearnToSubnets",fvBD.LimitIpLearnToSubnets)
	
    
	A(fvBDMap, "llAddr",fvBD.LlAddr)
	
    
	A(fvBDMap, "mac",fvBD.Mac)
	
    
	A(fvBDMap, "mcastAllow",fvBD.McastAllow)
	
    
	A(fvBDMap, "multiDstPktAct",fvBD.MultiDstPktAct)
	
    
	A(fvBDMap, "nameAlias",fvBD.NameAlias)
	
    
	A(fvBDMap, "type",fvBD.BridgeDomain_type)
	
    
	A(fvBDMap, "unicastRoute",fvBD.UnicastRoute)
	
    
	A(fvBDMap, "unkMacUcastAct",fvBD.UnkMacUcastAct)
	
    
	A(fvBDMap, "unkMcastAct",fvBD.UnkMcastAct)
	
    
	A(fvBDMap, "v6unkMcastAct",fvBD.V6unkMcastAct)
	
    
	A(fvBDMap, "vmac",fvBD.Vmac)
	
    
	

	return fvBDMap, err
}

func BridgeDomainFromContainerList(cont *container.Container, index int) *BridgeDomain {

	BridgeDomainCont := cont.S("imdata").Index(index).S(FvbdClassName, "attributes")
	return &BridgeDomain{
		BaseAttributes{
			DistinguishedName: G(BridgeDomainCont, "dn"),
			Description:       G(BridgeDomainCont, "descr"),
			Status:            G(BridgeDomainCont, "status"),
			ClassName:         FvbdClassName,
			Rn:                G(BridgeDomainCont, "rn"),
		},
        
		BridgeDomainAttributes{
		
		
			Name : G(BridgeDomainCont, "name"),
		
		
        
	        OptimizeWanBandwidth : G(BridgeDomainCont, "OptimizeWanBandwidth"),
		
        
	        Annotation : G(BridgeDomainCont, "annotation"),
		
        
	        ArpFlood : G(BridgeDomainCont, "arpFlood"),
		
        
	        EpClear : G(BridgeDomainCont, "epClear"),
		
        
	        EpMoveDetectMode : G(BridgeDomainCont, "epMoveDetectMode"),
		
        
	        HostBasedRouting : G(BridgeDomainCont, "hostBasedRouting"),
		
        
	        IntersiteBumTrafficAllow : G(BridgeDomainCont, "intersiteBumTrafficAllow"),
		
        
	        IntersiteL2Stretch : G(BridgeDomainCont, "intersiteL2Stretch"),
		
        
	        IpLearning : G(BridgeDomainCont, "ipLearning"),
		
        
	        Ipv6McastAllow : G(BridgeDomainCont, "ipv6McastAllow"),
		
        
	        LimitIpLearnToSubnets : G(BridgeDomainCont, "limitIpLearnToSubnets"),
		
        
	        LlAddr : G(BridgeDomainCont, "llAddr"),
		
        
	        Mac : G(BridgeDomainCont, "mac"),
		
        
	        McastAllow : G(BridgeDomainCont, "mcastAllow"),
		
        
	        MultiDstPktAct : G(BridgeDomainCont, "multiDstPktAct"),
		
        
	        NameAlias : G(BridgeDomainCont, "nameAlias"),
		
        
	        BridgeDomain_type : G(BridgeDomainCont, "type"),
		
        
	        UnicastRoute : G(BridgeDomainCont, "unicastRoute"),
		
        
	        UnkMacUcastAct : G(BridgeDomainCont, "unkMacUcastAct"),
		
        
	        UnkMcastAct : G(BridgeDomainCont, "unkMcastAct"),
		
        
	        V6unkMcastAct : G(BridgeDomainCont, "v6unkMcastAct"),
		
        
	        Vmac : G(BridgeDomainCont, "vmac"),
		
        		
        },
        
	}
}

func BridgeDomainFromContainer(cont *container.Container) *BridgeDomain {

	return BridgeDomainFromContainerList(cont, 0)
}

func BridgeDomainListFromContainer(cont *container.Container) []*BridgeDomain {
	length, _ := strconv.Atoi(G(cont, "totalCount"))

	arr := make([]*BridgeDomain, length)

	for i := 0; i < length; i++ {

		arr[i] = BridgeDomainFromContainerList(cont, i)
	}

	return arr
}