← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gpsprune/utopic

« back to all changes in this revision

Viewing changes to tim/prune/save/xml/GpxSlicer.java

  • Committer: Package Import Robot
  • Author(s): David Paleino
  • Date: 2014-07-03 10:26:09 UTC
  • mfrom: (1.2.1) (13.1.1 experimental)
  • Revision ID: package-import@ubuntu.com-20140703102609-mtkt1enup5wfsok8
Tags: 16.2-1
* Upload to unstable.
* New upstream release.
* Switch Recommends from gnuplot to gnuplot-x11, bug reported by upstream (!)
* Bump B-D on libmetadata-extractor-java (>= 2.6.4), which was in
  experimental until now

Show diffs side-by-side

added added

removed removed

Lines of Context:
tim/prune/save/xml/GpxSlicer.java
12
12
{
13
13
        /** listener to receive tags */
14
14
        private TagReceiver _receiver = null;
15
 
        /** string builder for copying source xml */
16
 
        private StringBuilder _builder = null;
17
15
 
18
16
        // character sequences for start and end of tags
19
17
        private static final char[] GPX_START = "<gpx".toCharArray();
27
25
        private static final char[] CDATA_START = "<![CDATA[".toCharArray();
28
26
        private static final char[] CDATA_END = "]]>".toCharArray();
29
27
 
30
 
 
31
28
        /**
32
29
         * Constructor
33
30
         * @param inReceiver listener for tags
43
40
         */
44
41
        public void slice(InputStream inStream)
45
42
        {
46
 
                _builder = new StringBuilder(100);
 
43
                StringBuffer beginBuffer = new StringBuffer(200);
 
44
                ByteBuffer byteBuffer = new ByteBuffer();
47
45
                boolean insideTag = false;
48
46
                boolean insideCdata = false;
49
47
                char[] endTag = null;
53
51
                {
54
52
                        while ((b = inStream.read()) >= 0)
55
53
                        {
56
 
                                if (!insideTag && !insideCdata) {
57
 
                                        if (b == '<') _builder.setLength(0);
58
 
                                }
59
54
                                // copy character
60
 
                                _builder.append((char)b);
 
55
                                byteBuffer.appendByte((byte) b);
 
56
                                // clear buffer if necessary
 
57
                                if (!insideTag && !insideCdata && (b == '>' || b == '\n'))
 
58
                                {
 
59
                                        byteBuffer.clear();
 
60
                                        continue;
 
61
                                }
 
62
                                // if we're still at the beginning, copy to the begin buffer as well
 
63
                                if (beginBuffer != null) {beginBuffer.append((char) b);}
61
64
 
62
65
                                if (insideCdata) {
63
66
                                        // Just look for end of cdata block
64
 
                                        if (foundSequence(CDATA_END)) {insideCdata = false;}
 
67
                                        if (byteBuffer.foundSequence(CDATA_END)) {insideCdata = false;}
65
68
                                }
66
69
                                else
67
70
                                {
68
71
                                        if (!insideTag)
69
72
                                        {
70
73
                                                // Look for start of one of the tags
71
 
                                                if (!foundHeader && foundSequence(GPX_START)) {
 
74
                                                if (!foundHeader && byteBuffer.foundSequence(GPX_START))
 
75
                                                {
72
76
                                                        insideTag = true;
73
77
                                                        foundHeader = true;
74
78
                                                        endTag = GPX_END;
 
79
                                                        // Check begin buffer for utf8 encoding
 
80
                                                        if (beginBuffer != null && beginBuffer.toString().toLowerCase().indexOf("encoding=\"utf-8\"") > 0)
 
81
                                                        {
 
82
                                                                byteBuffer.setEncodingUtf8();
 
83
                                                        }
 
84
                                                        beginBuffer = null; // don't need it any more
75
85
                                                }
76
86
                                                else if (b == 't')
77
87
                                                {
78
 
                                                        if (foundSequence(TRKPT_START)) {
 
88
                                                        if (byteBuffer.foundSequence(TRKPT_START)) {
79
89
                                                                insideTag = true;
80
90
                                                                endTag = TRKPT_END;
81
91
                                                        }
82
 
                                                        else if (foundSequence(WPT_START)) {
 
92
                                                        else if (byteBuffer.foundSequence(WPT_START)) {
83
93
                                                                insideTag = true;
84
94
                                                                endTag = WPT_END;
85
95
                                                        }
86
 
                                                        else if (foundSequence(RTEPT_START)) {
 
96
                                                        else if (byteBuffer.foundSequence(RTEPT_START)) {
87
97
                                                                insideTag = true;
88
98
                                                                endTag = RTEPT_END;
89
99
                                                        }
92
102
                                        else
93
103
                                        {
94
104
                                                // Look for end of found tag
95
 
                                                if (foundSequence(endTag)) {
96
 
                                                        _receiver.reportTag(_builder.toString());
97
 
                                                        _builder.setLength(0);
 
105
                                                if (byteBuffer.foundSequence(endTag))
 
106
                                                {
 
107
                                                        String tag = byteBuffer.toString();
 
108
                                                        _receiver.reportTag(tag);
 
109
                                                        byteBuffer.clear();
98
110
                                                        insideTag = false;
99
111
                                                }
100
112
                                        }
101
113
                                        // Look for start of cdata block
102
 
                                        if (foundSequence(CDATA_START)) {insideCdata = true;}
 
114
                                        if (byteBuffer.foundSequence(CDATA_START)) {
 
115
                                                insideCdata = true;
 
116
                                        }
103
117
                                }
104
118
                        }
105
119
                }
106
120
                catch (IOException e) {} // ignore
107
121
        }
108
 
 
109
 
        /**
110
 
         * Look for the given character sequence in the last characters read
111
 
         * @param inChars sequence to look for
112
 
         * @return true if sequence found
113
 
         */
114
 
        private boolean foundSequence(char[] inChars)
115
 
        {
116
 
                final int numChars = inChars.length;
117
 
                final int bufflen = _builder.length();
118
 
                if (bufflen < numChars) {return false;}
119
 
                for (int i=0; i<numChars; i++)
120
 
                {
121
 
                        char searchChar = inChars[numChars - 1 - i];
122
 
                        char sourceChar = _builder.charAt(bufflen - 1 - i);
123
 
                        if (searchChar != sourceChar) {return false;}
124
 
                        //if (Character.toLowerCase(searchChar) != Character.toLowerCase(sourceChar)) {return false;}
125
 
                }
126
 
                return true;
127
 
        }
128
122
}