Returns an Address object refering to this resource
170797
def address(working_address = nil)
      working_address &&= working_address.deep_copy

      working_address ||= if parent.respond_to?(:base)
        address = Address.new
        address.path_fragments << parent.base
        address
      else
        parent.address.deep_copy
      end

      working_address.path_fragments << path.dup

      # Install path, query, and header parameters in the Address. These
      # may override existing parameters with the same names, but if
      # you've got a WADL application that works that way, you should
      # have bound parameters to values earlier.
      new_path_fragments = []
      embedded_param_names = Set.new(Address.embedded_param_names(path))

      params.each { |param|
        name = param.name

        if embedded_param_names.include?(name)
          working_address.path_params[name] = param
        else
          if param.style == 'query'
            working_address.query_params[name] = param
          elsif param.style == 'header'
            working_address.header_params[name] = param
          else
            new_path_fragments << param
            working_address.path_params[name] = param
          end
        end
      }

      working_address.path_fragments << new_path_fragments unless new_path_fragments.empty?

      working_address
    end
903822
def address(self):
        
        bind = self.settings.get('bind')
        if bind:
            return parse_address(to_bytes(bind.get()))
499986
def GetAddress(self):
        
        script = b'21' + self.PublicKey.encode_point(True) + b'ac'
        script_hash = Crypto.ToScriptHash(script)
        address = Crypto.ToAddress(script_hash)
        return address
77315
def to_request
      address = {
        street:       self.street,
        number:       self.number,
        complement:   self.complement,
        district:     self.district,
        city:         self.city,
        state:        self.state,
        postal_code:  self.postal_code,
        country:      self.country,
      }
      return address
    end
1085043
def get_address(self):
        
        LOGGER.debug("Reading RPS01A sensor's address.",)
        return self.bus.read_byte_data(self.address, self.address_reg)
1120194
def get_active_address(name, arec):
    
    addrs = arec.get(name)
    if addrs:
        return Message("/oper/ns", "info", addrs)
    else:
        return Message("/oper/ns", "info", "")
787475
def getaddress(self):
        """"""
        self.commentlist = []
        self.gotonext()

        oldpos = self.pos
        oldcl = self.commentlist
        plist = self.getphraselist()

        self.gotonext()
        returnlist = []

        if self.pos >= len(self.field):
            # Bad email address technically, no domain.
            if plist:
                returnlist = [(SPACE.join(self.commentlist), plist[0])]

        elif self.field[self.pos] in '.@':
            # email address is just an addrspec
            # this isn't very efficient since we start over
            self.pos = oldpos
            self.commentlist = oldcl
            addrspec = self.getaddrspec()
            returnlist = [(SPACE.join(self.commentlist), addrspec)]

        elif self.field[self.pos] == ':':
            # address is a group
            returnlist = []

            fieldlen = len(self.field)
            self.pos += 1
            while self.pos < len(self.field):
                self.gotonext()
                if self.pos < fieldlen and self.field[self.pos] == ';':
                    self.pos += 1
                    break
                returnlist = returnlist + self.getaddress()

        elif self.field[self.pos] == '<':
            # Address is a phrase then a route addr
            routeaddr = self.getrouteaddr()

            if self.commentlist:
                returnlist = [(SPACE.join(plist) + ' (' +
                               ' '.join(self.commentlist) + ')', routeaddr)]
            else:
                returnlist = [(SPACE.join(plist), routeaddr)]

        else:
            if plist:
                returnlist = [(SPACE.join(self.commentlist), plist[0])]
            elif self.field[self.pos] in self.specials:
                self.pos += 1

        self.gotonext()
        if self.pos < len(self.field) and self.field[self.pos] == ',':
            self.pos += 1
        return returnlist
419057
def addressables(self):
    
    return {
      BuildFileAddress(rel_path=path, target_name=name): obj
      for name, (path, obj) in self.objects_by_name.items()
    }
1084276
private static String getHostPort(SocketAddress address) {
        if (address instanceof ResourceAddress) {
            ResourceAddress lowest = getLowestTransportLayer((ResourceAddress)address);
            return format(HOST_PORT_FORMAT, lowest.getResource().getHost(), lowest.getResource().getPort());
        }
        if (address instanceof InetSocketAddress) {
            InetSocketAddress inet = (InetSocketAddress)address;
            // we don't use inet.toString() because it would include a leading /, for example "/127.0.0.1:21345"
            // use getHostString() to avoid a reverse DNS lookup
            return format(HOST_PORT_FORMAT, inet.getHostString(), inet.getPort());
        }
        return null;
    }
861480
public static long addressOf(Object o) {
    Object[] array = new Object[] { o };
    long baseOffset = THE_UNSAFE.arrayBaseOffset(Object[].class);
    long objectAddress;
    switch (ADDRESS_SIZE) {
    case 4:
      objectAddress = THE_UNSAFE.getInt(array, baseOffset);
      break;
    case 8:
      objectAddress = THE_UNSAFE.getLong(array, baseOffset);
      break;
    default:
      throw new IllegalStateException("unsupported address size: " + ADDRESS_SIZE);
    }
    return objectAddress;
  }
159849
def getProvince(self, default=None):
        
        physical_address = self.getPhysicalAddress().get("state", default)
        postal_address = self.getPostalAddress().get("state", default)
        return physical_address or postal_address
1188725
def address(self):
        
        if self.isDirect():
            base36 = self._iban[4:]
            asInt = int(base36, 36)
            return to_checksum_address(pad_left_hex(baseN(asInt, 16), 20))

        return ""
1035937
def address(addr):
    

    if ':' in addr:
        # Using rpartition here means we should be able to support
        # IPv6, but only with a strict syntax
        host, _sep, port = addr.rpartition(':')

        # Convert the port to a number
        try:
            port = int(port)
        except ValueError:
            raise ValueError("invalid port number %r" % port)

        addr = (host, port)

    return addr
643697
def address(self):
        
        if self._hlinkClick is None:
            return None
        return self.part.target_ref(self._hlinkClick.rId)
119195
@Override
    public EndpointReferenceType getAddressWithId(String id) {
        EndpointReferenceType ref = null;

        if (isMultiplexWithAddress()) {
            String address = EndpointReferenceUtils.getAddress(reference);
            ref = EndpointReferenceUtils.duplicate(reference);
            if (address.endsWith("/")) {
                EndpointReferenceUtils.setAddress(ref, address + id);
            } else {
                EndpointReferenceUtils.setAddress(ref, address + "/" + id);
            }
        } else {
            ref = super.getAddressWithId(id);
        }
        return ref;
    }
352999
def getaddresses(fieldvalues):
    """"""
    all = COMMASPACE.join(fieldvalues)
    a = _AddressList(all)
    return a.addresslist
634353
def full_address(anon, obj, field, val):
    
    return anon.faker.address(field=field)