mUndoQueue, mRedoQueue;
32 |
33 | private String mOldText, mNewText;
34 | private int trackingState;
35 |
36 | public RunDoNative() {
37 | mHandler = new Handler();
38 | mRunnable = new WriteToArrayDequeRunnable(this);
39 |
40 | countdownTimerLength = DEFAULT_TIMER_LENGTH;
41 | queueSize = DEFAULT_QUEUE_SIZE;
42 |
43 | trackingState = TRACKING_ENDED;
44 | }
45 |
46 | public static RunDoNative newInstance() {
47 | return new RunDoNative();
48 | }
49 |
50 | @Override
51 | public void onAttach(Context context) {
52 | super.onAttach(context);
53 | try {
54 | mTextLink = (RunDo.TextLink) context;
55 | } catch (ClassCastException e) {
56 | throw new ClassCastException(context.toString() + " must implement RunDo.TextLink");
57 | }
58 |
59 | if (context instanceof RunDo.Callbacks) mCallbacks = (RunDo.Callbacks) context;
60 | }
61 |
62 | @Override
63 | public void onCreate(Bundle savedInstanceState) {
64 | super.onCreate(savedInstanceState);
65 |
66 | if (mUndoQueue == null) mUndoQueue = new FixedSizeArrayDeque<>(queueSize);
67 | if (mRedoQueue == null) mRedoQueue = new FixedSizeArrayDeque<>(queueSize);
68 |
69 | }
70 |
71 | @Override
72 | public void onActivityCreated(Bundle savedInstanceState) {
73 | super.onActivityCreated(savedInstanceState);
74 |
75 | if (savedInstanceState != null) {
76 | mUndoQueue = savedInstanceState.getParcelable(UNDO_TAG);
77 | mRedoQueue = savedInstanceState.getParcelable(REDO_TAG);
78 |
79 | mOldText = savedInstanceState.getString(OLD_TEXT_TAG);
80 |
81 | isRunning = savedInstanceState.getBoolean(CONFIG_CHANGE_TAG);
82 |
83 | if(isRunning) startCountdownRunnable();
84 |
85 | trackingState = TRACKING_STARTED;
86 | }
87 |
88 | }
89 |
90 | @Override
91 | public void onResume() {
92 | super.onResume();
93 | mTextLink.getEditTextForRunDo().addTextChangedListener(this);
94 | }
95 |
96 | @Override
97 | public void onSaveInstanceState(Bundle outState) {
98 | super.onSaveInstanceState(outState);
99 |
100 | outState.putParcelable(UNDO_TAG, mUndoQueue);
101 | outState.putParcelable(REDO_TAG, mRedoQueue);
102 |
103 | outState.putString(OLD_TEXT_TAG, mOldText);
104 |
105 | outState.putBoolean(CONFIG_CHANGE_TAG, isRunning);
106 |
107 | if (isRunning) stopCountdownRunnable();
108 |
109 | }
110 |
111 | @Override
112 | public void onDetach() {
113 | mTextLink = null;
114 | super.onDetach();
115 | }
116 |
117 | @Override
118 | public void beforeTextChanged(CharSequence s, int start, int count, int after) {
119 |
120 | if (mOldText == null) mOldText = mTextLink.getEditTextForRunDo().getText().toString();
121 |
122 | if (trackingState == TRACKING_ENDED) {
123 |
124 | //Redo Queue should only be required as response to Undo calls. Otherwise clear.
125 | mRedoQueue.clear();
126 |
127 | startCountdownRunnable();
128 | trackingState = TRACKING_CURRENT;
129 | }
130 |
131 | }
132 |
133 | @Override
134 | public void onTextChanged(CharSequence s, int start, int before, int count) {
135 |
136 | switch (trackingState) {
137 | case TRACKING_STARTED:
138 | trackingState = TRACKING_ENDED;
139 | break;
140 | case TRACKING_CURRENT:
141 | restartCountdownRunnable();
142 | break;
143 | }
144 |
145 | }
146 |
147 | @Override
148 | public void afterTextChanged(Editable s) {
149 | //Unused
150 | }
151 |
152 | /**
153 | *
154 | * @see {@link WriteToArrayDeque#getNewString()}
155 | */
156 | @Override
157 | public String getNewString() {
158 | mNewText = mTextLink.getEditTextForRunDo().getText().toString();
159 | return mNewText;
160 | }
161 |
162 | /**
163 | *
164 | * @see {@link WriteToArrayDeque#getOldString()}
165 | */
166 | @Override
167 | public String getOldString() {
168 | return mOldText;
169 | }
170 |
171 | /**
172 | *
173 | * @see {@link WriteToArrayDeque#notifyArrayDequeDataReady(com.werdpressed.partisan.rundo.SubtractStrings.Item)}
174 | */
175 | @Override
176 | public void notifyArrayDequeDataReady(SubtractStrings.Item item) {
177 |
178 | mUndoQueue.addFirst(item);
179 |
180 | mOldText = mTextLink.getEditTextForRunDo().getText().toString();
181 |
182 | trackingState = TRACKING_ENDED;
183 |
184 | }
185 |
186 | /**
187 | *
188 | * @see {@link WriteToArrayDeque#setIsRunning(boolean)}
189 | */
190 | @Override
191 | public void setIsRunning(boolean isRunning) {
192 | this.isRunning = isRunning;
193 | }
194 |
195 | /**
196 | *
197 | * @see {@link RunDo#setQueueSize(int)}
198 | */
199 | @Override
200 | public void setQueueSize(int size) {
201 | queueSize = size;
202 | mUndoQueue = new FixedSizeArrayDeque<>(queueSize);
203 | mRedoQueue = new FixedSizeArrayDeque<>(queueSize);
204 | }
205 |
206 | /**
207 | *
208 | * @see {@link RunDo#setTimerLength(long)}
209 | */
210 | @Override
211 | public void setTimerLength(long lengthInMillis) {
212 | countdownTimerLength = lengthInMillis;
213 | }
214 |
215 | /**
216 | *
217 | * @see {@link RunDo#undo()}
218 | */
219 | @Override
220 | public void undo() {
221 |
222 | if (isRunning) {
223 | restartCountdownRunnableImmediately();
224 | return;
225 | }
226 |
227 | trackingState = TRACKING_STARTED;
228 |
229 | if (mUndoQueue.peek() == null) {
230 | //Log.e(TAG, "Undo Queue Empty");
231 | return;
232 | }
233 |
234 | try {
235 |
236 | SubtractStrings.Item temp = mUndoQueue.poll();
237 |
238 | switch (temp.getDeviationType()) {
239 | case SubtractStrings.ADDITION:
240 | mTextLink.getEditTextForRunDo().getText().delete(
241 | temp.getFirstDeviation(),
242 | temp.getLastDeviationNewText()
243 | );
244 | break;
245 | case SubtractStrings.DELETION:
246 | mTextLink.getEditTextForRunDo().getText().insert(
247 | temp.getFirstDeviation(),
248 | temp.getReplacedText());
249 | break;
250 | case SubtractStrings.REPLACEMENT:
251 | mTextLink.getEditTextForRunDo().getText().replace(
252 | temp.getFirstDeviation(),
253 | temp.getLastDeviationNewText(),
254 | temp.getReplacedText());
255 | break;
256 | case SubtractStrings.UNCHANGED:
257 | break;
258 | default:
259 | break;
260 | }
261 |
262 | mTextLink.getEditTextForRunDo().setSelection(temp.getFirstDeviation());
263 |
264 | mRedoQueue.addFirst(temp);
265 |
266 | if (mCallbacks != null) mCallbacks.undoCalled();
267 |
268 | } catch (IndexOutOfBoundsException e) {
269 | e.printStackTrace();
270 | } finally {
271 | mOldText = mTextLink.getEditTextForRunDo().getText().toString();
272 | }
273 |
274 | }
275 |
276 | /**
277 | *
278 | * @see {@link RunDo#redo()}
279 | */
280 | @Override
281 | public void redo() {
282 |
283 | trackingState = TRACKING_STARTED;
284 |
285 | if (mRedoQueue.peek() == null) {
286 | //Log.e(TAG, "Redo Queue Empty");
287 | return;
288 | }
289 |
290 | try {
291 |
292 | SubtractStrings.Item temp = mRedoQueue.poll();
293 |
294 | switch (temp.getDeviationType()) {
295 | case SubtractStrings.ADDITION:
296 | mTextLink.getEditTextForRunDo().getText().insert(
297 | temp.getFirstDeviation(),
298 | temp.getAlteredText());
299 | break;
300 | case SubtractStrings.DELETION:
301 | mTextLink.getEditTextForRunDo().getText().delete(
302 | temp.getFirstDeviation(),
303 | temp.getLastDeviationOldText()
304 | );
305 | break;
306 | case SubtractStrings.REPLACEMENT:
307 | mTextLink.getEditTextForRunDo().getText().replace(
308 | temp.getFirstDeviation(),
309 | temp.getLastDeviationOldText(),
310 | temp.getAlteredText());
311 | break;
312 | case SubtractStrings.UNCHANGED:
313 | break;
314 | default:
315 | break;
316 |
317 | }
318 |
319 | mTextLink.getEditTextForRunDo().setSelection(temp.getFirstDeviation());
320 |
321 | mUndoQueue.addFirst(temp);
322 |
323 | if (mCallbacks != null) mCallbacks.redoCalled();
324 |
325 | } catch (IndexOutOfBoundsException e) {
326 | e.printStackTrace();
327 | } finally {
328 | mOldText = mTextLink.getEditTextForRunDo().getText().toString();
329 | }
330 |
331 | }
332 |
333 | /**
334 | *
335 | * @see {@link RunDo#clearAllQueues()}
336 | */
337 | @Override
338 | public void clearAllQueues() {
339 | mUndoQueue.clear();
340 | mRedoQueue.clear();
341 | }
342 |
343 | private void restartCountdownRunnableImmediately() {
344 | stopCountdownRunnable();
345 | mHandler.post(mRunnable);
346 | }
347 |
348 | private void startCountdownRunnable() {
349 | isRunning = true;
350 | mHandler.postDelayed(mRunnable, countdownTimerLength);
351 | }
352 |
353 | private void stopCountdownRunnable() {
354 | mHandler.removeCallbacks(mRunnable);
355 | isRunning = false;
356 | }
357 |
358 | private void restartCountdownRunnable() {
359 | stopCountdownRunnable();
360 | startCountdownRunnable();
361 | }
362 |
363 | }
--------------------------------------------------------------------------------
/rundo/src/main/java/com/werdpressed/partisan/rundo/SubtractStrings.java:
--------------------------------------------------------------------------------
1 | package com.werdpressed.partisan.rundo;
2 |
3 | import android.os.Parcel;
4 | import android.os.Parcelable;
5 |
6 | import com.werdpressed.partisan.rundo.utils.SubtractStringUtils;
7 |
8 | import java.util.Arrays;
9 |
10 | final class SubtractStrings {
11 |
12 | @SuppressWarnings("unused")
13 | private static final String TAG = "SubtractStrings";
14 |
15 | static final int ADDITION = 55023;
16 | static final int REPLACEMENT = ADDITION + 1;
17 | static final int DELETION = ADDITION + 2;
18 | static final int UNCHANGED = ADDITION + 3;
19 |
20 | private final char[] mOldText, mNewText;
21 |
22 | private int firstDeviation = -1;
23 | private int lastDeviationOldText = -1;
24 | private int lastDeviationNewText = -1;
25 | private int deviationType = -1;
26 |
27 | private Item mItem = null;
28 |
29 | public SubtractStrings(String oldString, String newString) {
30 |
31 | mOldText = oldString.toCharArray();
32 | mNewText = newString.toCharArray();
33 |
34 | }
35 |
36 | /**
37 | * Calculates the first point of deviation between old and new text, by comparing each individual
38 | * char from beginning to end.
39 | *
40 | * @see #getFirstDeviation()
41 | */
42 | private int findFirstDeviation() {
43 |
44 | if (isOldTextEqualToNewText()) return 0;
45 |
46 | int shortestLength = findShortestLength();
47 |
48 | for (int i = 0; i < shortestLength; i++) {
49 | if (mOldText[i] != mNewText[i]) {
50 | shortestLength = i;
51 | break;
52 | }
53 | }
54 |
55 | return shortestLength;
56 | }
57 |
58 | /**
59 | * Calculates the last point of deviation by reversing old and new text, and repeating the same
60 | * process as {@link #findFirstDeviation()}. Different values are assigned for old and new text
61 | * in order to effectively calculate what has changed between the two. This is especially
62 | * relevant when text is replaced.
63 | *
64 | * Under certain circumstances, running both this and {@link #findFirstDeviation()} alone will
65 | * produce incorrect results, especially when words are duplicated. For example:
66 | *
67 | *
68 | * {@code
69 | * int firstDeviation, lastDeviation;
70 | *
71 | * char[] mOldText = new String("one").toCharArray();
72 | * char[] mNewText = new String("one one").toCharArray();
73 | *
74 | * findFirstDeviation();
75 | * findLastDeviation();
76 | *
77 | * String output = new String(mNewText).subString(firstDeviation, lastDeviation);
78 | *
79 | * //firstDeviation will equal 3, last deviation 4, and "output" will be " ".
80 | * }
81 | *
82 | *
83 | * This is because the first deviation comes after the first "e", at index 3, yet when the
84 | * arrays are reversed, the "e" at the end of "one" in mOldText shifts to index 0. It is
85 | * effectively counted twice:
86 | *
87 | *
88 | * {@code
89 | * char[] mOldText = new char[]{ 'o', 'n', 'e' }
90 | * char[] mNewText = new char[]{ 'o', 'n', 'e', ' ', 'o', 'n', 'e' };
91 | *
92 | * mOldTextReversed = new char[]{ 'e', 'n', 'o' };
93 | * mNewTextReversed = new char[]{ 'e', 'n', 'o', ' ', 'e', 'n', 'o'};
94 | * }
95 | *
96 | *
97 | * lastDeviation values are adjusted in {@link #findLastDeviationOffsetSize(char[], char[], int)}
98 | * to account for such situations.
99 | *
100 | * @return Last point of deviation between old and new text, in relation to old text.
101 | *
102 | * @see #findLastDeviationNewText()
103 | * @see #getLastDeviationOldText()
104 | * @see Item#getLastDeviationOldText()
105 | */
106 | private int findLastDeviationOldText() {
107 |
108 | if (isOldTextEqualToNewText()) return 0;
109 |
110 | final int shortestLength = findShortestLength();
111 |
112 | final char[] oldTextReversed = SubtractStringUtils.reverseCharArray(mOldText);
113 | final char[] newTextReversed = SubtractStringUtils.reverseCharArray(mNewText);
114 |
115 | int tempLastDeviation = shortestLength;
116 | int difference = Math.abs((mNewText.length - mOldText.length));
117 |
118 | for (int i = 0; i < shortestLength; i++) {
119 | if (oldTextReversed[i] != newTextReversed[i]) {
120 | tempLastDeviation = i;
121 | break;
122 | }
123 | }
124 |
125 | int lastDeviation =
126 | findLastDeviationOffsetSize(oldTextReversed, newTextReversed, tempLastDeviation);
127 |
128 | return (isNewTextLonger() ? (lastDeviation - difference) : lastDeviation);
129 |
130 | }
131 |
132 | /**
133 | * Identical process to {@link #findLastDeviationOldText()}, except value returned is in
134 | * relation to new text.
135 | *
136 | * @return Last point of deviation between old and new text, in relation to new text.
137 | *
138 | * @see #findLastDeviationOldText()
139 | * @see #getLastDeviationNewText()
140 | * @see Item#getLastDeviationNewText()
141 | */
142 | private int findLastDeviationNewText() {
143 |
144 | if (isOldTextEqualToNewText()) return 0;
145 |
146 | final int shortestLength = findShortestLength();
147 |
148 | final char[] oldTextReversed = SubtractStringUtils.reverseCharArray(mOldText);
149 | final char[] newTextReversed = SubtractStringUtils.reverseCharArray(mNewText);
150 |
151 | int tempLastDeviation = shortestLength;
152 | int difference = Math.abs((mNewText.length - mOldText.length));
153 |
154 | for (int i = 0; i < shortestLength; i++) {
155 | if (oldTextReversed[i] != newTextReversed[i]) {
156 | tempLastDeviation = i;
157 | break;
158 | }
159 | }
160 |
161 | int lastDeviation =
162 | findLastDeviationOffsetSize(oldTextReversed, newTextReversed, tempLastDeviation);
163 |
164 | return (isNewTextLonger() ? lastDeviation : (lastDeviation - difference));
165 |
166 | }
167 |
168 | /**
169 | * Adjusts the last point at which the two {@code char[]} diverge, due to the reasons outlined in
170 | * {@link #findLastDeviationOldText()}. This is achieved by calculating the difference in length between
171 | * the old and new text, and comparing each {@code char} from this final end point to the char at the
172 | * same position less the offset difference. If the same value is found, then the current
173 | * index is used to determine the true last deviation value. For example:
174 | *
175 | *
176 | * {@code
177 | * mOldTextReversed = new char[]{ 'e', 'n', 'o' };
178 | * mNewTextReversed = new char[]{ 'e', 'n', 'o', ' ', 'e', 'n', 'o'};
179 | * }
180 | *
181 | *
182 | * In this case, the potential offset size (the length of the longest array subtracted from the
183 | * shortest) is {@code(7 - 3) = 4}. Thus, the char at index [4] of the longest array, which is
184 | * 'e', is compared to the char at index[0] (4 - (potentialOffsetSize of 4) = 0), which is also
185 | * 'e'. As the two values match, the final value returned is
186 | * (length of the longest array - (current index - potential offset size)), which translates
187 | * to (7 - (4 - 0)) = 3.
188 | *
189 | * @param oldText Reversed old text
190 | * @param newText Reversed new text
191 | * @param tempLastDeviation The current last deviation figure. This is the value that will be
192 | * checked and possibly altered before being returned.
193 | * @return The adjusted last deviation value.
194 | */
195 | private int findLastDeviationOffsetSize(char[] oldText, char[] newText, int tempLastDeviation) {
196 |
197 | final char[] longestArray = (isNewTextLonger()) ? newText : oldText;
198 | final int potentialOffsetSize = (newText.length - oldText.length);
199 |
200 | boolean isOffsetWithinArrayBounds =
201 | ((tempLastDeviation + potentialOffsetSize) < longestArray.length);
202 |
203 | final int maxValue = (isOffsetWithinArrayBounds)
204 | ? (tempLastDeviation + potentialOffsetSize)
205 | : longestArray.length;
206 |
207 | final int reverseDeviation = (tempLastDeviation < potentialOffsetSize)
208 | ? potentialOffsetSize
209 | : tempLastDeviation;
210 |
211 | for (int i = reverseDeviation; i < maxValue; i++) {
212 |
213 | if (longestArray[i] == longestArray[i - reverseDeviation]) {
214 | return (longestArray.length - (i - reverseDeviation));
215 | }
216 | }
217 |
218 | return findLongestLength();
219 |
220 | }
221 |
222 | private int findLastDeviationOldTextFromNew() {
223 | final int difference = findLengthDifference();
224 | return (isNewTextLonger())
225 | ? (lastDeviationNewText - difference)
226 | : (lastDeviationNewText + difference);
227 | }
228 |
229 | private int findLastDeviationNewTextFromOld() {
230 | final int difference = findLengthDifference();
231 | return (isNewTextLonger())
232 | ? (lastDeviationOldText + difference)
233 | : (lastDeviationOldText - difference);
234 | }
235 |
236 |
237 | /**
238 | * Populates the {@link #deviationType} field with one of three constant values,
239 | * representing an ADDITION of text, from old to new, with no text from old replaced. DELETION,
240 | * showing a removal of text from old to new, in which no text was replaced, and a REPLACEMENT,
241 | * in which text has been either added or removed from old to new, and overwritten the old text
242 | * in part or in its entirety. For example:
243 | *
244 | * ADDITION: The difference between "one" and "one two".
245 | *
246 | * DELETION: The difference between "one two" and "one".
247 | *
248 | * REPLACEMENT: The difference between "one" and "two".
249 | *
250 | * @see #getDeviationType()
251 | */
252 | private int findDeviationType() {
253 |
254 | if (firstDeviation == -1) getFirstDeviation();
255 |
256 | int deviationType;
257 |
258 | if (isNewTextLonger()) {
259 |
260 | if (lastDeviationNewText == -1) getLastDeviationNewText();
261 |
262 | deviationType = (SubtractStringUtils.isArrayEqualWithOmission(
263 | mNewText, mOldText, firstDeviation, lastDeviationNewText)
264 | )
265 | ? ADDITION
266 | : REPLACEMENT;
267 | } else if(isTextLengthEqual()) {
268 | deviationType = (isOldTextEqualToNewText())
269 | ? UNCHANGED
270 | : REPLACEMENT;
271 | } else {
272 |
273 | if (lastDeviationOldText == -1) getLastDeviationOldText();
274 |
275 | deviationType = (SubtractStringUtils.isArrayEqualWithOmission(
276 | mNewText, mOldText, firstDeviation, lastDeviationOldText)
277 | )
278 | ? DELETION
279 | : REPLACEMENT;
280 | }
281 |
282 | return deviationType;
283 |
284 | }
285 |
286 | private boolean isOldTextEqualToNewText() {
287 | return Arrays.equals(mOldText, mNewText);
288 | }
289 |
290 | private boolean isNewTextLonger() {
291 | return (mNewText.length > mOldText.length);
292 | }
293 |
294 | private boolean isTextLengthEqual() {
295 | return (mNewText.length == mOldText.length);
296 | }
297 |
298 | private int findLongestLength() {
299 | return Math.max(mNewText.length, mOldText.length);
300 | }
301 |
302 | private int findShortestLength() {
303 | return Math.min(mNewText.length, mOldText.length);
304 | }
305 |
306 | private int findLengthDifference() {
307 | return findLongestLength() - findShortestLength();
308 | }
309 |
310 | /**
311 | *
312 | * @return First deviation
313 | */
314 | int getFirstDeviation() {
315 |
316 | if (firstDeviation == -1) {
317 | firstDeviation = findFirstDeviation();
318 | }
319 |
320 | return firstDeviation;
321 | }
322 |
323 | int getLastDeviationOldText() {
324 |
325 | if (lastDeviationOldText == -1) {
326 | lastDeviationOldText = (lastDeviationNewText == -1 )
327 | ? findLastDeviationOldText()
328 | : findLastDeviationOldTextFromNew();
329 | }
330 |
331 | return lastDeviationOldText;
332 | }
333 |
334 | int getLastDeviationNewText() {
335 |
336 | if (lastDeviationNewText == -1) {
337 | lastDeviationNewText = (lastDeviationOldText == -1)
338 | ? findLastDeviationNewText()
339 | : findLastDeviationNewTextFromOld();
340 | }
341 |
342 | return lastDeviationNewText;
343 | }
344 |
345 | /**
346 | *
347 | * @return Deviation type, in the form of an int value. For a String representation, use
348 | * {@link #valueOfDeviation(int)} ()}
349 | */
350 | int getDeviationType() {
351 | if (deviationType == -1) {
352 | deviationType = findDeviationType();
353 | }
354 | return deviationType;
355 | }
356 |
357 | /**
358 | * Converts {@code int} value returned by {@link #getDeviationType()} to {@link String}
359 | * representation.
360 | * @param deviationType Value return from {@link #getDeviationType()}
361 | * @return String representation of argument if argument is valid. Otherwise, {@code null}
362 | */
363 | @SuppressWarnings("unused")
364 | public static String valueOfDeviation(int deviationType) {
365 |
366 | switch (deviationType) {
367 | case ADDITION:
368 | return "Addition";
369 | case DELETION:
370 | return "Deletion";
371 | case REPLACEMENT:
372 | return "Replacement";
373 | case UNCHANGED:
374 | return "Unchanged";
375 | default:
376 | return null;
377 | }
378 |
379 | }
380 |
381 | /**
382 | *
383 | * @return If text has been added or replaced, returns a substring of the new text that has
384 | * been altered in respect to old text.
385 | */
386 | public String getAlteredText() {
387 |
388 | if (firstDeviation == -1) getFirstDeviation();
389 | if (lastDeviationNewText == -1) getLastDeviationNewText();
390 |
391 | switch (deviationType) {
392 | case ADDITION:
393 | case REPLACEMENT:
394 | return new String(mNewText).substring(firstDeviation, lastDeviationNewText);
395 | }
396 |
397 | return "";
398 | }
399 |
400 | /**
401 | *
402 | * @return If text has been deleted or replaced, returns a substring of the old text that has
403 | * been removed or overwritten.
404 | */
405 | public String getReplacedText() {
406 |
407 | if (firstDeviation == -1) getFirstDeviation();
408 | if (lastDeviationOldText == -1) getLastDeviationOldText();
409 |
410 | switch (deviationType) {
411 | case DELETION:
412 | case REPLACEMENT:
413 | return new String(mOldText).substring(firstDeviation, lastDeviationOldText);
414 | }
415 |
416 | return "";
417 |
418 | }
419 |
420 | /**
421 | *
422 | * @return Encapsulates all important information relating to the differences between old and
423 | * new text.
424 | * @see com.werdpressed.partisan.rundo.SubtractStrings.Item
425 | */
426 | public Item getItem() {
427 |
428 | if (mItem == null) {
429 | mItem = new Item(
430 | getFirstDeviation(),
431 | getLastDeviationOldText(),
432 | getLastDeviationNewText(),
433 | getDeviationType(),
434 | getReplacedText(),
435 | getAlteredText()
436 | );
437 | }
438 |
439 | return mItem;
440 | }
441 |
442 | /**
443 | * Model class which encapsulates all important pieces of information relating to the differences
444 | * between two {@link String}s, calculated by {@link SubtractStrings}
445 | */
446 | static final class Item implements Parcelable {
447 |
448 | private final int firstDeviation, lastDeviationOldText, lastDeviationNewText, deviationType;
449 | private final String replacedText, alteredText;
450 |
451 | Item(
452 | int firstDeviation,
453 | int lastDeviationOldText,
454 | int lastDeviationNewText,
455 | int deviationType,
456 | String replacedText,
457 | String alteredText
458 | ) {
459 | this.firstDeviation = firstDeviation;
460 | this.lastDeviationOldText = lastDeviationOldText;
461 | this.lastDeviationNewText = lastDeviationNewText;
462 | this.deviationType = deviationType;
463 | this.replacedText = replacedText;
464 | this.alteredText = alteredText;
465 | }
466 |
467 | protected Item(Parcel in) {
468 | firstDeviation = in.readInt();
469 | lastDeviationOldText = in.readInt();
470 | lastDeviationNewText = in.readInt();
471 | deviationType = in.readInt();
472 | replacedText = in.readString();
473 | alteredText = in.readString();
474 | }
475 |
476 | /**
477 | *
478 | * @return First point of deviation between old and new text.
479 | */
480 | public int getFirstDeviation() {
481 | return firstDeviation;
482 | }
483 |
484 | /**
485 | *
486 | * @return Last point of deviation between old and new text, in relation to old text.
487 | */
488 | public int getLastDeviationOldText() {
489 | return lastDeviationOldText;
490 | }
491 |
492 | /**
493 | *
494 | * @return Last point of deviation between old and new text, in relation to new text.
495 | */
496 | public int getLastDeviationNewText() {
497 | return lastDeviationNewText;
498 | }
499 |
500 | /**
501 | *
502 | * @return Deviation type in the form of an {@code int}. Value will correlate to
503 | * {@link #ADDITION}. {@link #REPLACEMENT}, {@link #DELETION} or {@link #UNCHANGED}. For
504 | * a {@link String} representation, use {@link #valueOfDeviation(int)}
505 | *
506 | * @see #valueOfDeviation(int)
507 | */
508 | public int getDeviationType() {
509 | return deviationType;
510 | }
511 |
512 | /**
513 | *
514 | * @return Section of old text replaced by new text, if applicable.
515 | */
516 | public String getReplacedText() {
517 | return replacedText;
518 | }
519 |
520 | /**
521 | *
522 | * @return Section of new text replaced by old text, if applicable.
523 | */
524 | public String getAlteredText() {
525 | return alteredText;
526 | }
527 |
528 | public static final Creator- CREATOR = new Creator
- () {
529 | @Override
530 | public Item createFromParcel(Parcel in) {
531 | return new Item(in);
532 | }
533 |
534 | @Override
535 | public Item[] newArray(int size) {
536 | return new Item[size];
537 | }
538 | };
539 |
540 | @Override
541 | public int describeContents() {
542 | return 0;
543 | }
544 |
545 | @Override
546 | public void writeToParcel(Parcel dest, int flags) {
547 | dest.writeInt(firstDeviation);
548 | dest.writeInt(lastDeviationOldText);
549 | dest.writeInt(lastDeviationNewText);
550 | dest.writeInt(deviationType);
551 | dest.writeString(replacedText);
552 | dest.writeString(alteredText);
553 | }
554 | }
555 | }
556 |
--------------------------------------------------------------------------------