docs: def modify_virtual(hostname, username, password, name, destination,
                     pool=None,
                     address_status=None,
                     auto_lasthop=None,
                     bwc_policy=None,
                     cmp_enabled=None,
                     connection_limit=None,
                     dhcp_relay=None,
                     description=None,
                     fallback_persistence=None,
                     flow_eviction_policy=None,
                     gtm_score=None,
                     ip_forward=None,
                     ip_protocol=None,
                     internal=None,
                     twelve_forward=None,
                     last_hop_pool=None,
                     mask=None,
                     mirror=None,
                     nat64=None,
                     persist=None,
                     profiles=None,
                     policies=None,
                     rate_class=None,
                     rate_limit=None,
                     rate_limit_mode=None,
                     rate_limit_dst=None,
                     rate_limit_src=None,
                     rules=None,
                     related_rules=None,
                     reject=None,
                     source=None,
                     source_address_translation=None,
                     source_port=None,
                     virtual_state=None,
                     traffic_classes=None,
                     translate_address=None,
                     translate_port=None,
                     vlans=None):
      '''
      Modify an virtual server.  modify an existing virtual.  Only parameters specified will be enforced.
  
      hostname
          The host/address of the bigip device
      username
          The iControl REST username
      password
          The iControl REST password
      name
          The name of the virtual to create
      destination
          [ [virtual_address_name:port] | [ipv4:port] | [ipv6.port] ]
      pool
          [ [pool_name] | none]
      address_status
          [yes | no]
      auto_lasthop
          [default | enabled | disabled ]
      bwc_policy
          [none] | string]
      cmp_enabled
          [yes | no]
      dhcp_relay
          [yes | no}
      connection_limit
          [integer]
      description
          [string]
      state
          [disabled | enabled]
      fallback_persistence
          [none | [profile name] ]
      flow_eviction_policy
          [none | [eviction policy name] ]
      gtm_score
          [integer]
      ip_forward
          [yes | no]
      ip_protocol
          [any | protocol]
      internal
          [yes | no]
      twelve_forward(12-forward)
          [yes | no]
      last_hop-pool
          [ [pool_name] | none]
      mask
          { [ipv4] | [ipv6] }
      mirror
          { [disabled | enabled | none] }
      nat64
          [enabled | disabled]
      persist
          [list]
      profiles
          [none | default | list ]
      policies
          [none | default | list ]
      rate_class
          [name]
      rate_limit
          [integer]
      rate_limit-mode
          [destination | object | object-destination |
          object-source | object-source-destination |
          source | source-destination]
      rate_limit_dst
          [integer]
      rate_limit_src
          [integer]
      rules
          [none | list ]
      related_rules
          [none | list ]
      reject
          [yes | no]
      source
          { [ipv4[/prefixlen]] | [ipv6[/prefixlen]] }
      source_address_translation
          [none | snat:pool_name | lsn | automap | dictionary ]
      source_port
          [change | preserve | preserve-strict]
      state
          [enabled | disabled]
      traffic_classes
          [none | default | list ]
      translate_address
          [enabled | disabled]
      translate_port
          [enabled | disabled]
      vlans
          [none | default | dictionary ]
  
          vlan_ids
              [ list]
          enabled
              [ true | false ]
  
      '''
  
      ret = {'name': name, 'changes': {}, 'result': False, 'comment': ''}
  
      if __opts__['test']:
          return _test_output(ret, 'modify', params={
              'hostname': hostname,
              'username': username,
              'password': password,
              'name': name,
              'destination': destination,
              'pool': pool,
              'address_status': address_status,
              'auto_lasthop': auto_lasthop,
              'bwc_policy': bwc_policy,
              'cmp_enabled': cmp_enabled,
              'connection_limit': connection_limit,
              'dhcp_relay': dhcp_relay,
              'description': description,
              'fallback_persistence': fallback_persistence,
              'flow_eviction_policy': flow_eviction_policy,
              'gtm_score': gtm_score,
              'ip_forward': ip_forward,
              'ip_protocol': ip_protocol,
              'internal': internal,
              'twelve_forward': twelve_forward,
              'last_hop_pool': last_hop_pool,
              'mask': mask,
              'mirror': mirror,
              'nat64': nat64,
              'persist': persist,
              'profiles': profiles,
              'policies': policies,
              'rate_class': rate_class,
              'rate_limit': rate_limit,
              'rate_limit_mode': rate_limit_mode,
              'rate_limit_dst': rate_limit_dst,
              'rate_limit_src': rate_limit_src,
              'rules': rules,
              'related_rules': related_rules,
              'reject': reject,
              'source': source,
              'source_address_translation': source_address_translation,
              'source_port': source_port,
              'virtual_state': virtual_state,
              'traffic_classes': traffic_classes,
              'translate_address': translate_address,
              'translate_port': translate_port,
              'vlans': vlans
          }
          )
  
      existing = __salt__['bigip.list_virtual'](hostname, username, password, name)
  
      # does this virtual exist?
      if existing['code'] == 200:
  
          # modify
          modified = __salt__['bigip.modify_virtual'](hostname=hostname,
                                                      username=username,
                                                      password=password,
                                                      name=name,
                                                      destination=destination,
                                                      description=description,
                                                      pool=pool,
                                                      address_status=address_status,
                                                      auto_lasthop=auto_lasthop,
                                                      bwc_policy=bwc_policy,
                                                      cmp_enabled=cmp_enabled,
                                                      connection_limit=connection_limit,
                                                      dhcp_relay=dhcp_relay,
                                                      fallback_persistence=fallback_persistence,
                                                      flow_eviction_policy=flow_eviction_policy,
                                                      gtm_score=gtm_score,
                                                      ip_forward=ip_forward,
                                                      ip_protocol=ip_protocol,
                                                      internal=internal,
                                                      twelve_forward=twelve_forward,
                                                      last_hop_pool=last_hop_pool,
                                                      mask=mask,
                                                      mirror=mirror,
                                                      nat64=nat64,
                                                      persist=persist,
                                                      profiles=profiles,
                                                      policies=policies,
                                                      rate_class=rate_class,
                                                      rate_limit=rate_limit,
                                                      rate_limit_mode=rate_limit_mode,
                                                      rate_limit_dst=rate_limit_dst,
                                                      rate_limit_src=rate_limit_src,
                                                      rules=rules,
                                                      related_rules=related_rules,
                                                      reject=reject,
                                                      source=source,
                                                      source_address_translation=source_address_translation,
                                                      source_port=source_port,
                                                      state=virtual_state,
                                                      traffic_classes=traffic_classes,
                                                      translate_address=translate_address,
                                                      translate_port=translate_port,
                                                      vlans=vlans)
  
          #was the modification successful?
          if modified['code'] == 200:
  
              #relist it to compare
              relisting = __salt__['bigip.list_virtual'](hostname, username, password, name)
  
              if relisting['code'] == 200:
  
                  relisting = _strip_key(relisting, 'generation')
                  existing = _strip_key(existing, 'generation')
  
                  ret = _check_for_changes('Virtual', ret, existing, relisting)
              else:
                  ret = _load_result(relisting, ret)
  
          else:
              ret = _load_result(modified, ret)
  
      elif existing['code'] == 404:
          ret['comment'] = 'A Virtual with this name was not found.'
          # else something else was returned
      else:
          ret = _load_result(existing, ret)
  
      return ret