//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// PLEASE DO NOT EDIT WITHOUT THE EXPLICIT CONSENT OF THE AUTHOR! \\
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
package hlt.language.util;
import java.util.HashMap;
/**
* This class is a concrete implementation of the abstract class RegExp. It is meant to represent an
* alphabet symbol. It is simply a wrapper for an object to be used as
* an alphabet symbol in a RE. Alphabet symbols are uniquely
* represented. So this also provides a factory to return a unique
* symbol from a specified object (using equals on the
* objects). Hence, it has no public constructor.
*
*
* @version Last modified on Mon Mar 26 10:20:59 2018 by hak
* @author Hassan Aït-Kaci
* @copyright © Hassan Aït-Kaci
*/
public class RegExpSymbol extends RegExp
{
/**
* Returns the unique canonical object called RegExpSymbol.EMPTY
* representing the empty symbol ().
*/
public static final RegExpSymbol EMPTY = new RegExpSymbol("()");
/**
* Returns a shallow copy of this RegExpSymbol; since
* RegExpSymbols are unique, it is in fact itself.
*
* @return this RegExpSymbol
*/
public final RegExp shallowCopy ()
{
return this;
}
/**
* Returns a deep copy of this RegExpSymbol; since
* RegExpSymbols are unique, it is in fact itself.
*
* @return this RegExpSymbol
*/
public final RegExp deepCopy ()
{
return this;
}
/**
* Returns an int denoting the type of this
* RegExpSymbol: RegExp.EMPTY_EXP if this is the
* empty symbol; RegExp.SYMBOL_EXP otherwise.
*
* @return this RegExpSymbol's type (an int)
*/
public final int type ()
{
return isEmpty() ? EMPTY_EXP : SYMBOL_EXP;
}
/**
* Returns the object wrapped by this RegExpSymbol.
*
* @return the wrapped Object
*/
private Object _object = null;
/**
* Returns this RegExpSymbol's object.
*/
public final Object object ()
{
return _object;
}
/**
* The name of this RegExpSymbol.
*/
String _name;
/**
* Sets the name of this RegExpSymbol to the specified
* string.
*/
public final void setName (String name)
{
_name = name.intern();
}
/**
* Returns this RegExpSymbol's name as a unique id.
*/
public final String name ()
{
return _name == null ? _name = _object.toString().intern()
: _name;
}
/**
* A private static store associating an object to its canonical
* RegExpSymbol wrapper. It uses an object's
* equals(Object) method for lookups.
*/
private static HashMap _symbols = new HashMap();
/**
* A private constructor used only once to generate the canonical
* empty symbol.
*/
private RegExpSymbol ()
{
}
/**
* A private constructor constructing a RegExpSymbol
* wrapper for the specified object. It is used by the
* get(Object) method, which is the only public way of
* constructing RegExpSymbol's.
*/
private RegExpSymbol (Object object)
{
_object = object;
}
/**
* This is the public method factory for creating
* RegExpSymbol objects. It returns a canonical
* RegExpSymbol wrapper for the specified object. If the
* argument is null, this returns the canonical
* EMPTY RegExpSymbol. Otherwise, it will return
* the same RegExpSymbol for equals objects.
*
* @param object an object
* @return the canonical unique RegExpSymbol for the specified object
*/
public static RegExpSymbol get (Object object)
{
if (object == null)
return EMPTY;
RegExpSymbol symbol = (RegExpSymbol)_symbols.get(object);
if (symbol == null)
_symbols.put(object,
symbol = new RegExpSymbol(object));
return symbol;
}
/**
* Computes this RegExpSymbol as its
* own normal form.
*/
public final void normalize ()
{
_normalForm = this;
}
/**
* Returns true iff the specified object is a
* RegExpSymbol that has the same name as this.
*/
public final boolean equals (Object other)
{
return (this == other)
|| (other instanceof RegExpSymbol
&& ((RegExpSymbol)other).name() == name());
}
/**
* Returns a printable form for this RegExpSymbol.
*/
public final String toString ()
{
return isEmpty() ? "()" : name();
}
public final String toNormalString ()
{
return toString();
}
}