query-by method for field address2
@param address2 the specified attribute
@return an Iterable of DUsers for the specified address2
344086
public Iterable<DUser> queryByAddress2(java.lang.String address2) {
    return queryByField(null, DUserMapper.Field.ADDRESS2.getFieldName(), address2);
  }
450090
def getaddresses (addr):
    """"""
    parsed = [mail for name, mail in AddressList(addr).addresslist if mail]
    if parsed:
        addresses = parsed
    elif addr:
        # we could not parse any mail addresses, so try with the raw string
        addresses = [addr]
    else:
        addresses = []
    return addresses
1353855
public static InetSocketAddress[] parseAddressList(String[] addresses) {
        InetSocketAddress[] isa = new InetSocketAddress[addresses.length];
        for (int x = 0; x < addresses.length; x++) {
            isa[x] = createInetSocketAddress(addresses[x]);
        }
        return isa;
    }
802116
public static Set<InetAddress> getAddresses() {
        Set<InetAddress> allAddresses = new LinkedHashSet<>();
        Map<String, Set<InetAddress>> interfaceAddressMap = getNetworkInterfaceAddresses(false);
        for (Map.Entry<String, Set<InetAddress>> entry : interfaceAddressMap.entrySet()) {
            Set<InetAddress> addresses = entry.getValue();
            if (!addresses.isEmpty()) {
                for (InetAddress address : addresses) {
                    allAddresses.add(address);
                }
            }
        }
        return allAddresses;
    }
988981
def address(self, s):
        
        s = parseable_str(s)
        return self.p2pkh(s) or self.p2sh(s) or self.p2pkh_segwit(s) or self.p2sh_segwit(s)
260861
public InetAddress address(boolean resolve) {
    if (resolve) {
      address = resolveAddress();
      return address;
    }

    if (address == null) {
      synchronized (this) {
        if (address == null) {
          address = resolveAddress();
        }
      }
    }
    return address;
  }
896711
public T findOne(T query, T fields) {
        return findOne(query, fields, getReadPreference());
    }
824856
public Iterable<DUser> queryByLastName(java.lang.String lastName) {
    return queryByField(null, DUserMapper.Field.LASTNAME.getFieldName(), lastName);
  }
228156
public Iterable<DUser> queryByCity(java.lang.String city) {
    return queryByField(null, DUserMapper.Field.CITY.getFieldName(), city);
  }
892811
def get_all_derivatives(self, address):
    
    ret = []
    direct = self.get_direct_derivatives(address)
    ret.extend(direct)
    for t in direct:
      ret.extend(self.get_all_derivatives(t.address))
    return ret
525316
public static AddressMatcher getAddressMatcher(String address) {
        final AddressMatcher matcher;
        final int indexColon = address.indexOf(':');
        final int lastIndexColon = address.lastIndexOf(':');
        final int indexDot = address.indexOf('.');
        final int lastIndexDot = address.lastIndexOf('.');

        if (indexColon > -1 && lastIndexColon > indexColon) {
            if (indexDot == -1) {
                matcher = new Ip6AddressMatcher();
                parseIpv6(matcher, address);
            } else {
                // IPv4 mapped IPv6
                if (indexDot >= lastIndexDot) {
                    throw new InvalidAddressException(address);
                }
                final int lastIndexColon2 = address.lastIndexOf(':');
                final String host2 = address.substring(lastIndexColon2 + 1);
                matcher = new Ip4AddressMatcher();
                parseIpv4(matcher, host2);
            }
        } else if (indexDot > -1 && lastIndexDot > indexDot && indexColon == -1) {
            // IPv4
            matcher = new Ip4AddressMatcher();
            parseIpv4(matcher, address);
        } else {
            throw new InvalidAddressException(address);
        }
        return matcher;
    }
1318958
@InternalFunction()
    public Boolean match(final List<ProxyField> list,final List<ProxyField> list2)
    {
    	if (list == null)
    	{
    		return Boolean.TRUE;
    	}
        for (ProxyField proxyField: list)
        {
            boolean found = false;
            for (ProxyField proxyField2: list2)
            {
                if (proxyField.getValue().equals(proxyField2.getValue()))
                {
                    found = true;
                    break;
                }
            }
            if (!found)
            {
                return Boolean.FALSE;
            }
        }
        return Boolean.TRUE;
    }
840117
public Iterable<DUser> queryByState(java.lang.Integer state) {
    return queryByField(null, DUserMapper.Field.STATE.getFieldName(), state);
  }
1025323
public DUser findByEmail(java.lang.String email) {
    return queryUniqueByField(null, DUserMapper.Field.EMAIL.getFieldName(), email);
  }
165915
public Iterable<DUser> queryByThumbnailUrl(java.lang.String thumbnailUrl) {
    return queryByField(null, DUserMapper.Field.THUMBNAILURL.getFieldName(), thumbnailUrl);
  }
323684
def is_same_address(addr1, addr2):
    
    hostport1 = addr1.split(":")
    hostport2 = addr2.split(":")

    return (is_same_host(hostport1[0], hostport2[0]) and
            hostport1[1] == hostport2[1])
1114101
def find_associated_with_address(self, instance):
    
    objects = []
    objects += list(Project.objects.filter(address=instance))
    objects += list(Organization.objects.filter(address=instance))

    return objects