001package net.filebot.format;
002
003import static net.filebot.util.RegularExpressions.*;
004
005import java.util.ArrayList;
006import java.util.Collection;
007import java.util.Iterator;
008import java.util.List;
009import java.util.ListIterator;
010import java.util.Map;
011import java.util.Set;
012
013import groovy.lang.GroovyObjectSupport;
014
015public class AssociativeEnumObject extends GroovyObjectSupport implements List<Object> {
016
017        private final Map<?, ?> values;
018
019        public AssociativeEnumObject(Map<?, ?> values) {
020                this.values = values;
021        }
022
023        protected String definingKey(Object key) {
024                // letters and digits are defining, everything else will be ignored
025                return NON_WORD.matcher(key.toString()).replaceAll("").toLowerCase();
026        }
027
028        @Override
029        public Object getProperty(String name) {
030                return getValue(definingKey(name));
031        }
032
033        private Object getValue(String key) {
034                return values.keySet().stream().filter(k -> {
035                        return definingKey(k).equals(key);
036                }).findFirst().map(values::get).orElse(null);
037        }
038
039        @Override
040        public void setProperty(String name, Object value) {
041                throw new UnsupportedOperationException(name);
042        }
043
044        @Override
045        public String toString() {
046                return values.toString();
047        }
048
049        public Set<?> keySet() {
050                return values.keySet();
051        }
052
053        public List<Object> toList() {
054                return new ArrayList<Object>(values.values());
055        }
056
057        @Override
058        public Iterator<Object> iterator() {
059                return toList().iterator();
060        }
061
062        @Override
063        public Object get(int index) {
064                return toList().get(index);
065        }
066
067        @Override
068        public List<Object> subList(int fromIndex, int toIndex) {
069                return toList().subList(fromIndex, toIndex);
070        }
071
072        @Override
073        public int size() {
074                return values.size();
075        }
076
077        @Override
078        public boolean isEmpty() {
079                return values.isEmpty();
080        }
081
082        @Override
083        public boolean contains(Object o) {
084                return values.values().contains(o);
085        }
086
087        @Override
088        public Object[] toArray() {
089                return values.values().toArray();
090        }
091
092        @Override
093        public <T> T[] toArray(T[] a) {
094                return values.values().toArray(a);
095        }
096
097        @Override
098        public boolean add(Object e) {
099                throw new UnsupportedOperationException();
100        }
101
102        @Override
103        public boolean remove(Object o) {
104                throw new UnsupportedOperationException();
105        }
106
107        @Override
108        public boolean containsAll(Collection<?> c) {
109                return values.values().containsAll(c);
110        }
111
112        @Override
113        public boolean addAll(Collection<? extends Object> c) {
114                throw new UnsupportedOperationException();
115        }
116
117        @Override
118        public boolean addAll(int index, Collection<? extends Object> c) {
119                throw new UnsupportedOperationException();
120        }
121
122        @Override
123        public boolean removeAll(Collection<?> c) {
124                throw new UnsupportedOperationException();
125        }
126
127        @Override
128        public boolean retainAll(Collection<?> c) {
129                throw new UnsupportedOperationException();
130        }
131
132        @Override
133        public void clear() {
134                throw new UnsupportedOperationException();
135        }
136
137        @Override
138        public Object set(int index, Object element) {
139                throw new UnsupportedOperationException();
140        }
141
142        @Override
143        public void add(int index, Object element) {
144                throw new UnsupportedOperationException();
145        }
146
147        @Override
148        public Object remove(int index) {
149                throw new UnsupportedOperationException();
150        }
151
152        @Override
153        public int indexOf(Object o) {
154                return toList().indexOf(o);
155        }
156
157        @Override
158        public int lastIndexOf(Object o) {
159                return toList().lastIndexOf(o);
160        }
161
162        @Override
163        public ListIterator<Object> listIterator() {
164                return toList().listIterator();
165        }
166
167        @Override
168        public ListIterator<Object> listIterator(int index) {
169                return toList().listIterator(index);
170        }
171
172}