From a4b6b184b4a7a18d8bf0128b678d4582fbf493f4 Mon Sep 17 00:00:00 2001 From: Tom Hicks Date: Sun, 20 Jun 2021 15:33:55 -0700 Subject: [PATCH] Adds getters and setters for string array properties of EditMonsterViewModel. --- .../ui/editmonster/EditMonsterViewModel.java | 286 +++++++++++++----- .../ui/editmonster/EditSenseFragment.java | 2 +- 2 files changed, 211 insertions(+), 77 deletions(-) diff --git a/app/src/main/java/com/majinnaibu/monstercards/ui/editmonster/EditMonsterViewModel.java b/app/src/main/java/com/majinnaibu/monstercards/ui/editmonster/EditMonsterViewModel.java index 9d53a91..d3789b7 100644 --- a/app/src/main/java/com/majinnaibu/monstercards/ui/editmonster/EditMonsterViewModel.java +++ b/app/src/main/java/com/majinnaibu/monstercards/ui/editmonster/EditMonsterViewModel.java @@ -19,10 +19,10 @@ import com.majinnaibu.monstercards.utils.ChangeTrackedLiveData; import java.util.ArrayList; import java.util.Collections; +import java.util.Comparator; import java.util.HashSet; import java.util.List; import java.util.Objects; -import java.util.Set; import java.util.UUID; @SuppressWarnings({"ConstantConditions", "unused"}) @@ -78,17 +78,17 @@ public class EditMonsterViewModel extends ViewModel { private final ChangeTrackedLiveData mUnderstandsButDescription; private final ChangeTrackedLiveData> mSkills; private final ChangeTrackedLiveData> mSenses; - private final ChangeTrackedLiveData> mDamageImmunities; - private final ChangeTrackedLiveData> mDamageResistances; - private final ChangeTrackedLiveData> mDamageVulnerabilities; - private final ChangeTrackedLiveData> mConditionImmunities; - private final ChangeTrackedLiveData> mLanguages; - private final ChangeTrackedLiveData> mAbilities; - private final ChangeTrackedLiveData> mActions; - private final ChangeTrackedLiveData> mReactions; - private final ChangeTrackedLiveData> mLairActions; - private final ChangeTrackedLiveData> mLegendaryActions; - private final ChangeTrackedLiveData> mRegionalActions; + private final ChangeTrackedLiveData> mDamageImmunities; + private final ChangeTrackedLiveData> mDamageResistances; + private final ChangeTrackedLiveData> mDamageVulnerabilities; + private final ChangeTrackedLiveData> mConditionImmunities; + private final ChangeTrackedLiveData> mLanguages; + private final ChangeTrackedLiveData> mAbilities; + private final ChangeTrackedLiveData> mActions; + private final ChangeTrackedLiveData> mReactions; + private final ChangeTrackedLiveData> mLairActions; + private final ChangeTrackedLiveData> mLegendaryActions; + private final ChangeTrackedLiveData> mRegionalActions; public EditMonsterViewModel() { mErrorMessage = new MutableLiveData<>(""); @@ -144,17 +144,17 @@ public class EditMonsterViewModel extends ViewModel { mUnderstandsButDescription = new ChangeTrackedLiveData<>("", onDirtied); mSkills = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); mSenses = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); - mDamageImmunities = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mDamageResistances = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mDamageVulnerabilities = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mConditionImmunities = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mLanguages = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mAbilities = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mActions = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mReactions = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mLairActions = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mLegendaryActions = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); - mRegionalActions = new ChangeTrackedLiveData<>(new HashSet<>(), onDirtied); + mDamageImmunities = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mDamageResistances = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mDamageVulnerabilities = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mConditionImmunities = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mLanguages = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mAbilities = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mActions = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mReactions = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mLairActions = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mLegendaryActions = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); + mRegionalActions = new ChangeTrackedLiveData<>(new ArrayList<>(), onDirtied); } public void copyFromMonster(Monster monster) { @@ -210,17 +210,27 @@ public class EditMonsterViewModel extends ViewModel { ArrayList senses = new ArrayList<>(monster.senses); Collections.sort(senses, String::compareToIgnoreCase); mSenses.resetValue(senses); - mDamageImmunities.resetValue(monster.damageImmunities); - mDamageResistances.resetValue(monster.damageResistances); - mDamageVulnerabilities.resetValue(monster.damageVulnerabilities); - mConditionImmunities.resetValue(monster.conditionImmunities); - mLanguages.resetValue(monster.languages); - mAbilities.resetValue(monster.abilities); - mActions.resetValue(monster.actions); - mReactions.resetValue(monster.reactions); - mLairActions.resetValue(monster.lairActions); - mLegendaryActions.resetValue(monster.legendaryActions); - mRegionalActions.resetValue(monster.regionalActions); + ArrayList damageImmunities = new ArrayList<>(monster.damageImmunities); + Collections.sort(damageImmunities, String::compareToIgnoreCase); + mDamageImmunities.resetValue(damageImmunities); + ArrayList damageResistances = new ArrayList<>(monster.damageResistances); + Collections.sort(damageResistances, String::compareToIgnoreCase); + mDamageResistances.resetValue(damageResistances); + ArrayList damageVulnerabilities = new ArrayList<>(monster.damageVulnerabilities); + Collections.sort(damageVulnerabilities, String::compareToIgnoreCase); + mDamageVulnerabilities.resetValue(damageVulnerabilities); + ArrayList conditionImmunities = new ArrayList<>(monster.conditionImmunities); + Collections.sort(conditionImmunities, String::compareToIgnoreCase); + mConditionImmunities.resetValue(conditionImmunities); + ArrayList languages = new ArrayList<>(monster.languages); + Collections.sort(languages, (lang1, lang2) -> lang1.getName().compareToIgnoreCase(lang2.getName())); + mLanguages.resetValue(languages); + mAbilities.resetValue(new ArrayList<>(monster.abilities)); + mActions.resetValue(new ArrayList<>(monster.actions)); + mReactions.resetValue(new ArrayList<>(monster.reactions)); + mLairActions.resetValue(new ArrayList<>(monster.lairActions)); + mLegendaryActions.resetValue(new ArrayList<>(monster.legendaryActions)); + mRegionalActions.resetValue(new ArrayList<>(monster.regionalActions)); mHasChanges.setValue(false); } @@ -807,44 +817,97 @@ public class EditMonsterViewModel extends ViewModel { } public String addNewSense() { - String newSense = ""; - ArrayList newSenses = new ArrayList<>(mSenses.getValue()); - newSenses.add(newSense); - Collections.sort(newSenses, String::compareToIgnoreCase); - mSenses.setValue(newSenses); - return newSense; + return Helpers.addItemToList(mSenses, "", String::compareToIgnoreCase); } public void removeSense(int position) { - List senses = mSenses.getValue(); - ArrayList newSenses = new ArrayList<>(senses); - newSenses.remove(position); - mSenses.setValue(newSenses); + Helpers.removeFromList(mSenses, position); } - public void replaceSense(String newSense, String oldSense) { - List oldSenses = mSenses.getValue(); - if (oldSenses == null) { - oldSenses = new ArrayList<>(); - } - boolean hasReplaced = false; - ArrayList newSenses = new ArrayList<>(oldSenses.size()); - for (String sense : oldSenses) { - if (Objects.equals(sense, oldSense)) { - newSenses.add(newSense); - hasReplaced = true; - } else { - newSenses.add(sense); - } - } - if (!hasReplaced) { - newSenses.add(newSense); - } - Collections.sort(newSenses, String::compareToIgnoreCase); - mSenses.setValue(newSenses); + public void replaceSense(String oldSense, String newSense) { + Helpers.replaceItemInList(mSenses, oldSense, newSense, String::compareToIgnoreCase); + } + + public LiveData> getDamageImmunities() { + return mDamageImmunities; + } + + public List getDamageImmunitiesArray() { + return mDamageImmunities.getValue(); + } + + public String addNewDamageImmunity() { + return Helpers.addStringToList("", mDamageImmunities); + } + + public void removeDamageImmunity(int position) { + Helpers.removeFromList(mDamageImmunities, position); + } + + public void replaceDamageImmunity(String oldDamageType, String newDamageType) { + Helpers.replaceItemInList(mDamageImmunities, oldDamageType, newDamageType, String::compareToIgnoreCase); + } + + public LiveData> getDamageResistances() { + return mDamageResistances; + } + + public List getDamageResistancesArray() { + return mDamageResistances.getValue(); + } + + public String addNewDamageResistance() { + return Helpers.addStringToList("", mDamageResistances); + } + + public void removeDamageResistance(int position) { + Helpers.removeFromList(mDamageResistances, position); + } + + public void replaceDamageResistance(String oldDamageType, String newDamageType) { + Helpers.replaceItemInList(mDamageResistances, oldDamageType, newDamageType, String::compareToIgnoreCase); + } + + public LiveData> getDamageVulnerabilities() { + return mDamageVulnerabilities; + } + + public List getDamageVulnerabilitiesArray() { + return mDamageVulnerabilities.getValue(); + } + + public String addNewDamageVulnerability() { + return Helpers.addStringToList("", mDamageVulnerabilities); + } + + public void removeDamageVulnerability(int position) { + Helpers.removeFromList(mDamageVulnerabilities, position); + } + + public void replaceDamageVulnerability(String oldDamageType, String newDamageType) { + Helpers.replaceItemInList(mDamageVulnerabilities, oldDamageType, newDamageType, String::compareToIgnoreCase); + } + + public LiveData> getConditionImmunities() { + return mConditionImmunities; + } + + public List getConditionImmunitiesArray() { + return mConditionImmunities.getValue(); + } + + public String addNewConditionImmunity() { + return Helpers.addStringToList("", mConditionImmunities); + } + + public void removeConditionImmunity(int position) { + Helpers.removeFromList(mConditionImmunities, position); + } + + public void replaceConditionImmunity(String oldDamageType, String newDamageType) { + Helpers.replaceItemInList(mConditionImmunities, oldDamageType, newDamageType, String::compareToIgnoreCase); } - // TODO: add getters and setters for lists of strings (Senses, Damage Immunities, Damage Resistances, Damage Vulnerabilities, and Condition Immunities) // TODO: add getters and setters for Languages // TODO: add getters and setters for traits (Abilities, Actions, Reactions, Lair Actions, Legendary Actions, and Regional Actions) @@ -897,19 +960,90 @@ public class EditMonsterViewModel extends ViewModel { monster.understandsButDescription = mUnderstandsButDescription.getValue(); monster.skills = new HashSet<>(mSkills.getValue()); monster.senses = new HashSet<>(mSenses.getValue()); - monster.damageImmunities = mDamageImmunities.getValue(); - monster.damageResistances = mDamageResistances.getValue(); - monster.damageVulnerabilities = mDamageVulnerabilities.getValue(); - monster.conditionImmunities = mConditionImmunities.getValue(); - monster.languages = mLanguages.getValue(); - monster.abilities = mAbilities.getValue(); - monster.actions = mActions.getValue(); - monster.reactions = mReactions.getValue(); - monster.lairActions = mLairActions.getValue(); - monster.legendaryActions = mLegendaryActions.getValue(); - monster.regionalActions = mRegionalActions.getValue(); + monster.damageImmunities = new HashSet<>(mDamageImmunities.getValue()); + monster.damageResistances = new HashSet<>(mDamageResistances.getValue()); + monster.damageVulnerabilities = new HashSet<>(mDamageVulnerabilities.getValue()); + monster.conditionImmunities = new HashSet<>(mConditionImmunities.getValue()); + monster.languages = new HashSet<>(mLanguages.getValue()); + monster.abilities = new HashSet<>(mAbilities.getValue()); + monster.actions = new HashSet<>(mActions.getValue()); + monster.reactions = new HashSet<>(mReactions.getValue()); + monster.lairActions = new HashSet<>(mLairActions.getValue()); + monster.legendaryActions = new HashSet<>(mLegendaryActions.getValue()); + monster.regionalActions = new HashSet<>(mRegionalActions.getValue()); return monster; } + private static class Helpers { + static String addStringToList(String newString, MutableLiveData> strings) { + return addItemToList(strings, newString, String::compareToIgnoreCase); + } + + static T addItemToList(MutableLiveData> listData, T newItem, Comparator comparator) { + ArrayList newList = new ArrayList<>(listData.getValue()); + newList.add(newItem); + if (comparator != null) { + Collections.sort(newList, comparator); + } + listData.setValue(newList); + return newItem; + } + + static void removeFromList(MutableLiveData> listData, int position) { + List oldList = listData.getValue(); + ArrayList newList = new ArrayList<>(oldList); + newList.remove(position); + listData.setValue(newList); + } + + static void replaceItemInList(MutableLiveData> listData, int position, T newItem, Comparator comparator) { + List oldList = listData.getValue(); + if (oldList == null) { + oldList = new ArrayList<>(); + } + int size = oldList.size(); + boolean hasReplaced = false; + ArrayList newList = new ArrayList<>(size); + for (int index = 0; index < size; index++) { + if (index == position) { + newList.add(newItem); + hasReplaced = true; + } else { + newList.add(oldList.get(index)); + } + } + if (!hasReplaced) { + newList.add(newItem); + } + if (comparator != null) { + Collections.sort(newList, comparator); + } + listData.setValue(newList); + } + + static void replaceItemInList(MutableLiveData> listData, T oldItem, T newItem, Comparator comparator) { + List oldList = listData.getValue(); + if (oldList == null) { + oldList = new ArrayList<>(); + } + boolean hasReplaced = false; + ArrayList newList = new ArrayList<>(oldList.size()); + for (T item : oldList) { + if (Objects.equals(item, oldItem)) { + newList.add(newItem); + hasReplaced = true; + } else { + newList.add(item); + } + } + if (!hasReplaced) { + newList.add(newItem); + } + if (comparator != null) { + Collections.sort(newList, comparator); + } + listData.setValue(newList); + } + } } diff --git a/app/src/main/java/com/majinnaibu/monstercards/ui/editmonster/EditSenseFragment.java b/app/src/main/java/com/majinnaibu/monstercards/ui/editmonster/EditSenseFragment.java index 4888c54..423353a 100644 --- a/app/src/main/java/com/majinnaibu/monstercards/ui/editmonster/EditSenseFragment.java +++ b/app/src/main/java/com/majinnaibu/monstercards/ui/editmonster/EditSenseFragment.java @@ -57,7 +57,7 @@ public class EditSenseFragment extends MCFragment { @Override public void handleOnBackPressed() { if (mViewModel.hasChanges()) { - mEditMonsterViewModel.replaceSense(mViewModel.getDescription().getValue(), mOldSense); + mEditMonsterViewModel.replaceSense(mOldSense, mViewModel.getDescription().getValue()); } Navigation.findNavController(requireView()).navigateUp(); }