6733918 Teamware has retired, please welcome your new manager, Mercurial
4758439 some files use "current date" sccs keywords
6560843 asm sources should not rely on .file "%M%" for naming STT_FILE symbols
6560958 Solaris:: perl modules should not use SCCS keywords in version information
6729074 webrev doesn't deal well with remote ssh hg parents
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 1999 by Sun Microsystems, Inc.
* All rights reserved.
*
*/
// ServiceType.java: Model a service type.
// Author: James Kempf
// Created On: Thu Apr 9 09:23:18 1998
// Last Modified By: James Kempf
// Last Modified On: Mon Oct 19 15:43:18 1998
// Update Count: 33
//
package com.sun.slp;
import java.util.*;
import java.io.*;
/**
* The ServiceType class conceals the complex details of whether a
* service type name is a simple URL scheme identifier, a service:
* type, an abstract type or protocol type.
*
* @author James Kempf
*/
public class ServiceType extends Object implements Serializable {
boolean isServiceURL = true; // was it originally a service: type?
private String type1 = ""; // scheme, abstract, or protocol.
private String type2 = ""; // concrete, if type was abstract.
private String na = ""; // naming authority.
// For removing IANA.
static final String IANA = "iana";
/**
* Create a service type object from the type name. The name may
* take the form of any valid SLP service type name.
*
* @param t The type name.
* @return The ServiceType object.
* @exception IllegalArgumentException If the name is syntactically
* incorrect.
*/
public ServiceType(String t) throws IllegalArgumentException {
parse(t);
}
/**
* Return true if type name was from a service: URL.
*
* @return True if type name came from service: URL.
*/
public boolean isServiceURL() {
return isServiceURL;
}
/**
* Return true if type name is for an abstract type.
*
* @return True if type name is for an abstract type.
*/
public boolean isAbstractType() {
return (type2.length() > 0);
}
/**
* Return true if naming authority is default.
*
* @return True if naming authority is default.
*/
public boolean isNADefault() {
return (na.length() <= 0);
}
/**
* Return the concrete service type name without naming authority.
*
* @return concrete type name.
*/
public String getConcreteTypeName() {
return type2;
}
/**
* Return the principle type name, which is either the abstract
* type name or the protocol name, without naming authority.
*
* @return Principle type name.
*/
public String getPrincipleTypeName() {
return type1;
}
/**
* Return the fully formatted abstract type name, if it is an abstract
* type, otherwise the empty string.
*/
public String getAbstractTypeName() {
if (isAbstractType()) {
return "service:" + type1 + (na.length() > 0 ? ("." + na):"");
}
return "";
}
/**
* Return the naming authority name.
*
* @return Naming authority name.
*/
public String getNamingAuthority() {
return na;
}
/**
*Validate a naming authority name.
*/
static void validateTypeComponent(String name)
throws ServiceLocationException {
validateTypeComponentInternal(name, false);
}
// Validate, allowing '.' if allowDot is true.
static private void
validateTypeComponentInternal(String name, boolean allowDot)
throws ServiceLocationException {
int i, n = name.length();
for (i = 0; i < n; i++) {
char c = name.charAt(i);
if ((Character.isLetterOrDigit(c) == false) &&
(c != '+') && (c != '-')) {
boolean throwIt = true;
// If dot is allowed, don't throw it.
if (allowDot && (c == '.')) {
throwIt = false;
}
if (throwIt) {
throw
new IllegalArgumentException(
SLPConfig.getSLPConfig().formatMessage("service_type_syntax",
new Object[] {name}));
}
}
}
}
// Two service type names are equal if they have the same
// types, naming authority, and same service: flag.
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof ServiceType)) {
return false;
}
ServiceType type = (ServiceType)o;
return
(isServiceURL == type.isServiceURL) &&
type1.equals(type.type1) &&
type2.equals(type.type2) &&
na.equals(type.na);
}
// Format the service type name for output.
public String toString() {
return
(isServiceURL ? "service:" : "") +
type1 +
(na.length() > 0 ? ("." + na) : "") +
(type2.length() > 0 ? (":" + type2) : "");
}
// Return a hash code for the type.
public int hashCode() {
return type1.hashCode() +
na.hashCode() +
type2.hashCode() +
(isServiceURL ? Defaults.SERVICE_PREFIX.hashCode():0);
}
// Parse a service type name with optional naming authority.
private void parse(String t) {
StringTokenizer st = new StringTokenizer(t, ":.", true);
try {
// This loop is a kludgy way to break out of the parse so
// we only throw at one location in the code.
do {
String tok = st.nextToken();
if (tok.equals(":") || tok.equals(".")) {
break; // error!
}
// Look for a nonservice: URL.
if (!tok.equalsIgnoreCase(Defaults.SERVICE_PREFIX)) {
isServiceURL = false;
// Need to eat through all dots.
do {
type1 = type1 + tok.toLowerCase();
// Break when we run out of tokens.
if (!st.hasMoreTokens()) {
break;
}
tok = st.nextToken();
} while (true);
// Check for disallowed characters. Allow '.'.
validateTypeComponentInternal(type1, true);
// There should be no more tokens.
if (st.hasMoreTokens()) {
break; // error!
}
return; // done!
}
tok = st.nextToken();
if (!tok.equals(":")) {
break; // error!
}
// Get the protocol or abstract type name.
type1 = st.nextToken().toLowerCase();
validateTypeComponent(type1);
// From here on in, everything is optional, so be sure
// to check for no remaining tokens.
if (!st.hasMoreTokens()) {
return;
// done! It's a simple protocol type w.o. naming authority.
}
// It's either got a naming authority or is an abstract
// type (or both).
tok = st.nextToken();
// Check for naming authorithy.
if (tok.equals(".")) {
tok = st.nextToken();
validateTypeComponent(tok);
if (!tok.equalsIgnoreCase(IANA)) {
na = tok.toLowerCase();
} else {
// Error to have IANA.
break;
}
if (!st.hasMoreTokens()) {
return;
// done! It's a simple protocol type w. naming authority.
}
tok = st.nextToken();
}
// Should be at the separator to concrete type.
if (!tok.equals(":")) {
break; // error!
}
tok = st.nextToken();
// This is the concrete type name.
validateTypeComponent(tok);
type2 = tok.toLowerCase();
// Should be no more tokens.
if (st.hasMoreTokens()) {
break; // error!
}
return; // done!
} while (false);
} catch (NoSuchElementException ex) {
throw
new IllegalArgumentException(
SLPConfig.getSLPConfig().formatMessage("service_type_syntax",
new Object[] {t}));
} catch (ServiceLocationException ex) {
throw
new IllegalArgumentException(ex.getMessage());
}
throw
new IllegalArgumentException(
SLPConfig.getSLPConfig().formatMessage("service_type_syntax",
new Object[] {t}));
}
}