java.lang.Object
- com.aoindustries.aoserv.client.account.User.Name

All Implemented Interfaces:

DtoFactory<UserName>, FastExternalizable, Internable<User.Name>, Externalizable, Serializable, Comparable<User.Name>

Direct Known Subclasses:

User.Name

Enclosing class:

User
```
public static class User.Name
extends Object
implements Comparable<User.Name>, FastExternalizable, DtoFactory<UserName>, Internable<User.Name>
```
Represents the most general form of a user name. This is has the fewest constraints; other types of accounts constrain this further. User names must:
- Be non-null
- Be non-empty
- Be between 1 and 255 characters
- Must start with [a-z]
- Uses only ASCII 0x21 through 0x7f, excluding space , : ( ) [ ] ' " | & ; A-Z \ /
- If contains any @ symbol, must also be a valid email address. Please note that the reverse is not implied - email addresses may exist that are not valid user ids.
TODO: Should we allow Unicode here, since we now have a more restrictive User.Name for shell accounts?
Author:

AO Industries, Inc.

See Also:

User.Name, User.Name, User.Name, Serialized Form

Field Summary

Fields
Modifier and Type Field Description

static int MAX_LENGTH

protected String name

Constructor Summary

Constructors
Modifier Constructor Description

Name()

protected Name(String name)

protected Name(String name, boolean validate)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`int`	`compareTo(User.Name other)`
`boolean`	`equals(Object O)`
`UserName`	`getDto()`
`long`	`getSerialVersionUID()`
`int`	`hashCode()`
`User.Name`	`intern()`	Interns this name much in the same fashion as `String.intern()`.
`void`	`readExternal(ObjectInput in)`
`String`	`toString()`
`protected void`	`validate()`
`static ValidationResult`	`validate(String name)`	Validates a `User` name.
`static User.Name`	`valueOf(String name)`
`void`	`writeExternal(ObjectOutput out)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - MAX_LENGTH
```
public static final int MAX_LENGTH
```
    See Also:
    
    Constant Field Values
  - name
```
protected String name
```
- Constructor Detail
  - Name
```
protected Name(String name,
               boolean validate)
        throws ValidationException
```
    Throws:
    
    ValidationException
  - Name
```
protected Name(String name)
```
    Parameters:
    
    name - Does not validate, should only be used with a known valid value.
  - Name
```
public Name()
```
- Method Detail
  - validate
```
public static ValidationResult validate(String name)
```
    Validates a User name.
  - valueOf
```
public static User.Name valueOf(String name)
                         throws ValidationException
```
    Parameters:
    
    name - when null, returns null
    
    Throws:
    
    ValidationException
  - validate
```
protected void validate()
                 throws ValidationException
```
    Throws:
    
    ValidationException
  - equals
```
public final boolean equals(Object O)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - compareTo
```
public final int compareTo(User.Name other)
```
    Specified by:
    
    compareTo in interface Comparable<User.Name>
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object
  - intern
```
public User.Name intern()
```
    Interns this name much in the same fashion as String.intern().
    Because this has subtypes, two User.Name that are equals(java.lang.Object) may not necessarily return the same instance object after interning. Thus, unless you know objects are of the same class, equals(java.lang.Object) should still be used for equality check instead of the obj1 == obj2 shortcut.
    
    To more efficiently check post-interned equivalence, one could also do obj1 == obj2 || (obj1.getClass() != obj2.getClass() && obj1.equals(obj2)), but is it worth it?
    
    And then if we abuse the fact that interned user ids have an interned name, one could check equivalence of post-interned user ids as obj1.getId() == obj2.getId(), but once again, is it worth it? Just call equals(java.lang.Object).
    
    Specified by:
    
    intern in interface Internable<User.Name>
    
    See Also:
    
    String.intern()
  - getDto
```
public UserName getDto()
```
    Specified by:
    
    getDto in interface DtoFactory<UserName>
  - getSerialVersionUID
```
public long getSerialVersionUID()
```
    Specified by:
    
    getSerialVersionUID in interface FastExternalizable
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException

Modifier	Constructor	Description
	`Name()`
`protected`	`Name(String name)`
`protected`	`Name(String name, boolean validate)`

Class User.Name

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MAX_LENGTH

name

Constructor Detail

Name

Name

Name

Method Detail

validate

valueOf

validate

equals

hashCode

compareTo

toString

intern

getDto

getSerialVersionUID

writeExternal

readExternal