text:
'''
Module for handling OpenStack Neutron calls

:depends:   - neutronclient Python module
:configuration: This module is not usable until the user, password, tenant, and
    auth URL are specified either in a pillar or in the minion's config file.
    For example::

        keystone.user: 'admin'
        keystone.password: 'password'
        keystone.tenant: 'admin'
        keystone.auth_url: 'http://127.0.0.1:5000/v2.0/'
        keystone.region_name: 'RegionOne'
        keystone.service_type: 'network'

    If configuration for multiple OpenStack accounts is required, they can be
    set up as different configuration profiles:
    For example::

        openstack1:
          keystone.user: 'admin'
          keystone.password: 'password'
          keystone.tenant: 'admin'
          keystone.auth_url: 'http://127.0.0.1:5000/v2.0/'
          keystone.region_name: 'RegionOne'
          keystone.service_type: 'network'

        openstack2:
          keystone.user: 'admin'
          keystone.password: 'password'
          keystone.tenant: 'admin'
          keystone.auth_url: 'http://127.0.0.2:5000/v2.0/'
          keystone.region_name: 'RegionOne'
          keystone.service_type: 'network'

    With this configuration in place, any of the neutron functions
    can make use of a configuration profile by declaring it explicitly.
    For example::

        salt '*' neutron.network_list profile=openstack1
'''

# Import python libs
from __future__ import absolute_import
import logging

# Import salt libs
try:
    import salt.utils.openstack.neutron as suoneu
    HAS_NEUTRON = True
except NameError as exc:
    HAS_NEUTRON = False

# Get logging started
log = logging.getLogger(__name__)

# Function alias to not shadow built-ins
__func_alias__ = {
    'list_': 'list'
}

def __virtual__():
    '''
    Only load this module if neutron
    is installed on this minion.
    '''
    return HAS_NEUTRON

__opts__ = {}

def _auth(profile=None):
    '''
    Set up neutron credentials
    '''
    if profile:
        credentials = __salt__['config.option'](profile)
        user = credentials['keystone.user']
        password = credentials['keystone.password']
        tenant = credentials['keystone.tenant']
        auth_url = credentials['keystone.auth_url']
        region_name = credentials.get('keystone.region_name', None)
        service_type = credentials['keystone.service_type']
    else:
        user = __salt__['config.option']('keystone.user')
        password = __salt__['config.option']('keystone.password')
        tenant = __salt__['config.option']('keystone.tenant')
        auth_url = __salt__['config.option']('keystone.auth_url')
        region_name = __salt__['config.option']('keystone.region_name')
        service_type = __salt__['config.option']('keystone.service_type')

    kwargs = {
        'username': user,
        'password': password,
        'tenant_name': tenant,
        'auth_url': auth_url,
        'region_name': region_name,
        'service_type': service_type
    }

    return suoneu.SaltNeutron(**kwargs)

def get_quotas_tenant(profile=None):
    '''
    Fetches tenant info in server's context for following quota operation

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.get_quotas_tenant
        salt '*' neutron.get_quotas_tenant profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: Quotas information
    '''

    conn = _auth(profile)
    return conn.get_quotas_tenant()

def list_quotas(profile=None):
    '''
    Fetches all tenants quotas

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_quotas
        salt '*' neutron.list_quotas profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of quotas
    '''
    conn = _auth(profile)
    return conn.list_quotas()

def show_quota(tenant_id, profile=None):
    '''
    Fetches information of a certain tenant's quotas

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_quota tenant-id
        salt '*' neutron.show_quota tenant-id profile=openstack1

    :param tenant_id: ID of tenant
    :param profile: Profile to build on (Optional)
    :return: Quota information
    '''
    conn = _auth(profile)
    return conn.show_quota(tenant_id)

def update_quota(tenant_id,
                 subnet=None,
                 router=None,
                 network=None,
                 floatingip=None,
                 port=None,
                 security_group=None,
                 security_group_rule=None,
                 profile=None):
    '''
    Update a tenant's quota

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_quota tenant-id subnet=40 router=50
                                    network=10 floatingip=30 port=30

    :param tenant_id: ID of tenant
    :param subnet: Value of subnet quota (Optional)
    :param router: Value of router quota (Optional)
    :param network: Value of network quota (Optional)
    :param floatingip: Value of floatingip quota (Optional)
    :param port: Value of port quota (Optional)
    :param security_group: Value of security group (Optional)
    :param security_group_rule: Value of security group rule (Optional)
    :param profile: Profile to build on (Optional)
    :return: Value of updated quota
    '''
    conn = _auth(profile)
    return conn.update_quota(tenant_id, subnet, router, network,
                             floatingip, port, security_group,
                             security_group_rule)

def delete_quota(tenant_id, profile=None):
    '''
    Delete the specified tenant's quota value

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_quota tenant-id
        salt '*' neutron.update_quota tenant-id profile=openstack1

    :param tenant_id: ID of tenant to quota delete
    :param profile: Profile to build on (Optional)
    :return: True(Delete succeed) or False(Delete failed)
    '''
    conn = _auth(profile)
    return conn.delete_quota(tenant_id)

def list_extensions(profile=None):
    '''
    Fetches a list of all extensions on server side

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_extensions
        salt '*' neutron.list_extensions profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of extensions
    '''
    conn = _auth(profile)
    return conn.list_extensions()

def list_ports(profile=None):
    '''
    Fetches a list of all networks for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_ports
        salt '*' neutron.list_ports profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of port
    '''
    conn = _auth(profile)
    return conn.list_ports()

def show_port(port, profile=None):
    '''
    Fetches information of a certain port

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_port port-id
        salt '*' neutron.show_port port-id profile=openstack1

    :param port: ID or name of port to look up
    :param profile: Profile to build on (Optional)
    :return: Port information
    '''
    conn = _auth(profile)
    return conn.show_port(port)

def create_port(name,
                network,
                device_id=None,
                admin_state_up=True,
                profile=None):
    '''
    Creates a new port

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_port network-name port-name

    :param name: Name of port to create
    :param network: Network name or ID
    :param device_id: ID of device (Optional)
    :param admin_state_up: Set admin state up to true or false,
            default: true (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created port information
    '''
    conn = _auth(profile)
    return conn.create_port(name, network, device_id, admin_state_up)

def update_port(port, name, admin_state_up=True, profile=None):
    '''
    Updates a port

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_port port-name network-name new-port-name

    :param port: Port name or ID
    :param name: Name of this port
    :param admin_state_up: Set admin state up to true or false,
            default: true (Optional)
    :param profile: Profile to build on (Optional)
    :return: Value of updated port information
    '''
    conn = _auth(profile)
    return conn.update_port(port, name, admin_state_up)

