/**
 * Interface for both netbios and internet addresses
 * 
 * @author mbechler
 *
 */
public interface Address {

    /**
     * 
     * @param type
     * @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Address> T unwrap ( Class<T> type );


    /**
     * 
     * @return the resolved host name, or the host address if it could not be resolved
     */

                            }
                            if( response.received && response.resultCode == 0 ) {

/* Before we return, in anticipation of this address being cached we must
 * augment the addresses name's hashCode to distinguish those resolved by
 * Lmhosts, WINS, or BCAST. Otherwise a failed query from say WINS would
 * get pulled out of the cache for a BCAST on the same name.
 */

                addresses = new UniAddress[1];
                addresses[0] = UniAddress.getByName( server );
                return getNextAddress();
            }
            String address = queryLookup(query, "address");
            if (address != null && address.length() > 0) {
                byte[] ip = java.net.InetAddress.getByName(address).getAddress();
                addresses = new UniAddress[1];

        initCache(tc);
    }

    static final class CacheEntry {

        Name hostName;
        NbtAddress address;
        long expiration;


        CacheEntry ( Name hostName, NbtAddress address, long expiration ) {
            this.hostName = hostName;
            this.address = address;
            this.expiration = expiration;
        }
    }


    /**
     * 
     */

        return null;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Address#unwrap(java.lang.Class)
     */
    @SuppressWarnings ( "unchecked" )
    @Override
    public <T extends Address> T unwrap ( Class<T> type ) {
        if ( this.addr instanceof Address ) {
            return ( (Address) this.addr ).unwrap(type);
        }
        else if ( this.getClass().isAssignableFrom(type) ) {

     * Retrieve all addresses of a host by it's address. NetBIOS hosts can
     * have many names for a given IP address. The name and IP address make
     * the NetBIOS address. This provides a way to retrieve the other names
     * for a host with the same IP address. See {@link #getByName}
     * for a description of <code>type</code>
     * and <code>scope</code>.
     *
     * @param host
     *            hostname to lookup all addresses for

        this.addr = addr;
    }

    /**
     * Return the IP address of this address as a 32 bit integer.
     */

    public int hashCode() {
        return addr.hashCode();
    }

    /**
     * Compare two addresses for equality. Two <tt>UniAddress</tt>s are equal
     * if they are both <tt>UniAddress</tt>' and refer to the same IP address.
     */
    public boolean equals( Object obj ) {

        loc.share = this.share;
        loc.dfsReferral = this.dfsReferral;
        loc.unc = this.unc;
        if ( this.addresses != null ) {
            loc.addresses = new UniAddress[this.addresses.length];
            System.arraycopy(this.addresses, 0, loc.addresses, 0, this.addresses.length);
        }
        loc.addressIndex = this.addressIndex;
        loc.type = this.type;
        return loc;
    }

    }


/**
 * Retrieve all addresses of a host by it's address. NetBIOS hosts can
 * have many names for a given IP address. The name and IP address make the
 * NetBIOS address. This provides a way to retrieve the other names for a
 * host with the same IP address.
 *
 * @param addr the address to query
 * @throws UnknownHostException if address cannot be resolved
 */

                log.error("Not a number", nfe);
            }
        }
        return def;
    }


    /**
     * Retrieve an <code>InetAddress</code>. If the address is not
     * an IP address and cannot be resolved <code>null</code> will
     * be returned.
     */
    public static InetAddress getInetAddress ( Properties props, String key, InetAddress def ) {