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