NmeaMessage.java

package au.gov.amsa.util.nmea;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Bean to carry NMEA fields.
 * 
 * @author dxm
 * 
 */
public class NmeaMessage {

    private final LinkedHashMap<String, String> tags;
    private final List<String> items;
    private final Talker talker;
    private final SentenceInfo sentenceInfo;
    private final String checksum;

    /**
     * Constructor.
     * 
     * @param tags
     *            is a list of tags from the tag block section of an NMEA
     *            message
     * @param items
     *            is the list of columns from the NMEA message (not including
     *            the tag block) but including the checksum on the final column.
     */
    public NmeaMessage(LinkedHashMap<String, String> tags, List<String> items, String checksum) {
        this.tags = tags;
        this.items = items;
        if (!items.isEmpty() && items.get(0).length() >= 3)
            this.talker = NmeaUtil.getTalker((items.get(0).substring(1, 3)));
        else
            talker = Talker.UNKNOWN;
        this.sentenceInfo = getSentenceInfo(tags, items);
        this.checksum = checksum;
    }

    /**
     * Returns the 's:' value from the tag block.
     * 
     * @return
     */
    public String getSource() {
        return tags.get("s");
    }

    /**
     * Returns the 'c:' value from the tag block times 1000 to convert to
     * millis. Returns null if not present.
     * 
     * @return
     */
    public Long getUnixTimeMillis() {
        String time = tags.get("c");
        if (time == null)
            return null;
        else
            try {
                return Long.parseLong(time) * 1000;
            } catch (NumberFormatException e) {
                return null;
            }
    }

    /**
     * Returns the 'd:' value from the tag block.
     * 
     * @return
     */
    public String getDestination() {
        return tags.get("d");
    }

    /**
     * Returns the 'g:' value from the tag block.
     * 
     * @return
     */
    public String getSentenceGroupingFromTagBlock() {
        return tags.get("g");
    }

    /**
     * Returns the 'n:' value from the tag block.
     * 
     * @return
     */
    public Integer getLineCount() {
        String count = tags.get("n");
        if (count == null)
            return null;
        else
            return Integer.parseInt(count);
    }

    /**
     * Returns the 'r:' value from the tag block times 1000 to convert to
     * millis.
     * 
     * @return
     */
    public Long getRelativeTimeMillis() {
        String time = tags.get("r");
        if (time == null)
            return null;
        else
            return Long.parseLong(time) * 1000;
    }

    /**
     * Returns the 't:' value from the tag block.
     * 
     * @return
     */
    public String getText() {
        return tags.get("t");
    }

    /**
     * Returns a list of the NMEA items from the columns after the tag block.
     * 
     * @return
     */
    public List<String> getItems() {
        return items;
    }

    public LinkedHashMap<String, String> getTags() {
        return tags;
    }

    public Talker getTalker() {
        return talker;
    }

    public String toLine() {
        return NmeaUtil.createNmeaLine(tags, items);
    }

    public Integer getSentenceNumber() {
        if (sentenceInfo != null)
            return sentenceInfo.number;
        else
            return null;
    }

    public Integer getSentenceCount() {
        if (sentenceInfo != null)
            return sentenceInfo.count;
        else
            return null;
    }

    public String getSentenceGroupId() {
        if (sentenceInfo != null)
            return sentenceInfo.id;
        else
            return null;
    }

    /**
     * Returns a recalculated checksum.
     * 
     * @return calculated checksum
     */
    public String calculateChecksum() {
        return NmeaUtil.getChecksum(NmeaUtil.createNmeaLine(tags, items));
    }

    public String getChecksum() {
        return checksum;
    }

    private static final Pattern sentenceTagPattern = Pattern
            .compile("([1-9][0-9]*)G([1-9][0-9]*)");

    private static SentenceInfo getSentenceInfo(LinkedHashMap<String, String> tags,
            List<String> items) {
        try {
            String g = tags.get("g");
            if (g != null) {
                // old style NMEA 4.0.0 sentence grouping tag
                String[] parts = g.split("-");
                if (parts.length < 3)
                    throw new NmeaMessageParseException("not enough parts available in g tag");
                int number = Integer.parseInt(parts[0]);
                int count = Integer.parseInt(parts[1]);
                String id = parts[2];
                return new SentenceInfo(number, count, id);

            } else {
                // look for new style NMEA 4.1.0 sentence grouping tag (e.g.
                // 1G2)
                for (Entry<String, String> entry : tags.entrySet()) {
                    Matcher matcher = sentenceTagPattern.matcher(entry.getKey());
                    if (matcher.matches()) {
                        int number = Integer.parseInt(matcher.group(1));
                        int count = Integer.parseInt(matcher.group(2));
                        String id = entry.getValue();
                        // found it so return the sentence info
                        return new SentenceInfo(number, count, id);
                    }
                }
                // didn't find the grouping tag
                if (items.size() > 2 && isEncapsulationSentence(items)) {
                    int number = Integer.parseInt(items.get(2));
                    int count = Integer.parseInt(items.get(1));
                    String id = items.get(3);
                    return new SentenceInfo(number, count, id);
                } else
                    return null;
            }
        } catch (NumberFormatException e) {
            throw new NmeaMessageParseException(e.getMessage(), e);
        }
    }

    private static boolean isEncapsulationSentence(List<String> items) {
        return items.size() > 0 && items.get(0).startsWith("!");
    }

    private static class SentenceInfo {
        int number;
        int count;
        String id;

        public SentenceInfo(int number, int count, String id) {
            super();
            this.number = number;
            this.count = count;
            this.id = id;
        }
    }

    public boolean isSingleSentence() {
        return getSentenceCount() == null || getSentenceCount() == 1;
    }

    public Long getArrivalTimeMillis() {
        String time = tags.get("a");
        if (time == null)
            return null;
        else
            try {
                return Long.parseLong(time);
            } catch (NumberFormatException e) {
                return null;
            }
    }

}