com.ericsson.otp.erlang.OtpErlangAtom Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jinterface Show documentation
Show all versions of jinterface Show documentation
Jinterface Java package contains java classes, which help you integrate programs written in Java with Erlang.
Erlang is a programming language designed at the Ericsson Computer Science Laboratory.
/*
* %CopyrightBegin%
*
* Copyright Ericsson AB 2000-2009. All Rights Reserved.
*
* The contents of this file are subject to the Erlang Public License,
* Version 1.1, (the "License"); you may not use this file except in
* compliance with the License. You should have received a copy of the
* Erlang Public License along with this software. If not, it can be
* retrieved online at http://www.erlang.org/.
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* %CopyrightEnd%
*/
package com.ericsson.otp.erlang;
import java.io.Serializable;
/**
* Provides a Java representation of Erlang atoms. Atoms can be created from
* strings whose length is not more than {@link #maxAtomLength maxAtomLength}
* characters.
*/
public class OtpErlangAtom extends OtpErlangObject implements Serializable,
Cloneable {
// don't change this!
static final long serialVersionUID = -3204386396807876641L;
/** The maximun allowed length of an atom, in characters */
public static final int maxAtomLength = 0xff; // one byte length
private final String atom;
/**
* Create an atom from the given string.
*
* @param atom
* the string to create the atom from.
*
* @exception java.lang.IllegalArgumentException
* if the string is null or contains more than
* {@link #maxAtomLength maxAtomLength} characters.
*/
public OtpErlangAtom(final String atom) {
if (atom == null) {
throw new java.lang.IllegalArgumentException(
"null string value");
}
if (atom.length() > maxAtomLength) {
throw new java.lang.IllegalArgumentException("Atom may not exceed "
+ maxAtomLength + " characters");
}
this.atom = atom;
}
/**
* Create an atom from a stream containing an atom encoded in Erlang
* external format.
*
* @param buf
* the stream containing the encoded atom.
*
* @exception OtpErlangDecodeException
* if the buffer does not contain a valid external
* representation of an Erlang atom.
*/
public OtpErlangAtom(final OtpInputStream buf)
throws OtpErlangDecodeException {
atom = buf.read_atom();
}
/**
* Create an atom whose value is "true" or "false".
*/
public OtpErlangAtom(final boolean t) {
atom = String.valueOf(t);
}
/**
* Get the actual string contained in this object.
*
* @return the raw string contained in this object, without regard to Erlang
* quoting rules.
*
* @see #toString
*/
public String atomValue() {
return atom;
}
/**
* The boolean value of this atom.
*
* @return the value of this atom expressed as a boolean value. If the atom
* consists of the characters "true" (independent of case) the value
* will be true. For any other values, the value will be false.
*
*/
public boolean booleanValue() {
return Boolean.valueOf(atomValue()).booleanValue();
}
/**
* Get the printname of the atom represented by this object. The difference
* between this method and {link #atomValue atomValue()} is that the
* printname is quoted and escaped where necessary, according to the Erlang
* rules for atom naming.
*
* @return the printname representation of this atom object.
*
* @see #atomValue
*/
@Override
public String toString() {
if (atomNeedsQuoting(atom)) {
return "'" + escapeSpecialChars(atom) + "'";
} else {
return atom;
}
}
/**
* Determine if two atoms are equal.
*
* @param o
* the other object to compare to.
*
* @return true if the atoms are equal, false otherwise.
*/
@Override
public boolean equals(final Object o) {
if (!(o instanceof OtpErlangAtom)) {
return false;
}
final OtpErlangAtom atom = (OtpErlangAtom) o;
return this.atom.compareTo(atom.atom) == 0;
}
@Override
protected int doHashCode() {
return atom.hashCode();
}
/**
* Convert this atom to the equivalent Erlang external representation.
*
* @param buf
* an output stream to which the encoded atom should be
* written.
*/
@Override
public void encode(final OtpOutputStream buf) {
buf.write_atom(atom);
}
/* the following four predicates are helpers for the toString() method */
private boolean isErlangDigit(final char c) {
return c >= '0' && c <= '9';
}
private boolean isErlangUpper(final char c) {
return c >= 'A' && c <= 'Z' || c == '_';
}
private boolean isErlangLower(final char c) {
return c >= 'a' && c <= 'z';
}
private boolean isErlangLetter(final char c) {
return isErlangLower(c) || isErlangUpper(c);
}
// true if the atom should be displayed with quotation marks
private boolean atomNeedsQuoting(final String s) {
char c;
if (s.length() == 0) {
return true;
}
if (!isErlangLower(s.charAt(0))) {
return true;
}
final int len = s.length();
for (int i = 1; i < len; i++) {
c = s.charAt(i);
if (!isErlangLetter(c) && !isErlangDigit(c) && c != '@') {
return true;
}
}
return false;
}
/*
* Get the atom string, with special characters escaped. Note that this
* function currently does not consider any characters above 127 to be
* printable.
*/
private String escapeSpecialChars(final String s) {
char c;
final StringBuffer so = new StringBuffer();
final int len = s.length();
for (int i = 0; i < len; i++) {
c = s.charAt(i);
/*
* note that some of these escape sequences are unique to Erlang,
* which is why the corresponding 'case' values use octal. The
* resulting string is, of course, in Erlang format.
*/
switch (c) {
// some special escape sequences
case '\b':
so.append("\\b");
break;
case 0177:
so.append("\\d");
break;
case 033:
so.append("\\e");
break;
case '\f':
so.append("\\f");
break;
case '\n':
so.append("\\n");
break;
case '\r':
so.append("\\r");
break;
case '\t':
so.append("\\t");
break;
case 013:
so.append("\\v");
break;
case '\\':
so.append("\\\\");
break;
case '\'':
so.append("\\'");
break;
case '\"':
so.append("\\\"");
break;
default:
// some other character classes
if (c < 027) {
// control chars show as "\^@", "\^A" etc
so.append("\\^" + (char) ('A' - 1 + c));
} else if (c > 126) {
// 8-bit chars show as \345 \344 \366 etc
so.append("\\" + Integer.toOctalString(c));
} else {
// character is printable without modification!
so.append(c);
}
}
}
return new String(so);
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy