func()

in pkg/authority/rule/authorization/definition.go [93:141]

• 40 lines of code
• 11 McCabe index (conditional complexity)

func (s *Source) CopyToClient() *SourceToClient {
	toClient := &SourceToClient{}

	if s.Namespaces != nil {
		toClient.Namespaces = make([]string, len(s.Namespaces))
		copy(toClient.Namespaces, s.Namespaces)
	}

	if s.NotNamespaces != nil {
		toClient.NotNamespaces = make([]string, len(s.NotNamespaces))
		copy(toClient.NotNamespaces, s.NotNamespaces)
	}

	if s.IpBlocks != nil {
		toClient.IpBlocks = make([]string, len(s.IpBlocks))
		copy(toClient.IpBlocks, s.IpBlocks)
	}

	if s.NotIpBlocks != nil {
		toClient.NotIpBlocks = make([]string, len(s.NotIpBlocks))
		copy(toClient.NotIpBlocks, s.NotIpBlocks)
	}

	if s.Principals != nil {
		toClient.Principals = make([]string, len(s.Principals))
		copy(toClient.Principals, s.Principals)
	}

	if s.NotPrincipals != nil {
		toClient.NotPrincipals = make([]string, len(s.NotPrincipals))
		copy(toClient.NotPrincipals, s.NotPrincipals)
	}

	if s.Extends != nil {
		toClient.Extends = make([]*ExtendToClient, len(s.Extends))
		for i, v := range s.Extends {
			toClient.Extends[i] = v.CopyToClient()
		}
	}

	if s.NotExtends != nil {
		toClient.NotExtends = make([]*ExtendToClient, len(s.NotExtends))
		for i, v := range s.NotExtends {
			toClient.NotExtends[i] = v.CopyToClient()
		}
	}

	return toClient
}