/****************************************************************
* Licensed to the Apache Software Foundation (ASF) under one *
* or more contributor license agreements. See the NOTICE file *
* distributed with this work for additional information *
* regarding copyright ownership. The ASF licenses this file *
* to you under the Apache License, Version 2.0 (the *
* "License"); you may not use this file except in compliance *
* with the License. You may obtain a copy of the License at *
* *
* http://www.apache.org/licenses/LICENSE-2.0 *
* *
* Unless required by applicable law or agreed to in writing, *
* software distributed under the License is distributed on an *
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY *
* KIND, either express or implied. See the License for the *
* specific language governing permissions and limitations *
* under the License. *
****************************************************************/
package org.apache.james.mime4j.field.address;
import org.apache.james.mime4j.decoder.DecoderUtil;
import org.apache.james.mime4j.field.address.parser.ASTaddr_spec;
import org.apache.james.mime4j.field.address.parser.ASTaddress;
import org.apache.james.mime4j.field.address.parser.ASTaddress_list;
import org.apache.james.mime4j.field.address.parser.ASTangle_addr;
import org.apache.james.mime4j.field.address.parser.ASTdomain;
import org.apache.james.mime4j.field.address.parser.ASTgroup_body;
import org.apache.james.mime4j.field.address.parser.ASTlocal_part;
import org.apache.james.mime4j.field.address.parser.ASTmailbox;
import org.apache.james.mime4j.field.address.parser.ASTname_addr;
import org.apache.james.mime4j.field.address.parser.ASTphrase;
import org.apache.james.mime4j.field.address.parser.ASTroute;
import org.apache.james.mime4j.field.address.parser.Node;
import org.apache.james.mime4j.field.address.parser.SimpleNode;
import org.apache.james.mime4j.field.address.parser.Token;
import java.util.ArrayList;
import java.util.Iterator;
/**
* Transforms the JJTree-generated abstract syntax tree
* into a graph of org.apache.james.mime4j.field.address objects.
*
*
*/
class Builder {
private static Builder singleton = new Builder();
public static Builder getInstance() {
return singleton;
}
public AddressList buildAddressList(ASTaddress_list node) {
ArrayList list = new ArrayList();
for (int i = 0; i < node.jjtGetNumChildren(); i++) {
ASTaddress childNode = (ASTaddress) node.jjtGetChild(i);
Address address = buildAddress(childNode);
list.add(address);
}
return new AddressList(list, true);
}
private Address buildAddress(ASTaddress node) {
ChildNodeIterator it = new ChildNodeIterator(node);
Node n = it.nextNode();
if (n instanceof ASTaddr_spec) {
return buildAddrSpec((ASTaddr_spec)n);
}
else if (n instanceof ASTangle_addr) {
return buildAngleAddr((ASTangle_addr)n);
}
else if (n instanceof ASTphrase) {
String name = buildString((ASTphrase)n, false);
Node n2 = it.nextNode();
if (n2 instanceof ASTgroup_body) {
return new Group(name, buildGroupBody((ASTgroup_body)n2));
}
else if (n2 instanceof ASTangle_addr) {
name = DecoderUtil.decodeEncodedWords(name);
return new NamedMailbox(name, buildAngleAddr((ASTangle_addr)n2));
}
else {
throw new IllegalStateException();
}
}
else {
throw new IllegalStateException();
}
}
private MailboxList buildGroupBody(ASTgroup_body node) {
ArrayList results = new ArrayList();
ChildNodeIterator it = new ChildNodeIterator(node);
while (it.hasNext()) {
Node n = it.nextNode();
if (n instanceof ASTmailbox)
results.add(buildMailbox((ASTmailbox)n));
else
throw new IllegalStateException();
}
return new MailboxList(results, true);
}
private Mailbox buildMailbox(ASTmailbox node) {
ChildNodeIterator it = new ChildNodeIterator(node);
Node n = it.nextNode();
if (n instanceof ASTaddr_spec) {
return buildAddrSpec((ASTaddr_spec)n);
}
else if (n instanceof ASTangle_addr) {
return buildAngleAddr((ASTangle_addr)n);
}
else if (n instanceof ASTname_addr) {
return buildNameAddr((ASTname_addr)n);
}
else {
throw new IllegalStateException();
}
}
private NamedMailbox buildNameAddr(ASTname_addr node) {
ChildNodeIterator it = new ChildNodeIterator(node);
Node n = it.nextNode();
String name;
if (n instanceof ASTphrase) {
name = buildString((ASTphrase)n, false);
}
else {
throw new IllegalStateException();
}
n = it.nextNode();
if (n instanceof ASTangle_addr) {
name = DecoderUtil.decodeEncodedWords(name);
return new NamedMailbox(name, buildAngleAddr((ASTangle_addr) n));
}
else {
throw new IllegalStateException();
}
}
private Mailbox buildAngleAddr(ASTangle_addr node) {
ChildNodeIterator it = new ChildNodeIterator(node);
DomainList route = null;
Node n = it.nextNode();
if (n instanceof ASTroute) {
route = buildRoute((ASTroute)n);
n = it.nextNode();
}
else if (n instanceof ASTaddr_spec)
; // do nothing
else
throw new IllegalStateException();
if (n instanceof ASTaddr_spec)
return buildAddrSpec(route, (ASTaddr_spec)n);
else
throw new IllegalStateException();
}
private DomainList buildRoute(ASTroute node) {
ArrayList results = new ArrayList(node.jjtGetNumChildren());
ChildNodeIterator it = new ChildNodeIterator(node);
while (it.hasNext()) {
Node n = it.nextNode();
if (n instanceof ASTdomain)
results.add(buildString((ASTdomain)n, true));
else
throw new IllegalStateException();
}
return new DomainList(results, true);
}
private Mailbox buildAddrSpec(ASTaddr_spec node) {
return buildAddrSpec(null, node);
}
private Mailbox buildAddrSpec(DomainList route, ASTaddr_spec node) {
ChildNodeIterator it = new ChildNodeIterator(node);
String localPart = buildString((ASTlocal_part)it.nextNode(), true);
String domain = buildString((ASTdomain)it.nextNode(), true);
return new Mailbox(route, localPart, domain);
}
private String buildString(SimpleNode node, boolean stripSpaces) {
Token head = node.firstToken;
Token tail = node.lastToken;
StringBuffer out = new StringBuffer();
while (head != tail) {
out.append(head.image);
head = head.next;
if (!stripSpaces)
addSpecials(out, head.specialToken);
}
out.append(tail.image);
return out.toString();
}
private void addSpecials(StringBuffer out, Token specialToken) {
if (specialToken != null) {
addSpecials(out, specialToken.specialToken);
out.append(specialToken.image);
}
}
private static class ChildNodeIterator implements Iterator {
private SimpleNode simpleNode;
private int index;
private int len;
public ChildNodeIterator(SimpleNode simpleNode) {
this.simpleNode = simpleNode;
this.len = simpleNode.jjtGetNumChildren();
this.index = 0;
}
public void remove() {
throw new UnsupportedOperationException();
}
public boolean hasNext() {
return index < len;
}
public Object next() {
return nextNode();
}
public Node nextNode() {
return simpleNode.jjtGetChild(index++);
}
}
}