def delete_port(port, profile=None):
    '''
    Deletes the specified port

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_network port-name
        salt '*' neutron.delete_network port-name profile=openstack1

    :param port: port name or ID
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_port(port)

def list_networks(profile=None):
    '''
    Fetches a list of all networks for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_networks
        salt '*' neutron.list_networks profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of network
    '''
    conn = _auth(profile)
    return conn.list_networks()

def show_network(network, profile=None):
    '''
    Fetches information of a certain network

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_network network-name
        salt '*' neutron.show_network network-name profile=openstack1

    :param network: ID or name of network to look up
    :param profile: Profile to build on (Optional)
    :return: Network information
    '''
    conn = _auth(profile)
    return conn.show_network(network)

def create_network(name, router_ext=None, admin_state_up=True, network_type=None, physical_network=None, segmentation_id=None, shared=None, profile=None):
    '''
    Creates a new network

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_network network-name
        salt '*' neutron.create_network network-name profile=openstack1

    :param name: Name of network to create
    :param admin_state_up: should the state of the network be up?
            default: True (Optional)
    :param router_ext: True then if create the external network (Optional)
    :param network_type: the Type of network that the provider is such as GRE, VXLAN, VLAN, FLAT, or LOCAL (Optional)
    :param physical_network: the name of the physical network as neutron knows it (Optional)
    :param segmentation_id: the vlan id or GRE id (Optional)
    :param shared: is the network shared or not (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created network information
    '''
    conn = _auth(profile)
    return conn.create_network(name, admin_state_up, router_ext, network_type, physical_network, segmentation_id, shared)

def update_network(network, name, profile=None):
    '''
    Updates a network

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_network network-name new-network-name

    :param network: ID or name of network to update
    :param name: Name of this network
    :param profile: Profile to build on (Optional)
    :return: Value of updated network information
    '''
    conn = _auth(profile)
    return conn.update_network(network, name)

def delete_network(network, profile=None):
    '''
    Deletes the specified network

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_network network-name
        salt '*' neutron.delete_network network-name profile=openstack1

    :param network: ID or name of network to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_network(network)

def list_subnets(profile=None):
    '''
    Fetches a list of all networks for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_subnets
        salt '*' neutron.list_subnets profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of subnet
    '''
    conn = _auth(profile)
    return conn.list_subnets()

def show_subnet(subnet, profile=None):
    '''
    Fetches information of a certain subnet

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_subnet subnet-name

    :param subnet: ID or name of subnet to look up
    :param profile: Profile to build on (Optional)
    :return: Subnet information
    '''
    conn = _auth(profile)
    return conn.show_subnet(subnet)

def create_subnet(network, cidr, name=None,
                  ip_version=4, profile=None):
    '''
    Creates a new subnet

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_subnet network-name 192.168.1.0/24

    :param network: Network ID or name this subnet belongs to
    :param cidr: CIDR of subnet to create (Ex. '192.168.1.0/24')
    :param name: Name of the subnet to create (Optional)
    :param ip_version: Version to use, default is 4(IPv4) (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created subnet information
    '''
    conn = _auth(profile)
    return conn.create_subnet(network, cidr, name, ip_version)

def update_subnet(subnet, name, profile=None):
    '''
    Updates a subnet

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_subnet subnet-name new-subnet-name

    :param subnet: ID or name of subnet to update
    :param name: Name of this subnet
    :param profile: Profile to build on (Optional)
    :return: Value of updated subnet information
    '''
    conn = _auth(profile)
    return conn.update_subnet(subnet, name)

def delete_subnet(subnet, profile=None):
    '''
    Deletes the specified subnet

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_subnet subnet-name
        salt '*' neutron.delete_subnet subnet-name profile=openstack1

    :param subnet: ID or name of subnet to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_subnet(subnet)

def list_routers(profile=None):
    '''
    Fetches a list of all routers for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_routers
        salt '*' neutron.list_routers profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of router
    '''
    conn = _auth(profile)
    return conn.list_routers()

def show_router(router, profile=None):
    '''
    Fetches information of a certain router

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_router router-name

    :param router: ID or name of router to look up
    :param profile: Profile to build on (Optional)
    :return: Router information
    '''
    conn = _auth(profile)
    return conn.show_router(router)

def create_router(name, ext_network=None,
                  admin_state_up=True, profile=None):
    '''
    Creates a new router

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_router new-router-name

    :param name: Name of router to create (must be first)
    :param ext_network: ID or name of the external for the gateway (Optional)
    :param admin_state_up: Set admin state up to true or false,
            default:true (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created router information
    '''
    conn = _auth(profile)
    return conn.create_router(name, ext_network, admin_state_up)

def update_router(router,
                  name=None,
                  admin_state_up=None,
                  profile=None,
                  **kwargs):
    '''
    Updates a router

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_router router_id name=new-router-name
                admin_state_up=True

    :param router: ID or name of router to update
    :param name: Name of this router
    :param ext_network: ID or name of the external for the gateway (Optional)
    :param admin_state_up: Set admin state up to true or false,
            default: true (Optional)
    :param profile: Profile to build on (Optional)
    :param kwargs:
    :return: Value of updated router information
    '''
    conn = _auth(profile)
    return conn.update_router(router, name, admin_state_up, **kwargs)

def delete_router(router, profile=None):
    '''
    Delete the specified router

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_router router-name

    :param router: ID or name of router to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_router(router)

def add_interface_router(router, subnet, profile=None):
    '''
    Adds an internal network interface to the specified router

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.add_interface_router router-name subnet-name

    :param router: ID or name of the router
    :param subnet: ID or name of the subnet
    :param profile: Profile to build on (Optional)
    :return: Added interface information
    '''
    conn = _auth(profile)
    return conn.add_interface_router(router, subnet)

def remove_interface_router(router, subnet, profile=None):
    '''
    Removes an internal network interface from the specified router

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.remove_interface_router router-name subnet-name

    :param router: ID or name of the router
    :param subnet: ID or name of the subnet
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.remove_interface_router(router, subnet)

def add_gateway_router(router, ext_network, profile=None):
    '''
    Adds an external network gateway to the specified router

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.add_gateway_router router-name ext-network-name

    :param router: ID or name of the router
    :param ext_network: ID or name of the external network the gateway
    :param profile: Profile to build on (Optional)
    :return: Added Gateway router information
    '''
    conn = _auth(profile)
    return conn.add_gateway_router(router, ext_network)

def remove_gateway_router(router, profile=None):
    '''
    Removes an external network gateway from the specified router

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.remove_gateway_router router-name

    :param router: ID or name of router
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.remove_gateway_router(router)

def list_floatingips(profile=None):
    '''
    Fetch a list of all floatingIPs for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_floatingips
        salt '*' neutron.list_floatingips profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of floatingIP
    '''
    conn = _auth(profile)
    return conn.list_floatingips()

def show_floatingip(floatingip_id, profile=None):
    '''
    Fetches information of a certain floatingIP

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_floatingip floatingip-id

    :param floatingip_id: ID of floatingIP to look up
    :param profile: Profile to build on (Optional)
    :return: Floating IP information
    '''
    conn = _auth(profile)
    return conn.show_floatingip(floatingip_id)

def create_floatingip(floating_network, port=None, profile=None):
    '''
    Creates a new floatingIP

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_floatingip network-name port-name

    :param floating_network: Network name or ID to allocate floatingIP from
    :param port: Of the port to be associated with the floatingIP (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created floatingIP information
    '''
    conn = _auth(profile)
    return conn.create_floatingip(floating_network, port)

def update_floatingip(floatingip_id, port, profile=None):
    '''
    Updates a floatingIP

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_floatingip network-name port-name

    :param floatingip_id: ID of floatingIP
    :param port: ID or name of port
    :param profile: Profile to build on (Optional)
    :return: Value of updated floating IP information
    '''
    conn = _auth(profile)
    return conn.update_floatingip(floatingip_id, port)

def delete_floatingip(floatingip_id, profile=None):
    '''
    Deletes the specified floating IP

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_floatingip floatingip-id

    :param floatingip_id: ID of floatingIP to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_floatingip(floatingip_id)

def list_security_groups(profile=None):
    '''
    Fetches a list of all security groups for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_security_groups
        salt '*' neutron.list_security_groups profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of security group
    '''
    conn = _auth(profile)
    return conn.list_security_groups()

def show_security_group(security_group, profile=None):
    '''
    Fetches information of a certain security group

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_security_group security-group-name

    :param security_group: ID or name of security group to look up
    :param profile: Profile to build on (Optional)
    :return: Security group information
    '''
    conn = _auth(profile)
    return conn.show_security_group(security_group)

def create_security_group(name=None, description=None, profile=None):
    '''
    Creates a new security group

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_security_group security-group-name \
                description='Security group for servers'

    :param name: Name of security group (Optional)
    :param description: Description of security group (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created security group information
    '''
    conn = _auth(profile)
    return conn.create_security_group(name, description)

def update_security_group(security_group, name=None, description=None,
                          profile=None):
    '''
    Updates a security group

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_security_group security-group-name \
                new-security-group-name

    :param security_group: ID or name of security group to update
    :param name: Name of this security group (Optional)
    :param description: Description of security group (Optional)
    :param profile: Profile to build on (Optional)
    :return: Value of updated security group information
    '''
    conn = _auth(profile)
    return conn.update_security_group(security_group, name, description)

def delete_security_group(security_group, profile=None):
    '''
    Deletes the specified security group

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_security_group security-group-name

    :param security_group: ID or name of security group to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_security_group(security_group)

def list_security_group_rules(profile=None):
    '''
    Fetches a list of all security group rules for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_security_group_rules
        salt '*' neutron.list_security_group_rules profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of security group rule
    '''
    conn = _auth(profile)
    return conn.list_security_group_rules()

def show_security_group_rule(security_group_rule_id, profile=None):
    '''
    Fetches information of a certain security group rule

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_security_group_rule security-group-rule-id

    :param security_group_rule_id: ID of security group rule to look up
    :param profile: Profile to build on (Optional)
    :return: Security group rule information
    '''
    conn = _auth(profile)
    return conn.show_security_group_rule(security_group_rule_id)

def create_security_group_rule(security_group,
                               remote_group_id=None,
                               direction='ingress',
                               protocol=None,
                               port_range_min=None,
                               port_range_max=None,
                               ethertype='IPv4',
                               profile=None):
    '''
    Creates a new security group rule

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_security_group_rule security-group-rule-id

    :param security_group: Security group name or ID to add rule
    :param remote_group_id: Remote security group name or ID to
            apply rule (Optional)
    :param direction: Direction of traffic: ingress/egress,
            default: ingress (Optional)
    :param protocol: Protocol of packet: null/icmp/tcp/udp,
            default: null (Optional)
    :param port_range_min: Starting port range (Optional)
    :param port_range_max: Ending port range (Optional)
    :param ethertype: IPv4/IPv6, default: IPv4 (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created security group rule information
    '''
    conn = _auth(profile)
    return conn.create_security_group_rule(security_group,
                                           remote_group_id,
                                           direction,
                                           protocol,
                                           port_range_min,
                                           port_range_max,
                                           ethertype)

def delete_security_group_rule(security_group_rule_id, profile=None):
    '''
    Deletes the specified security group rule

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_security_group_rule security-group-rule-id

    :param security_group_rule_id: ID of security group rule to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_security_group_rule(security_group_rule_id)

def list_vpnservices(retrieve_all=True, profile=None, **kwargs):
    '''
    Fetches a list of all configured VPN services for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_vpnservices

    :param retrieve_all: True or False, default: True (Optional)
    :param profile: Profile to build on (Optional)
    :return: List of VPN service
    '''
    conn = _auth(profile)
    return conn.list_vpnservices(retrieve_all, **kwargs)

def show_vpnservice(vpnservice, profile=None, **kwargs):
    '''
    Fetches information of a specific VPN service

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_vpnservice vpnservice-name

    :param vpnservice: ID or name of vpn service to look up
    :param profile: Profile to build on (Optional)
    :return: VPN service information
    '''
    conn = _auth(profile)
    return conn.show_vpnservice(vpnservice, **kwargs)

def create_vpnservice(subnet, router, name, admin_state_up=True, profile=None):
    '''
    Creates a new VPN service

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_vpnservice router-name name

    :param subnet: Subnet unique identifier for the VPN service deployment
    :param router: Router unique identifier for the VPN service
    :param name: Set a name for the VPN service
    :param admin_state_up: Set admin state up to true or false,
            default:True (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created VPN service information
    '''
    conn = _auth(profile)
    return conn.create_vpnservice(subnet, router, name, admin_state_up)

def update_vpnservice(vpnservice, desc, profile=None):
    '''
    Updates a VPN service

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_vpnservice vpnservice-name desc='VPN Service1'

    :param vpnservice: ID or name of vpn service to update
    :param desc: Set a description for the VPN service
    :param profile: Profile to build on (Optional)
    :return: Value of updated VPN service information
    '''
    conn = _auth(profile)
    return conn.update_vpnservice(vpnservice, desc)

def delete_vpnservice(vpnservice, profile=None):
    '''
    Deletes the specified VPN service

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_vpnservice vpnservice-name

    :param vpnservice: ID or name of vpn service to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_vpnservice(vpnservice)

def list_ipsec_site_connections(profile=None):
    '''
    Fetches all configured IPsec Site Connections for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_ipsec_site_connections
        salt '*' neutron.list_ipsec_site_connections profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of IPSec site connection
    '''
    conn = _auth(profile)
    return conn.list_ipsec_site_connections()

def show_ipsec_site_connection(ipsec_site_connection, profile=None):
    '''
    Fetches information of a specific IPsecSiteConnection

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_ipsec_site_connection connection-name

    :param ipsec_site_connection: ID or name of ipsec site connection
            to look up
    :param profile: Profile to build on (Optional)
    :return: IPSec site connection information
    '''
    conn = _auth(profile)
    return conn.show_ipsec_site_connection(ipsec_site_connection)

def create_ipsec_site_connection(name,
                                 ipsecpolicy,
                                 ikepolicy,
                                 vpnservice,
                                 peer_cidrs,
                                 peer_address,
                                 peer_id,
                                 psk,
                                 admin_state_up=True,
                                 profile=None,
                                 **kwargs):
    '''
    Creates a new IPsecSiteConnection

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_ipsec_site_connection connection-name
                ipsec-policy-name ikepolicy-name vpnservice-name
                192.168.XXX.XXX/24 192.168.XXX.XXX 192.168.XXX.XXX secret

    :param name: Set friendly name for the connection
    :param ipsecpolicy: IPSec policy ID or name associated with this connection
    :param ikepolicy: IKE policy ID or name associated with this connection
    :param vpnservice: VPN service instance ID or name associated with
            this connection
    :param peer_cidrs: Remote subnet(s) in CIDR format
    :param peer_address: Peer gateway public IPv4/IPv6 address or FQDN
    :param peer_id: Peer router identity for authentication
            Can be IPv4/IPv6 address, e-mail address, key id, or FQDN
    :param psk: Pre-shared key string
    :param initiator: Initiator state in lowercase, default:bi-directional
    :param admin_state_up: Set admin state up to true or false,
            default: True (Optional)
    :param mtu: size for the connection, default:1500 (Optional)
    :param dpd_action: Dead Peer Detection attribute: hold/clear/disabled/
            restart/restart-by-peer (Optional)
    :param dpd_interval: Dead Peer Detection attribute (Optional)
    :param dpd_timeout: Dead Peer Detection attribute (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created IPSec site connection information
    '''
    conn = _auth(profile)
    return conn.create_ipsec_site_connection(name,
                                             ipsecpolicy,
                                             ikepolicy,
                                             vpnservice,
                                             peer_cidrs,
                                             peer_address,
                                             peer_id,
                                             psk,
                                             admin_state_up,
                                             **kwargs)

def delete_ipsec_site_connection(ipsec_site_connection, profile=None):
    '''
    Deletes the specified IPsecSiteConnection

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_ipsec_site_connection connection-name

    :param ipsec_site_connection: ID or name of ipsec site connection to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_ipsec_site_connection(ipsec_site_connection)

def list_ikepolicies(profile=None):
    '''
    Fetches a list of all configured IKEPolicies for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_ikepolicies
        salt '*' neutron.list_ikepolicies profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of IKE policy
    '''
    conn = _auth(profile)
    return conn.list_ikepolicies()

def show_ikepolicy(ikepolicy, profile=None):
    '''
    Fetches information of a specific IKEPolicy

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_ikepolicy ikepolicy-name

    :param ikepolicy: ID or name of ikepolicy to look up
    :param profile: Profile to build on (Optional)
    :return: IKE policy information
    '''
    conn = _auth(profile)
    return conn.show_ikepolicy(ikepolicy)

def create_ikepolicy(name, profile=None, **kwargs):
    '''
    Creates a new IKEPolicy

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_ikepolicy ikepolicy-name
                phase1_negotiation_mode=main auth_algorithm=sha1
                encryption_algorithm=aes-128 pfs=group5

    :param name: Name of the IKE policy
    :param phase1_negotiation_mode: IKE Phase1 negotiation mode in lowercase,
            default: main (Optional)
    :param auth_algorithm: Authentication algorithm in lowercase,
            default: sha1 (Optional)
    :param encryption_algorithm: Encryption algorithm in lowercase.
            default:aes-128 (Optional)
    :param pfs: Prefect Forward Security in lowercase,
            default: group5 (Optional)
    :param units: IKE lifetime attribute. default: seconds (Optional)
    :param value: IKE lifetime attribute. default: 3600 (Optional)
    :param ike_version: IKE version in lowercase, default: v1 (Optional)
    :param profile: Profile to build on (Optional)
    :param kwargs:
    :return: Created IKE policy information
    '''
    conn = _auth(profile)
    return conn.create_ikepolicy(name, **kwargs)

def delete_ikepolicy(ikepolicy, profile=None):
    '''
    Deletes the specified IKEPolicy

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_ikepolicy ikepolicy-name

    :param ikepolicy: ID or name of IKE policy to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_ikepolicy(ikepolicy)

def list_ipsecpolicies(profile=None):
    '''
    Fetches a list of all configured IPsecPolicies for a tenant

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_ipsecpolicies ipsecpolicy-name
        salt '*' neutron.list_ipsecpolicies ipsecpolicy-name profile=openstack1

    :param profile: Profile to build on (Optional)
    :return: List of IPSec policy
    '''
    conn = _auth(profile)
    return conn.list_ipsecpolicies()

def show_ipsecpolicy(ipsecpolicy, profile=None):
    '''
    Fetches information of a specific IPsecPolicy

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_ipsecpolicy ipsecpolicy-name

    :param ipsecpolicy: ID or name of IPSec policy to look up
    :param profile: Profile to build on (Optional)
    :return: IPSec policy information
    '''
    conn = _auth(profile)
    return conn.show_ipsecpolicy(ipsecpolicy)

def create_ipsecpolicy(name, profile=None, **kwargs):
    '''
    Creates a new IPsecPolicy

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_ipsecpolicy ipsecpolicy-name
                transform_protocol=esp auth_algorithm=sha1
                encapsulation_mode=tunnel encryption_algorithm=aes-128

    :param name: Name of the IPSec policy
    :param transform_protocol: Transform protocol in lowercase,
            default: esp (Optional)
    :param auth_algorithm: Authentication algorithm in lowercase,
            default: sha1 (Optional)
    :param encapsulation_mode: Encapsulation mode in lowercase,
            default: tunnel (Optional)
    :param encryption_algorithm: Encryption algorithm in lowercase,
            default:aes-128 (Optional)
    :param pfs: Prefect Forward Security in lowercase,
            default: group5 (Optional)
    :param units: IPSec lifetime attribute. default: seconds (Optional)
    :param value: IPSec lifetime attribute. default: 3600 (Optional)
    :param profile: Profile to build on (Optional)
    :return: Created IPSec policy information
    '''
    conn = _auth(profile)
    return conn.create_ipsecpolicy(name, **kwargs)

def delete_ipsecpolicy(ipsecpolicy, profile=None):
    '''
    Deletes the specified IPsecPolicy

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_ipsecpolicy ipsecpolicy-name

    :param ipsecpolicy: ID or name of IPSec policy to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_ipsecpolicy(ipsecpolicy)

def list_firewall_rules(profile=None):
    '''
    Fetches a list of all firewall rules for a tenant
    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_firewall_rules

    :param profile: Profile to build on (Optional)

    :return: List of firewall rules
    '''
    conn = _auth(profile)
    return conn.list_firewall_rules()

def show_firewall_rule(firewall_rule, profile=None):
    '''
    Fetches information of a specific firewall rule

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_firewall_rule firewall-rule-name

    :param ipsecpolicy: ID or name of firewall rule to look up

    :param profile: Profile to build on (Optional)

    :return: firewall rule information
    '''
    conn = _auth(profile)
    return conn.show_firewall_rule(firewall_rule)

def create_firewall_rule(protocol, action, profile=None, **kwargs):
    '''
    Creates a new firewall rule

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.create_firewall_rule protocol action
                tenant_id=TENANT_ID name=NAME description=DESCRIPTION ip_version=IP_VERSION
                source_ip_address=SOURCE_IP_ADDRESS destination_ip_address=DESTINATION_IP_ADDRESS source_port=SOURCE_PORT
                destination_port=DESTINATION_PORT shared=SHARED enabled=ENABLED

    :param protocol: Protocol for the firewall rule, choose "tcp","udp","icmp" or "None".
    :param action: Action for the firewall rule, choose "allow" or "deny".
    :param tenant_id: The owner tenant ID. (Optional)
    :param name: Name for the firewall rule. (Optional)
    :param description: Description for the firewall rule. (Optional)
    :param ip_version: IP protocol version, default: 4. (Optional)
    :param source_ip_address: Source IP address or subnet. (Optional)
    :param destination_ip_address: Destination IP address or subnet. (Optional)
    :param source_port: Source port (integer in [1, 65535] or range in a:b). (Optional)
    :param destination_port: Destination port (integer in [1, 65535] or range in a:b). (Optional)
    :param shared: Set shared to True, default: False. (Optional)
    :param enabled: To enable this rule, default: True. (Optional)
    '''
    conn = _auth(profile)
    return conn.create_firewall_rule(protocol, action, **kwargs)

def delete_firewall_rule(firewall_rule, profile=None):
    '''
    Deletes the specified firewall_rule

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.delete_firewall_rule firewall-rule

    :param firewall_rule: ID or name of firewall rule to delete
    :param profile: Profile to build on (Optional)
    :return: True(Succeed) or False
    '''
    conn = _auth(profile)
    return conn.delete_firewall_rule(firewall_rule)

def update_firewall_rule(firewall_rule,
                         protocol=None,
                         action=None,
                         name=None,
                         description=None,
                         ip_version=None,
                         source_ip_address=None,
                         destination_ip_address=None,
                         source_port=None,
                         destination_port=None,
                         shared=None,
                         enabled=None,
                         profile=None):
    '''
    Update a firewall rule

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.update_firewall_rule firewall_rule protocol=PROTOCOL action=ACTION
                name=NAME description=DESCRIPTION ip_version=IP_VERSION
                source_ip_address=SOURCE_IP_ADDRESS destination_ip_address=DESTINATION_IP_ADDRESS
                source_port=SOURCE_PORT destination_port=DESTINATION_PORT shared=SHARED enabled=ENABLED

    :param firewall_rule: ID or name of firewall rule to update.
    :param protocol: Protocol for the firewall rule, choose "tcp","udp","icmp" or "None". (Optional)
    :param action: Action for the firewall rule, choose "allow" or "deny". (Optional)
    :param name: Name for the firewall rule. (Optional)
    :param description: Description for the firewall rule. (Optional)
    :param ip_version: IP protocol version, default: 4. (Optional)
    :param source_ip_address: Source IP address or subnet. (Optional)
    :param destination_ip_address: Destination IP address or subnet. (Optional)
    :param source_port: Source port (integer in [1, 65535] or range in a:b). (Optional)
    :param destination_port: Destination port (integer in [1, 65535] or range in a:b). (Optional)
    :param shared: Set shared to True, default: False. (Optional)
    :param enabled: To enable this rule, default: True. (Optional)
    :param profile: Profile to build on (Optional)
    '''
    conn = _auth(profile)
    return conn.update_firewall_rule(firewall_rule, protocol, action, name, description, ip_version,
                                     source_ip_address, destination_ip_address, source_port, destination_port,
                                     shared, enabled)

def list_firewalls(profile=None):
    '''
    Fetches a list of all firewalls for a tenant
    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_firewalls
    :param profile: Profile to build on (Optional)
    :return: List of firewalls
    '''
    conn = _auth(profile)
    return conn.list_firewalls()

def show_firewall(firewall, profile=None):
    '''
    Fetches information of a specific firewall rule

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.show_firewall firewall

    :param firewall: ID or name of firewall to look up
    :param profile: Profile to build on (Optional)
    :return: firewall information
    '''
    conn = _auth(profile)
    return conn.show_firewall(firewall)

def list_l3_agent_hosting_routers(router, profile=None):
    '''
    List L3 agents hosting a router.

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_l3_agent_hosting_routers router

    :param router:router name or ID to query.
    :param profile: Profile to build on (Optional)
    :return: L3 agents message.
    '''
    conn = _auth(profile)
    return conn.list_l3_agent_hosting_routers(router)

def list_agents(profile=None):
    '''
    List agents.

    CLI Example:

    .. code-block:: bash

        salt '*' neutron.list_agents

    :param profile: Profile to build on (Optional)
    :return: agents message.
    '''
    conn = _auth(profile)
    return conn.list_agents()

# The following is a list of functions that need to be incorporated in the
# neutron module. This list should be updated as functions are added.
#
# update_ipsec_site_connection
#                       Updates an IPsecSiteConnection.
# update_ikepolicy      Updates an IKEPolicy
# update_ipsecpolicy    Updates an IPsecPolicy
# list_vips             Fetches a list of all load balancer vips for a tenant.
# show_vip              Fetches information of a certain load balancer vip.
# create_vip            Creates a new load balancer vip.
# update_vip            Updates a load balancer vip.
# delete_vip            Deletes the specified load balancer vip.
# list_pools            Fetches a list of all load balancer pools for a tenant.
# show_pool             Fetches information of a certain load balancer pool.
# create_pool           Creates a new load balancer pool.
# update_pool           Updates a load balancer pool.
# delete_pool           Deletes the specified load balancer pool.
# retrieve_pool_stats   Retrieves stats for a certain load balancer pool.
# list_members          Fetches a list of all load balancer members for
#                       a tenant.
# show_member           Fetches information of a certain load balancer member.
# create_member         Creates a new load balancer member.
# update_member         Updates a load balancer member.
# delete_member         Deletes the specified load balancer member.
# list_health_monitors  Fetches a list of all load balancer health monitors for
#                       a tenant.
# show_health_monitor   Fetches information of a certain load balancer
#                       health monitor.
# create_health_monitor
#                       Creates a new load balancer health monitor.
# update_health_monitor
#                       Updates a load balancer health monitor.
# delete_health_monitor
#                       Deletes the specified load balancer health monitor.
# associate_health_monitor
#                       Associate  specified load balancer health monitor
#                       and pool.
# disassociate_health_monitor
#                       Disassociate specified load balancer health monitor
#                       and pool.
# create_qos_queue      Creates a new queue.
# list_qos_queues       Fetches a list of all queues for a tenant.
# show_qos_queue        Fetches information of a certain queue.
# delete_qos_queue      Deletes the specified queue.
# list_agents           Fetches agents.
# show_agent            Fetches information of a certain agent.
# update_agent          Updates an agent.
# delete_agent          Deletes the specified agent.
# list_network_gateways
#                       Retrieve network gateways.
# show_network_gateway  Fetch a network gateway.
# create_network_gateway
#                       Create a new network gateway.
# update_network_gateway
#                       Update a network gateway.
# delete_network_gateway
#                       Delete the specified network gateway.
# connect_network_gateway
#                       Connect a network gateway to the specified network.
# disconnect_network_gateway
#                       Disconnect a network from the specified gateway.
# list_gateway_devices  Retrieve gateway devices.
# show_gateway_device   Fetch a gateway device.
# create_gateway_device
#                       Create a new gateway device.
# update_gateway_device
#                       Updates a new gateway device.
# delete_gateway_device
#                       Delete the specified gateway device.
# list_dhcp_agent_hosting_networks
#                       Fetches a list of dhcp agents hosting a network.
# list_networks_on_dhcp_agent
#                       Fetches a list of dhcp agents hosting a network.
# add_network_to_dhcp_agent
#                       Adds a network to dhcp agent.
# remove_network_from_dhcp_agent
#                       Remove a network from dhcp agent.
# list_l3_agent_hosting_routers
#                       Fetches a list of L3 agents hosting a router.
# list_routers_on_l3_agent
#                       Fetches a list of L3 agents hosting a router.
# add_router_to_l3_agent
#                       Adds a router to L3 agent.
# list_firewall_rules   Fetches a list of all firewall rules for a tenant.
# show_firewall_rule    Fetches information of a certain firewall rule.
# create_firewall_rule  Creates a new firewall rule.
# update_firewall_rule  Updates a firewall rule.
# delete_firewall_rule  Deletes the specified firewall rule.
# list_firewall_policies
#                       Fetches a list of all firewall policies for a tenant.
# show_firewall_policy  Fetches information of a certain firewall policy.
# create_firewall_policy
#                       Creates a new firewall policy.
# update_firewall_policy
#                       Updates a firewall policy.
# delete_firewall_policy
#                       Deletes the specified firewall policy.
# firewall_policy_insert_rule
#                       Inserts specified rule into firewall policy.
# firewall_policy_remove_rule
#                       Removes specified rule from firewall policy.
# list_firewalls        Fetches a list of all firewals for a tenant.
# show_firewall         Fetches information of a certain firewall.
# create_firewall       Creates a new firewall.
# update_firewall       Updates a firewall.
# delete_firewall       Deletes the specified firewall.
# remove_router_from_l3_agent
#                       Remove a router from l3 agent.
# get_lbaas_agent_hosting_pool
#                       Fetches a loadbalancer agent hosting a pool.
# list_pools_on_lbaas_agent
#                       Fetches a list of pools hosted by
#                       the loadbalancer agent.
# list_service_providers
#                       Fetches service providers.
# list_credentials      Fetch a list of all credentials for a tenant.
# show_credential       Fetch a credential.
# create_credential     Create a new credential.
# update_credential     Update a credential.
# delete_credential     Delete the specified credential.
# list_network_profile_bindings
#                       Fetch a list of all tenants associated for
#                       a network profile.
# list_network_profiles
#                       Fetch a list of all network profiles for a tenant.
# show_network_profile  Fetch a network profile.
# create_network_profile
#                       Create a network profile.
# update_network_profile
#                       Update a network profile.
# delete_network_profile
#                       Delete the network profile.
# list_policy_profile_bindings
#                       Fetch a list of all tenants associated for
#                       a policy profile.
# list_policy_profiles  Fetch a list of all network profiles for a tenant.
# show_policy_profile   Fetch a network profile.
# update_policy_profile
#                       Update a policy profile.
# create_metering_label
#                       Creates a metering label.
# delete_metering_label
#                       Deletes the specified metering label.
# list_metering_labels  Fetches a list of all metering labels for a tenant.
# show_metering_label   Fetches information of a certain metering label.
# create_metering_label_rule
#                       Creates a metering label rule.
# delete_metering_label_rule
#                       Deletes the specified metering label rule.
# list_metering_label_rules
#                       Fetches a list of all metering label rules for a label.
# show_metering_label_rule
#                       Fetches information of a certain metering label rule.
# list_net_partitions   Fetch a list of all network partitions for a tenant.
# show_net_partition    etch a network partition.
# create_net_partition  Create a network partition.
# delete_net_partition  Delete the network partition.
# create_packet_filter  Create a new packet filter.
# update_packet_filter  Update a packet filter.
# list_packet_filters   Fetch a list of all packet filters for a tenant.
# show_packet_filter    Fetch information of a certain packet filter.
# delete_packet_filter  Delete the specified packet filter.


text:
using Sample.Functions.FunctionFactories;

namespace Sample.Functions
{
    /// <summary>
    /// This provides interfaces to the <see cref="GetArmTemplateDirectoriesFunction"/> class.
    /// </summary>
    public interface IGetArmTemplateDirectoriesFunction : IFunction
    {
    }
}

redpajama_set_name: RedPajamaGithub


text:
import React from 'react';

export default function() {
  return (
    <div className="social">
      <div
        className="fb-like"
        data-href="http://sundar-nepal.subash.me/"
        data-layout="standard"
        data-action="like"
        data-show-faces="false"
        data-share="true"
      />
    </div>
  );
}


text:
using Microsoft.Xrm.Sdk;
using System;
using System.Collections.Generic;

namespace XrmFramework
{
    /// <summary>
    /// Maps a <see cref="Type"/> from a <c>PropertyType.GenericTypeArguments</c> to a corresponding <see cref="CustomApiArgumentType"/>
    /// </summary>
    public static class CustomApiArgumentTypeMapper
    {
        private static readonly Dictionary<Type, CustomApiArgumentType> Mapper = new();

        static CustomApiArgumentTypeMapper()
        {
            Mapper.Add(typeof(bool), CustomApiArgumentType.Boolean);
            Mapper.Add(typeof(DateTime), CustomApiArgumentType.DateTime);
            Mapper.Add(typeof(decimal), CustomApiArgumentType.Decimal);
            Mapper.Add(typeof(Entity), CustomApiArgumentType.Entity);
            Mapper.Add(typeof(EntityCollection), CustomApiArgumentType.EntityCollection);
            Mapper.Add(typeof(EntityReference), CustomApiArgumentType.EntityReference);
            Mapper.Add(typeof(float), CustomApiArgumentType.Float);
            Mapper.Add(typeof(int), CustomApiArgumentType.Integer);
            Mapper.Add(typeof(Money), CustomApiArgumentType.Money);
            Mapper.Add(typeof(OptionSetValue), CustomApiArgumentType.Picklist);
            Mapper.Add(typeof(string), CustomApiArgumentType.String);
            Mapper.Add(typeof(string[]), CustomApiArgumentType.StringArray);
            Mapper.Add(typeof(Guid), CustomApiArgumentType.Guid);
        }

        /// <summary>
        /// Maps the given <see cref="Type"/> to the corresponding <see cref="CustomApiArgumentType"/>
        /// and puts it in <paramref name="argumentType"/>
        /// If not found, <paramref name="argumentType"/> is set to <see cref="CustomApiArgumentType.String"/> and returns false
        /// </summary>
        /// <param name="type"></param>
        /// <param name="argumentType"></param>
        /// <returns><c>True</c> if the given <paramref name="type"/> matches a <see cref="CustomApiArgumentType"/>, <c>False</c> otherwise</returns>
        public static bool TryMap(Type type, out CustomApiArgumentType argumentType)
        {
            if (type.IsEnum)
            {
                argumentType = CustomApiArgumentType.Picklist;
                return true;
            }
            if (Mapper.TryGetValue(type, out argumentType)) return true;

            argumentType = CustomApiArgumentType.String;
            return false;
        }
    }
}


text:
namespace taskpp
{

namespace detail
{

struct empty_handler { };

template<typename Handler>
struct basic_yield_context
{
	typedef std::function<void()> timeout_handler_type;

	basic_yield_context() : ec_(nullptr) { }
	explicit basic_yield_context(boost::system::error_code& ec) : ec_(&ec) { }

	basic_yield_context& operator()(const boost::chrono::steady_clock::time_point& time)
	{
		timeout_=time;
		return *this;
	}
	basic_yield_context& operator()(const boost::chrono::steady_clock::duration& duration)
	{
		timeout_=boost::chrono::steady_clock::now()+duration;
		return *this;
	}
	template<typename TimeoutHandler,
		typename = typename std::enable_if<std::is_function<TimeoutHandler>::value>::type>
	basic_yield_context& operator()(TimeoutHandler&& handler)
	{
		timeout_handler_=handler;
		return *this;
	}
	template<typename Socket>
	basic_yield_context& operator()(Socket& socket)
	{
		timeout_handler_=[&socket]() {
			socket.cancel();
		};
		return *this;
	}

	void wait(const int& ready)
	{
		if(timeout_>=boost::chrono::steady_clock::now())
		{
			taskpp::this_task::sleep_until(timeout_, &timeout_);
		}
		else
		{
			taskpp::this_task::self()->suspend();
			taskpp::this_task::yield();
		}
		if(ready!=0) //timeout
		{
			//should cancel operation or close socket
			if(timeout_handler_) timeout_handler_();
			//continue to wait for asynchronous operation abort
			taskpp::this_task::self()->suspend();
			taskpp::this_task::yield();
		}
	}

	const boost::chrono::steady_clock::time_point* valid_time() const
	{
		return (timeout_ == boost::chrono::steady_clock::time_point()) ? nullptr : &timeout_;
	}

	boost::system::error_code* ec_;
	boost::chrono::steady_clock::time_point timeout_;
	timeout_handler_type timeout_handler_;
};

typedef basic_yield_context<empty_handler> yield_context;

void resume_asio_task(base_task* task, const boost::chrono::steady_clock::time_point*);

template<typename Handler, typename T>
class async_handler
{
public:
	async_handler(const yield_context& ctx)
		: ready_(nullptr), ctx_(const_cast<yield_context*>(&ctx)), value_(nullptr)
	{
		task_=taskpp::this_task::self();
	}

	void operator()(T&& value)
	{
		*ctx_->ec_ = boost::system::error_code();
		*value_ = std::forward<T>(value);
		if (--*ready_ == 0)
		{
			resume_asio_task(task_, ctx_->valid_time());
		}
	}

	void operator()(boost::system::error_code ec, T value)
	{
		*ctx_->ec_ = ec;
		*value_ = std::forward<T>(value);
		if (--*ready_ == 0)
		{
			resume_asio_task(task_, ctx_->valid_time());
		}
	}

	taskpp::base_task* task_;
	int* ready_;
	yield_context* ctx_;
	T* value_;
};

template<typename Handler>
class async_handler<Handler, void>
{
public:
	async_handler(const yield_context& ctx)
		: ready_(nullptr), ctx_(const_cast<yield_context*>(&ctx))
	{
		task_=taskpp::this_task::self();
	}

	void operator()()
	{
		*ctx_->ec_ = boost::system::error_code();
		if (--*ready_ == 0)
		{
			resume_asio_task(task_, ctx_->valid_time());
		}
	}

	void operator()(boost::system::error_code ec)
	{
		*ctx_->ec_ = ec;
		if (--*ready_ == 0)
		{
			resume_asio_task(task_, ctx_->valid_time());
		}
	}

	taskpp::base_task* task_;
	int* ready_;
	yield_context* ctx_;
};

class base_asio_thread : public base_work_thread
{
public:
	base_asio_thread() : service_(1) { }
	boost::asio::io_service& service() { return service_; }

	virtual void resume_task(base_task* task, const boost::chrono::steady_clock::time_point* timer)=0;

protected:
	boost::asio::io_service service_;
};

inline void resume_asio_task(base_task* task, const boost::chrono::steady_clock::time_point* timer=nullptr)
{
	base_asio_thread* thread=dynamic_cast<base_asio_thread*>(base_task_scheduler::this_thread());
	if(thread)
		thread->resume_task(task, timer);
}

template<class Queue, class ThreadEntry=empty_entry, class StackAllocator=fixedsize_stack>
class asio_thread : public work_thread<base_asio_thread, Queue, ThreadEntry, StackAllocator>
{
	typedef work_thread<base_asio_thread, Queue, ThreadEntry, StackAllocator> base;
public:
	typedef task_scheduler<Queue, ThreadEntry, StackAllocator, asio_thread> scheduler_type;

	explicit asio_thread(base_task_scheduler* scheduler)
		: base(scheduler), timer_(this->service_)
	{
	}
	~asio_thread()
	{
		if(!this->service_.stopped())
			this->service_.stop();
	}

	virtual void init() override
	{
		this->stealing();
		this->thread_ = std::thread(&asio_thread::run, this);
	}

	bool push(const task_ptr& task, bool force=false) override
	{
		if(this->task_queue_.try_push(task, force) == boost::queue_op_status::success)
		{
			this->service_.post([this]() {
			});
			return true;
		}
		return false;
	}

	virtual void run() override
	{
		typename base::markup_thread markup(this);
		ThreadEntry entry;
		boost::system::error_code ec;
		entry;
		while(1)
		{
			size_t actived_count = 0;
			boost::chrono::steady_clock::time_point suspend_time;
			do
			{
				suspend_time = this->wakeup_tasks();
				actived_count = this->resume_workers();
				if (this->task_queue_.empty())
					this->stealing();
			} while (actived_count > 0 && this->task_queue_.empty());
			//pickup task and don't blocking
			if(!this->pull(false, suspend_time))
				break;
			//run asio's handlers
			while(this->service_.poll(ec));
			//waiting for timer
			if(actived_count==0 && suspend_time>boost::chrono::steady_clock::now())
			{
				wait_for_schedule(suspend_time);
				this->service_.run_one(ec);
				while(this->service_.poll(ec));
			}
		}
		//waiting for all tasks is stoped.
		while (!this->running_tasks_.empty())
		{
			boost::chrono::steady_clock::time_point suspend_time = this->wakeup_tasks();
			size_t actived_count= this->resume_workers();
			while(this->service_.poll(ec));
			if(suspend_time>boost::chrono::steady_clock::now())
			{
				wait_for_schedule(suspend_time);
				this->service_.run_one();
			}
		}
		this->stoped_ = true;
		this->release_stacks();
	}

	virtual void resume_task(base_task* task, const boost::chrono::steady_clock::time_point* timer) override
	{
		if(timer)
		{
			auto it=this->sleeping_tasks_.find(*timer);
			if(it!=this->sleeping_tasks_.end())
			{
				auto it_task = std::find(it->second.begin(), it->second.end(), task);
				if(it_task!=it->second.end()) it->second.erase(it_task);
				if(it->second.empty())
					this->sleeping_tasks_.erase(it);
			}
		}
		this->current_task_ = task;
		task->resume();
		if(!this->resume_coroutine(task->coroutine(), false))
		{
			auto it=this->running_tasks_.begin();
			while(it!=this->running_tasks_.end())
			{
				if(it->get()==task)
				{
					this->running_tasks_.erase(it);
					break;
				}
				++it;
			}
		}
		this->current_task_=nullptr;
	}

private:
	boost::asio::basic_waitable_timer<boost::chrono::steady_clock> timer_;

	void wait_for_schedule(const boost::chrono::steady_clock::time_point& next_time)
	{
		if(timer_.expires_at() < boost::chrono::steady_clock::now())
		{
			timer_.expires_at(next_time);
			timer_.async_wait([this](const boost::system::error_code& ec) {
			});
		}
	}
};

}

}

namespace boost
{

namespace asio
{

template <typename Handler, typename ReturnType>
struct handler_type<taskpp::detail::basic_yield_context<Handler>, ReturnType()>
{
	typedef taskpp::detail::async_handler<Handler, void> type;
};

template <typename Handler, typename ReturnType, typename Arg1>
struct handler_type<taskpp::detail::basic_yield_context<Handler>, ReturnType(Arg1)>
{
	typedef taskpp::detail::async_handler<Handler, Arg1> type;
};

template <typename Handler, typename ReturnType>
struct handler_type<taskpp::detail::basic_yield_context<Handler>,
	ReturnType(boost::system::error_code)>
{
	typedef taskpp::detail::async_handler<Handler, void> type;
};

template <typename Handler, typename ReturnType, typename Arg2>
struct handler_type<taskpp::detail::basic_yield_context<Handler>,
	ReturnType(boost::system::error_code, Arg2)>
{
	typedef taskpp::detail::async_handler<Handler, Arg2> type;
};

template <typename Handler, typename T>
class async_result<taskpp::detail::async_handler<Handler, T> >
{
public:
	typedef T type;

	explicit async_result(taskpp::detail::async_handler<Handler, T>& h)
		: handler_(h), task_(h.task_), ctx_(*h.ctx_), ready_(2), value_(T())
	{
		handler_.ready_=&ready_;
		handler_.ctx_=&ctx_;
		out_ec_ = ctx_.ec_;
		if(!out_ec_) ctx_.ec_=&ec_;
		handler_.value_=&value_;
	}

	type&& get()
	{
		if (--ready_ != 0)
		{	// set io timeout
			ctx_.wait(ready_);
		}
		if (!out_ec_ && ec_) throw boost::system::system_error(ec_);
		return std::forward<type>(value_);
	}

private:
	taskpp::detail::async_handler<Handler, T>& handler_;
	taskpp::base_task* task_;
	int ready_;
	taskpp::detail::yield_context ctx_;
	boost::system::error_code* out_ec_;
	boost::system::error_code ec_;
	type value_;
};

template <typename Handler>
class async_result<taskpp::detail::async_handler<Handler, void> >
{
public:
	typedef void type;

	explicit async_result(taskpp::detail::async_handler<Handler, void>& h)
		: handler_(h), task_(h.task_), ctx_(*h.ctx_), ready_(2)
	{
		handler_.ready_=&ready_;
		handler_.ctx_=&ctx_;
		out_ec_ = ctx_.ec_;
		if(!out_ec_) ctx_.ec_=&ec_;
	}

	void get()
	{
		if (--ready_ != 0)
		{	// set io timeout
			ctx_.wait(ready_);
		}
		if (!out_ec_ && ec_) throw boost::system::system_error(ec_);
	}

private:
	taskpp::detail::async_handler<Handler, void>& handler_;
	taskpp::base_task* task_;
	int ready_;
	taskpp::detail::yield_context ctx_;
	boost::system::error_code* out_ec_;
	boost::system::error_code ec_;
};

}

}

#endif //_TASKPP_DETAIL_ASIO_H_


text:
"""Generic proxy to access any DFA web service."""

__author__ = 'api.jdilallo@gmail.com (Joseph DiLallo)'

import warnings

from adspygoogle import SOAPpy
from adspygoogle.common import Utils
from adspygoogle.common.Errors import Error
from adspygoogle.common.GenericApiService import GenericApiService
from adspygoogle.common.GenericApiService import MethodInfoKeys
from adspygoogle.dfa import DfaUtils
from adspygoogle.dfa import LIB_SIG
from adspygoogle.dfa import LIB_URL
from adspygoogle.dfa import WSSE_NS
from adspygoogle.dfa.DfaErrors import DfaApiError
from adspygoogle.dfa.DfaErrors import DfaAuthenticationError
from adspygoogle.dfa.DfaSoapBuffer import DfaSoapBuffer

_DEPRECATION_WARNING = ('Legacy DFA passwords are deprecated. Please use '
                        'OAuth 2.0')
warnings.filterwarnings('always', _DEPRECATION_WARNING, DeprecationWarning)

class GenericDfaService(GenericApiService):

  """Wrapper for any DFA web service."""

  # The _WRAP_LISTS constant indicates that all DFA services need to wrap lists
  # in an extra layer of XML element tags.
  _WRAP_LISTS = True
  # The _BUFFER_CLASS is the subclass of SoapBuffer that should be used to track
  # all SOAP interactions.
  _BUFFER_CLASS = DfaSoapBuffer
  # The _TOKEN_EXPIRED_ERROR_MESSAGE is returned by the DFA API when a DFA token
  # needs to be refreshed.
  _TOKEN_EXPIRED_ERROR_MESSAGE = 'Authentication token has expired.'

  def __init__(self, headers, config, op_config, lock, logger, service_name):
    """Inits GenericDfaService.

    Args:
      headers: dict Dictionary object with populated authentication
               credentials.
      config: dict Dictionary object with populated configuration values.
      op_config: dict Dictionary object with additional configuration values for
                 this operation.
      lock: threading.RLock Thread lock to use to synchronize requests.
      logger: Logger Instance of Logger to use for logging.
      service_name: string The name of this service.
    """
    service_url = '/'.join([op_config['server'], op_config['version'],
                            'api/dfa-api', service_name])
    namespace = '/'.join(['http://www.doubleclick.net/dfa-api',
                          op_config['version']])
    namespace_extractor = _DetermineNamespacePrefix

    super(GenericDfaService, self).__init__(
        headers, config, op_config, lock, logger, service_name, service_url,
        GenericDfaService._WRAP_LISTS, GenericDfaService._BUFFER_CLASS,
        namespace, namespace_extractor)

    # DFA-specific changes to the SOAPpy.WSDL.Proxy
    methodattrs = {
        'xmlns:dfa': self._namespace
    }
    self._soappyservice.soapproxy.methodattrs = methodattrs

  def _WrapSoapCall(self, soap_call_function):
    """Gives the service a chance to wrap a call in a product-specific function.

    DFA uses this function to listen for expired DDMM tokens and refresh them.
    Calls which fail due to expired tokens will be retried.

    Args:
      soap_call_function: function The function to make a SOAP call.

    Returns:
      function A new function wrapping the input function which listens for
      token expired errors and retries the failed call.
    """

    def RefreshTokenIfExpired(*args, **kargs):
      try:
        return soap_call_function(*args, **kargs)
      except DfaAuthenticationError, e:
        if e.message == self._TOKEN_EXPIRED_ERROR_MESSAGE:
          self._GenerateToken()
          return soap_call_function(*args, **kargs)
        else:
          raise e

    return RefreshTokenIfExpired

  def _SetHeaders(self):
    """Sets the SOAP headers for this service's requests."""
    soap_headers = SOAPpy.Types.headerType()
    if self._service_name != 'login':
      if 'AuthToken' not in self._headers or not self._headers['AuthToken']:
        self._GenerateToken()
      wsse_header = SOAPpy.Types.structType(
          data={
              'UsernameToken': {
                  'Username': self._headers['Username'],
                  'Password': self._headers['AuthToken']
              }
          },
          name='Security', typed=0, attrs={'xmlns': WSSE_NS})
      soap_headers.Security = wsse_header
    request_header = SOAPpy.Types.structType(
        data={'applicationName': ' '.join([self._config['app_name'], LIB_SIG])},
        name='RequestHeader', typed=0)
    soap_headers.RequestHeader = request_header
    self._soappyservice.soapproxy.header = soap_headers

  def _ReadyOAuth(self):
    """If OAuth is on, sets the transport handler to add OAuth2 HTTP header.

    DFA overrides the default implementation because only the login service
    should have this header.
    """
    if self._service_name == 'login':
      super(GenericDfaService, self)._ReadyOAuth()

  def _GetMethodInfo(self, method_name):
    """Pulls all of the relevant data about a method from a SOAPpy service.

    The return dictionary has two keys, MethodInfoKeys.INPUTS and
    MethodInfoKeys.OUTPUTS. Each of these keys has a list value. The list
    value contains a dictionary of information on each input/output parameter,
    in order.

    Args:
      method_name: string The name of the method to pull information for.

    Returns:
      dict A dictionary containing information about a SOAP method.
    """
    rval = {}
    rval[MethodInfoKeys.INPUTS] = []
    for i in range(len(self._soappyservice.methods[method_name].inparams)):
      param_attributes = self._soappyservice.methods[method_name].inparams[i]
      if hasattr(param_attributes, 'maxOccurs'):
        max_occurs = param_attributes.maxOccurs
      else:
        max_occurs = '1'
      inparam = {
          MethodInfoKeys.ELEMENT_NAME: param_attributes.name,
          MethodInfoKeys.NS: param_attributes.type[0],
          MethodInfoKeys.TYPE: param_attributes.type[1],
          MethodInfoKeys.MAX_OCCURS: max_occurs
      }
      rval[MethodInfoKeys.INPUTS].append(inparam)

    rval[MethodInfoKeys.OUTPUTS] = []
    for i in range(len(self._soappyservice.methods[method_name].outparams)):
      param_attributes = self._soappyservice.methods[method_name].outparams[i]
      if hasattr(param_attributes, 'maxOccurs'):
        max_occurs = param_attributes.maxOccurs
      else:
        max_occurs = '1'
      outparam = {
          MethodInfoKeys.ELEMENT_NAME: param_attributes.name,
          MethodInfoKeys.NS: param_attributes.type[0],
          MethodInfoKeys.TYPE: param_attributes.type[1],
          MethodInfoKeys.MAX_OCCURS: max_occurs
      }
      rval[MethodInfoKeys.OUTPUTS].append(outparam)
    return rval

  def _TakeActionOnSoapCall(self, method_name, args):
    """Gives the service a chance to take product-specific action on raw inputs.

    DFA will try to determine xsi_types for saveAd and saveCreative calls.

    Args:
      method_name: string The name of the SOAP operation being called.
      args: tuple The arguments passed into the SOAP operation.

    Returns:
      tuple The method arguments, possibly modified.
    """
    if method_name.lower() == 'savecreative':
      DfaUtils.AssignCreativeXsi(args[0])
    elif method_name.lower() == 'savead':
      DfaUtils.AssignAdXsi(args[0])
    return args

  def _ReadyCompression(self):
    """Sets whether the HTTP transport layer should use compression.

    Overloaded for DFA because the DFA servers do not accept compressed
    messages. They do support returning compressed messages.
    """
    compress = Utils.BoolTypeConvert(self._config['compress'])
    self._soappyservice.soapproxy.config.send_compressed = False
    self._soappyservice.soapproxy.config.accept_compressed = compress

  def _HandleLogsAndErrors(self, buf, start_time, stop_time, error=None):
    """Manage SOAP XML message.

    Args:
      buf: SoapBuffer SOAP buffer.
      start_time: str Time before service call was invoked.
      stop_time: str Time after service call was invoked.
      [optional]
      error: dict Error, if any.

    Raises:
      DfaApiError: if the API calls returns a SOAP error message.
      Error: if the call returns a non-SOAP error message, such as an HTTP 502.
    """
    if error is None:
      error = {}
    try:
      handlers = self.__GetLogHandlers(buf)

      fault = super(GenericDfaService, self)._ManageSoap(
          buf, handlers, LIB_URL, start_time, stop_time, error)
      if fault:
        # Raise a specific error, subclass of DfaApiError.
        if fault['detail'] is None: del fault['detail']
        if 'detail' in fault:
          if ('google' in fault['detail'] and
              'doubleclick' not in fault['detail']):
            fault['detail']['doubleclick'] = fault['detail']['google']
          if ('doubleclick' in fault['detail'] and
              'errorCode' in fault['detail']['doubleclick']):
            code = int(fault['detail']['doubleclick']['errorCode'])
            if code == 4:
              raise DfaAuthenticationError(fault)
            else:
              raise DfaApiError(fault)
        if isinstance(fault, (str, dict)):
          raise DfaApiError(fault)
    except DfaApiError, e:
      raise e
    except Error, e:
      if error: e = error
      raise Error(e)

  def _GenerateToken(self):
    """Attempts to generate a token for the WSSE security header.

    Raises:
      DfaAuthenticationError: if there are not enough credentials to generate a
                              token or if the given credentials are invalid.
    """
    if ('Username' in self._headers and
        ('Password' in self._headers or 'oauth2credentials' in self._headers)):
      if not self._headers.get('oauth2credentials'):
        warnings.warn(_DEPRECATION_WARNING, DeprecationWarning, stacklevel=5)
      # Ensure the 'raw_response' config value is off while generating tokens.
      old_raw_response = self._config['raw_response']
      self._config['raw_response'] = 'n'
      try:
        login_service = GenericDfaService(
            self._headers, self._config, self._op_config, self._lock,
            self._logger, 'login')
        self._headers['AuthToken'] = login_service.authenticate(
            self._headers['Username'],
            self._headers.get('Password'))[0]['token']
      finally:
        self._config['raw_response'] = old_raw_response
    else:
      fault = {
          'faultstring': ('Authentication data, username/password or username/'
                          'oauth2credentials, is missing.')
      }
      raise DfaAuthenticationError(fault)

  def __GetLogHandlers(self, buf):
    """Gets a list of log handlers for the DFA library.

    Args:
      buf: SoapBuffer SOAP buffer from which calls are retrieved for logging.

    Returns:
      list Log handlers for the DFA library.
    """
    return [
        {
            'tag': 'xml_log',
            'name': 'soap_xml',
            'data': ''
        },
        {
            'tag': 'request_log',
            'name': 'request_info',
            'data': str('host=%s service=%s method=%s responseTime=%s '
                        'requestID=%s'
                        % (Utils.GetNetLocFromUrl(self._service_url),
                           self._service_name, buf.GetCallName(),
                           buf.GetCallResponseTime(), buf.GetCallRequestId()))
        },
        {
            'tag': '',
            'name': 'dfa_api_lib',
            'data': ''
        }
    ]

def _DetermineNamespacePrefix(unused_url):
  """Returns the SOAP prefix to use for definitions within the given namespace.

  Args:
    unused_url: string The URL of the namespace. The DFA library doesn't
                actually check this value.

  Returns:
    string The SOAP namespace prefix to use for the given namespace. The DFA
           library always returns 'dfa:'.
  """
  return 'dfa:'


text:
/* sqMemoryAccess.h -- memory accessors (and associated type definitions)
 *
 * Author: Ian.Piumarta@squeakland.org
 *
 * Last edited: 2013-10-14 12:23:39 by eliot on McStalker
 */

/* Systematic use of the macros defined in this file within the Interpreter,
 * ObjectMemory and plugins will permit all four combinations of 32/64-bit
 * image and 32/64-bit host to compile and run correctly.  (Code that uses
 * explicit casts and/or integer constants in arithmetic on object pointers
 * will invariably fail in at least one of the four possible combinations.)
 */

#ifndef __sqMemoryAccess_h
#define __sqMemoryAccess_h

#include "config.h"
#include "interp.h"

#ifndef SIZEOF_LONG
#  if LLP64
#    define SIZEOF_LONG 4
#  else
#    define SIZEOF_LONG SIZEOF_VOID_P /* default is sizeof(long)==sizeof(void *) */
#  endif
#endif

#if (SQ_VI_BYTES_PER_WORD == 4)
# define SQ_IMAGE32 1
# define SQ_IMAGE64 0
#else
# define SQ_IMAGE64 1
# define SQ_IMAGE32 0
#endif

#if (SQ_IMAGE64 || SPURVM)
# define OBJECTS_64BIT_ALIGNED 1
# define OBJECTS_32BIT_ALIGNED 0
#else
# define OBJECTS_32BIT_ALIGNED 1
# define OBJECTS_64BIT_ALIGNED 0
#endif

#if (SIZEOF_VOID_P == 4)
# define SQ_HOST32 1
#elif (SIZEOF_VOID_P == 8)
# define SQ_HOST64 1
#else
# error host is neither 32- nor 64-bit?
#endif

/* sqInt is a signed integer with size adequate for holding an Object Oriented Pointer (or immediate value)
  - that is 32bits long on a 32bits image or 64bits long on a 64bits image
  we could use C99 int32_t and int64_t once retiring legacy compiler support this time has not yet come
  usqInt is the unsigned flavour
  SQABS is a macro for taking absolute value of an sqInt */
#if SQ_IMAGE32
  typedef int		sqInt;
  typedef unsigned int	usqInt;
#define PRIdSQINT "d"
#define PRIuSQINT "u"
#define PRIxSQINT "x"
#define PRIXSQINT "X"
# define SQABS abs
#elif SQ_HOST64 && (SIZEOF_LONG == 8)
  typedef long		sqInt;
  typedef unsigned long	usqInt;
#define PRIdSQINT "ld"
#define PRIuSQINT "lu"
#define PRIxSQINT "lx"
#define PRIXSQINT "lX"
# define SQABS labs
#elif (SIZEOF_LONG_LONG != 8)
#   error long long integers are not 64-bits wide?
#else
  typedef long long		sqInt;
  typedef unsigned long long	usqInt;
#define PRIdSQINT "lld"
#define PRIuSQINT "llu"
#define PRIxSQINT "llx"
#define PRIXSQINT "llX"
# define SQABS llabs
#endif

/* sqLong is a signed integer with at least 64bits on both 32 and 64 bits images
   usqLong is the unsigned flavour
   SQLABS is a macro for taking absolute value of a sqLong */
#if !defined(sqLong)
#  if SIZEOF_LONG == 8
#     define sqLong long
#     define usqLong unsigned long
#     define SQLABS labs
#  elif _MSC_VER
#     define sqLong __int64
#     define usqLong unsigned __int64
#     define SQLABS llabs
#  else
#     define sqLong long long
#     define usqLong unsigned long long
#     define SQLABS llabs
#  endif
#endif /* !defined(sqLong) */

/* sqIntptr_t is a signed integer with enough bits to hold a pointer
   usqIntptr_t is the unsigned flavour
   this is essentially C99 intptr_t and uintptr_t but we support legacy compilers
   the C99 printf formats macros are also defined with SQ prefix */
#if SIZEOF_LONG == SIZEOF_VOID_P
typedef long sqIntptr_t;
typedef unsigned long usqIntptr_t;
#define PRIdSQPTR "ld"
#define PRIuSQPTR "lu"
#define PRIxSQPTR "lx"
#define PRIXSQPTR "lX"
#else
typedef long long sqIntptr_t;
typedef unsigned long long usqIntptr_t;
#define PRIdSQPTR "lld"
#define PRIuSQPTR "llu"
#define PRIxSQPTR "llx"
#define PRIXSQPTR "llX"
#endif

#if SQ_HOST64 && SQ_IMAGE32
  extern char *sqMemoryBase;
# define SQ_FAKE_MEMORY_OFFSET	16 // (1*1024*1024)	/* nonzero to debug addr xlation */
#else
# define sqMemoryBase 0
#endif

#ifdef USE_INLINE_MEMORY_ACCESSORS
  /* Use static inline functions when the compiler produces efficient code for small accessors.
     These are preferred because static type checking will prevent inadvertent confusion of pointers and oops. */
  static inline sqInt byteAtPointer(char *ptr)			{ return (sqInt)(*((unsigned char *)ptr)); }
  static inline sqInt byteAtPointerput(char *ptr, int val)	{ return (sqInt)(*((unsigned char *)ptr)= (unsigned char)val); }
  static inline sqInt shortAtPointer(char *ptr)			{ return (sqInt)(*((short *)ptr)); }
  static inline sqInt shortAtPointerput(char *ptr, int val)	{ return (sqInt)(*((short *)ptr)= (short)val); }
  static inline sqInt intAtPointer(char *ptr)			{ return (sqInt)(*((int *)ptr)); }
  static inline sqInt intAtPointerput(char *ptr, int val)	{ return (sqInt)(*((int *)ptr)= val); }
  static inline sqInt longAtPointer(char *ptr)			{ return *(sqInt *)ptr; }
  static inline sqInt longAtPointerput(char *ptr, sqInt val)	{ return *(sqInt *)ptr= val; }
  static inline sqLong long64AtPointer(char *ptr)			{ return *(sqLong *)ptr; }
  static inline sqLong long64AtPointerput(char *ptr, sqLong val)	{ return *(sqLong *)ptr= val; }
  static inline float singleFloatAtPointer(char *ptr)			{ return *(float *)ptr; }
  static inline float singleFloatAtPointerput(char *ptr, float val)	{ return *(float *)ptr= val; }
  static inline double floatAtPointer(char *ptr)			{ return *(double *)ptr; }
  static inline double floatAtPointerput(char *ptr, double val)	{ return *(double *)ptr= val; }
  static inline sqInt oopAtPointer(char *ptr)			{ return *(sqInt *)ptr; }
  static inline sqInt oopAtPointerput(char *ptr, sqInt val)	{ return (sqInt)(*(sqInt *)ptr= val); }
# if defined(sqMemoryBase) && !sqMemoryBase
  static inline char *pointerForOop(usqInt oop)			{ return (char *)oop; }
  static inline sqInt oopForPointer(void *ptr)			{ return (sqInt)ptr; }
# else
  static inline char *pointerForOop(usqInt oop)			{ return sqMemoryBase + oop; }
  static inline sqInt oopForPointer(void *ptr)			{ return (sqInt)(ptr - sqMemoryBase); }
# endif
  static inline sqInt byteAt(sqInt oop)				{ return byteAtPointer(pointerForOop(oop)); }
  static inline sqInt byteAtput(sqInt oop, int val)		{ return byteAtPointerput(pointerForOop(oop), val); }
  static inline sqInt shortAt(sqInt oop)			{ return shortAtPointer(pointerForOop(oop)); }
  static inline sqInt shortAtput(sqInt oop, int val)		{ return shortAtPointerput(pointerForOop(oop), val); }
  static inline sqInt intAt(sqInt oop)				{ return intAtPointer(pointerForOop(oop)); }
  static inline sqInt intAtput(sqInt oop, int val)		{ return intAtPointerput(pointerForOop(oop), val); }
  static inline sqInt longAt(sqInt oop)				{ return longAtPointer(pointerForOop(oop)); }
  static inline sqInt longAtput(sqInt oop, sqInt val)		{ return longAtPointerput(pointerForOop(oop), val); }
  static inline sqLong long64At(sqInt oop)				{ return long64AtPointer(pointerForOop(oop)); }
  static inline sqLong long64Atput(sqInt oop, sqLong val)		{ return long64AtPointerput(pointerForOop(oop), val); }
  static inline sqInt oopAt(sqInt oop)				{ return oopAtPointer(pointerForOop(oop)); }
  static inline sqInt oopAtput(sqInt oop, sqInt val)		{ return oopAtPointerput(pointerForOop(oop), val); }

  static inline char* pointerAtPointer(char *ptr)			{ return *(char **)ptr; }
  static inline char* pointerAtPointerput(char *ptr, char* val)	{ return *(char **)ptr = val; }

  static inline signed char int8AtPointer(char *ptr)			            { return (*((signed char *)ptr)); }
  static inline signed char int8AtPointerput(char *ptr, signed char val)	{ return (*((signed char *)ptr)= val); }
  static inline unsigned char uint8AtPointer(char *ptr)			            { return (*((unsigned char *)ptr)); }
  static inline unsigned char uint8AtPointerput(char *ptr, unsigned char val)	{ return (*((unsigned char *)ptr)= val); }

  static inline short int16AtPointer(char *ptr)			                    { return (*((short *)ptr)); }
  static inline short int16AtPointerput(char *ptr, short val)	            { return (*((short *)ptr)= val); }
  static inline unsigned short uint16AtPointer(char *ptr)			                    { return (*((unsigned short *)ptr)); }
  static inline unsigned short uint16AtPointerput(char *ptr, unsigned short val)	    { return (*((unsigned short *)ptr)= val); }

  static inline int int32AtPointer(char *ptr)			    { return (*((int *)ptr)); }
  static inline int int32AtPointerput(char *ptr, int val)	{ return (*((int *)ptr)= val); }
  static inline unsigned int uint32AtPointer(char *ptr)			    { return (*((unsigned int *)ptr)); }
  static inline unsigned int uint32AtPointerput(char *ptr, unsigned int val)	{ return (*((unsigned int *)ptr)= val); }

  static inline sqLong int64AtPointer(char *ptr)			    { return (*((sqLong *)ptr)); }
  static inline sqLong int64AtPointerput(char *ptr, int val)	{ return (*((sqLong *)ptr)= val); }
  static inline usqLong uint64AtPointer(char *ptr)			    { return (*((usqLong *)ptr)); }
  static inline usqLong uint64AtPointerput(char *ptr, usqLong val)	{ return (*((usqLong *)ptr)= val); }

  static inline sqLong asIEEE64BitWord(double val) {return *((sqLong*)&val); }
  static inline unsigned int asIEEE32BitWord(float val) {return *((unsigned int*)&val); }
#else /* USE_INLINE_MEMORY_ACCESSORS */
  /* Use macros when static inline functions aren't efficient. */
# define byteAtPointer(ptr)			((sqInt)(*((unsigned char *)(ptr))))
# define byteAtPointerput(ptr,val)	((sqInt)(*((unsigned char *)(ptr))= (unsigned char)(val)))
# define shortAtPointer(ptr)		((sqInt)(*((short *)(ptr))))
# define shortAtPointerput(ptr,val)	((sqInt)(*((short *)(ptr))= (short)(val)))
# define intAtPointer(ptr)			((sqInt)(*((int *)(ptr))))
# define intAtPointerput(ptr,val)	((sqInt)(*((int *)(ptr))= (int)(val)))
# define longAtPointer(ptr)			(*(sqInt *)(ptr))
# define longAtPointerput(ptr,val)	(*(sqInt *)(ptr)= (sqInt)(val))
# define long64AtPointer(ptr)			(*(sqLong *)(ptr))
# define long64AtPointerput(ptr,val)	(*(sqLong *)(ptr)= (sqLong)(val))
# define singleFloatAtPointer(ptr)		(*(float*)(ptr))
# define singleFloatAtPointerput(ptr, val)		(*(float*)(ptr) = val)
# define floatAtPointer(ptr)		        (*(double*)(ptr))
# define floatAtPointerput(ptr, val)		(*(double*)(ptr) = val)
# define pointerAtPointer(ptr)		        (*(char**)(ptr))
# define pointerAtPointerput(ptr, val)		(*(char**)(ptr) = val)
# define oopAtPointer(ptr)			(*(sqInt *)(ptr))
# define oopAtPointerput(ptr,val)	(*(sqInt *)(ptr)= (sqInt)(val))
# if defined(sqMemoryBase) && !sqMemoryBase
#  define pointerForOop(oop)		((char *)(oop))
#  define oopForPointer(ptr)		((sqInt)(ptr))
#  define atPointerArg(oop)			oop
# else
#  define pointerForOop(oop)		((char *)(sqMemoryBase + ((usqInt)(oop))))
#  define oopForPointer(ptr)		((sqInt)(((char *)(ptr)) - (sqMemoryBase)))
#  define atPointerArg(oop)			sqMemoryBase + (usqInt)(oop)
# endif
# define byteAt(oop)				byteAtPointer(atPointerArg(oop))
# define byteAtput(oop,val)			byteAtPointerput(atPointerArg(oop), val)
# define shortAt(oop)				shortAtPointer(atPointerArg(oop))
# define shortAtput(oop,val)		shortAtPointerput(atPointerArg(oop), val)
# define longAt(oop)				longAtPointer(atPointerArg(oop))
# define longAtput(oop,val)			longAtPointerput(atPointerArg(oop), val)
# define long64At(oop)				long64AtPointer(atPointerArg(oop))
# define long64Atput(oop,val)		long64AtPointerput(atPointerArg(oop), val)
# define intAt(oop)					intAtPointer(atPointerArg(oop))
# define intAtput(oop,val)			intAtPointerput(atPointerArg(oop), val)
# define oopAt(oop)					oopAtPointer(atPointerArg(oop))
# define oopAtput(oop,val)			oopAtPointerput(atPointerArg(oop), val)

# define int8AtPointer(ptr)          (*(signed char*)(ptr))
# define int8AtPointerput(ptr, val)  (*(signed char*)(ptr) = val)
# define uint8AtPointer(ptr)          (*(unsigned char*)(ptr))
# define uint8AtPointerput(ptr, val)  (*(unsigned char*)(ptr) = val)

# define int16AtPointer(ptr)          (*(signed short*)(ptr))
# define int16AtPointerput(ptr, val)  (*(signed short*)(ptr) = val)
# define uint16AtPointer(ptr)          (*(unsigned short*)(ptr))
# define uint16AtPointerput(ptr, val)  (*(unsigned short*)(ptr) = val)

# define int32AtPointer(ptr)          (*(signed int*)(ptr))
# define int32AtPointerput(ptr, val)  (*(signed int*)(ptr) = val)
# define uint32AtPointer(ptr)          (*(unsigned int*)(ptr))
# define uint32AtPointerput(ptr, val)  (*(unsigned int*)(ptr) = val)

# define int64AtPointer(ptr)          (*(sqLong*)(ptr))
# define int64AtPointerput(ptr, val)  (*(sqLong*)(ptr) = val)
# define uint64AtPointer(ptr)          (*(usqLong*)(ptr))
# define uint64AtPointerput(ptr, val)  (*(usqLong*)(ptr) = val)

# define asIEEE64BitWord(val) (*((sqLong*)&val))
# define asIEEE32BitWord(val) (*((unsigned int*)&val))
#endif /* USE_INLINE_MEMORY_ACCESSORS */

#define long32At	intAt
#define long32Atput	intAtput

/* platform-dependent float conversion macros.
 * Note: Second argument must be a variable name, not an expression!
 * Pre-Cog systems stored floats in Mac PowerPC big-endian format.
 * BigEndianFloats selects this behaviour for backwards-compatibility.
 * RISC systems typically insist on double-word alignment of double-words, but
 * the heap is only word-aligned.  OBJECTS_32BIT_ALIGNED selects word access.
 */
#if BigEndianFloats && !VMBIGENDIAN
/* this is to allow strict aliasing assumption in the optimizer */
typedef union { double d; int i[sizeof(double) / sizeof(int)]; } _swapper;
/* word-based copy with swapping for non-PowerPC order */
# define storeFloatAtPointerfrom(intPointerToFloat, doubleVar) do { \
		*((int *)(intPointerToFloat) + 0) = ((_swapper *)(&doubleVar))->i[1]; \
		*((int *)(intPointerToFloat) + 1) = ((_swapper *)(&doubleVar))->i[0]; \
	} while (0)
# define fetchFloatAtPointerinto(intPointerToFloat, doubleVar) do { \
		((_swapper *)(&doubleVar))->i[1] = *((int *)(intPointerToFloat) + 0); \
		((_swapper *)(&doubleVar))->i[0] = *((int *)(intPointerToFloat) + 1); \
	} while (0)
# else
# define storeFloatAtPointerfrom(intPointerToFloat, doubleVar) \
    memcpy((char *)intPointerToFloat,&doubleVar,sizeof(double));
# define fetchFloatAtPointerinto(intPointerToFloat, doubleVar) \
    memcpy(&doubleVar,(char *)intPointerToFloat,sizeof(double));
#endif /* !(BigEndianFloats && !VMBIGENDIAN) && !OBJECTS_32BIT_ALIGNED */

# define storeSingleFloatAtPointerfrom(intPointerToFloat, floatVar) \
        do {float __f=floatVar; memcpy((char *)intPointerToFloat,&__f,sizeof(float));} while(0)
# define fetchSingleFloatAtPointerinto(intPointerToFloat, floatVar) \
        do {float __f; memcpy(&__f,(char *)intPointerToFloat,sizeof(float)); floatVar=__f;} while(0)

#define storeFloatAtfrom(i, doubleVar)	storeFloatAtPointerfrom(pointerForOop(i), doubleVar)
#define fetchFloatAtinto(i, doubleVar)	fetchFloatAtPointerinto(pointerForOop(i), doubleVar)
#define storeSingleFloatAtfrom(i, floatVar)	storeSingleFloatAtPointerfrom(pointerForOop(i), floatVar)
#define fetchSingleFloatAtinto(i, floatVar)	fetchSingleFloatAtPointerinto(pointerForOop(i), floatVar)

/* These accessors are for accelerating byte swapping
   whenever intrinsics or other fast functions are available */
/* Compatibility with non-clang compilers */
#ifndef __has_builtin
#  define __has_builtin(x) 0
#endif

/*  GCC and Clang recent versions provide intrinsic byte swaps via builtins */
#if (defined(__clang__) && __has_builtin(__builtin_bswap32) && __has_builtin(__builtin_bswap64)) \
  || (defined(__GNUC__ ) && \
  (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)))
#  define SQ_SWAP_4_BYTES(x) __builtin_bswap32(x)
#  define SQ_SWAP_8_BYTES(x) __builtin_bswap64(x)
#elif defined(__linux__)
#  include <byteswap.h>
#  define SQ_SWAP_4_BYTES(x) bswap_32(x)
#  define SQ_SWAP_8_BYTES(x) bswap_64(x)
#elif defined(_MSC_VER)
#  include <stdlib.h>
#  define SQ_SWAP_4_BYTES(x) _byteswap_ulong(x)
#  define SQ_SWAP_8_BYTES(x) _byteswap_uint64(x)
#else
#  define SQ_SWAP_4_BYTES(x) \
	(((unsigned int)(x) << 24) | \
	(((unsigned int)(x) <<  8) & 0xff0000U) | \
	(((unsigned int)(x) >>  8) & 0xff00U) | \
	( (unsigned int)(x) >> 24))
#  define SQ_SWAP_8_BYTES(x) \
	(((unsigned long long)(x) << 56) | \
	(((unsigned long long)(x) << 40) & 0xff000000000000ULL) | \
	(((unsigned long long)(x) << 24) & 0xff0000000000ULL) | \
	(((unsigned long long)(x) << 8)  & 0xff00000000ULL) | \
	(((unsigned long long)(x) >> 8)  & 0xff000000ULL) | \
	(((unsigned long long)(x) >> 24) & 0xff0000ULL) | \
	(((unsigned long long)(x) >> 40) & 0xff00ULL) | \
	( (unsigned long long)(x) >> 56))
#endif

/* Since Large Integers are Bytes Oops allways stored as little endian,
   the following macros are handy to retrieve 4 or 8 byte limbs */
#if VMBIGENDIAN
#  define SQ_SWAP_4_BYTES_IF_BIGENDIAN(x) SQ_SWAP_4_BYTES(x)
#  define SQ_SWAP_8_BYTES_IF_BIGENDIAN(x) SQ_SWAP_8_BYTES(x)
#else
#  define SQ_SWAP_4_BYTES_IF_BIGENDIAN(x) (x)
#  define SQ_SWAP_8_BYTES_IF_BIGENDIAN(x) (x)
#endif

/* This doesn't belong here, but neither do 'self flag: ...'s belong in the
   image. We use a macro, not an inline function; we need no trace of flag.
 */
#define flag(foo) 0

/* heap debugging facilities in sqHeapMap.c */
extern void clearHeapMap(void);
extern int  heapMapAtWord(void *wordPointer);
extern void heapMapAtWordPut(void *wordPointer, int bit);

#endif /* __sqMemoryAccess_h */


text:
import {combineReducers} from 'redux';
import NavigatorReducer from './navigator';
import HomeReducer from './home';

const rootReducer = combineReducers({
  currentTabId: NavigatorReducer,
  home: HomeReducer
});

export default rootReducer;


text:
class Renderer2D; //[DON'T MOVE THIS]

class Application2D : public aie::Application
{
public:

	Application2D();
	virtual ~Application2D();

	virtual bool startup();
	virtual void shutdown();

	virtual void update(float deltaTime);
	virtual void draw();

	void switchGameState(GameState a_nextState);

protected:

	aie::Renderer2D* m_2dRenderer;

	//holds our gameState
	BaseGameState* currentGameState;
	DynamicArray<BaseGameState*> gameStates; //dynamic array
};


text:
<?xml version="1.0" encoding="UTF-8"?>

<!--L
  Copyright HealthCare IT, Inc.

  Distributed under the OSI-approved BSD 3-Clause License.
  See http://ncip.github.com/edct-formbuilder/LICENSE.txt for details.
L-->

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

	<!--  DAO beans -->
	<bean name="answerDao" class="com.healthcit.cacure.dao.AnswerDao"/>
	<bean name="formDao" class="com.healthcit.cacure.dao.FormDao"/>
	<bean name="moduleDao" class="com.healthcit.cacure.dao.ModuleDao"/>
	<bean name="questionDao" class="com.healthcit.cacure.dao.QuestionDao"/>
	<bean name="questionElementDao" class="com.healthcit.cacure.dao.QuestionElementDao"/>
	<bean name="linkElementDao" class="com.healthcit.cacure.dao.LinkElementDao"/>
	<bean name="formElementDao" class="com.healthcit.cacure.dao.FormElementDao"/>
	<bean name="tableElementDao" class="com.healthcit.cacure.dao.TableElementDao"/>
	<bean name="contentElementDao" class="com.healthcit.cacure.dao.ContentElementDao"/>
	<bean name="externalElementDao" class="com.healthcit.cacure.dao.ExternalQuestionElementDao"/>
	<bean name="tableQuestionDao" class="com.healthcit.cacure.dao.QuestionTableDao"/>
	<bean name="userDao" class="com.healthcit.cacure.dao.UserManagerDao"/>
	<bean name="skipDao" class="com.healthcit.cacure.dao.SkipPatternDao"/>
	<bean name="roleDao" class="com.healthcit.cacure.dao.RoleDao"/>
	<bean name="categoryDao" class="com.healthcit.cacure.dao.CategoryDao"/>
	<bean name="couchDbDao" class="com.healthcit.cacure.dao.CouchDBDao">
	</bean>

	<!--  business layer beans -->
	<bean name="formMgr" class="com.healthcit.cacure.businessdelegates.FormManager"/>
	<bean name="moduleMgr" class="com.healthcit.cacure.businessdelegates.ModuleManager"/>
	<bean name="qaMgr" class="com.healthcit.cacure.businessdelegates.QuestionAnswerManager"/>
	<bean name="userMgr" class="com.healthcit.cacure.businessdelegates.UserManager"/>
	<bean name="categoryManager" class="com.healthcit.cacure.businessdelegates.CategoryManager"/>
	<bean name="generatedFormDataMgr" class="com.healthcit.cacure.businessdelegates.GeneratedFormDataManager"/>

	<!-- Additional services -->
	<bean name="mailSendingService" class="com.healthcit.cacure.utils.MailSendingService" />
</beans>


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Mycologia 48: 608 (1956)

#### Original name
Pileolaria mexicana Arthur, 1907

### Remarks
null