daoas/adressevedligehold/AddressManager.java

package dk.daoas.adressevedligehold;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.commons.lang3.StringUtils;

import dk.daoas.adressevedligehold.AddressSourceEntry.EntryType;
import dk.daoas.adressevedligehold.beans.Address;
import dk.daoas.adressevedligehold.beans.Address.AddressState;
import dk.daoas.adressevedligehold.db.DatabaseLayerImplementation;
import dk.daoas.adressevedligehold.util.DeduplicateHelper;
import dk.daoas.adressevedligehold.util.TimingHelper;

/*
 * TODO: implementer visitRange()
 * TODO: håndtering af entry dupletter ! (+ rapportering af dem)
 */

public class AddressManager {
        
        
        List<Address> addressList;
        
        Map<Integer, TreeMap<Short, ArrayList<Address>> > searchStructure;
        
        ArrayList<AddressSourceEntry> afvisteEntries = new ArrayList<AddressSourceEntry>(); 
        
        public AddressManager() throws SQLException {
                DatabaseLayerImplementation db = new DatabaseLayerImplementation();
                
                searchStructure = new TreeMap<Integer, TreeMap<Short, ArrayList<Address>> >();
                
                addressList = db.getAllAdresses();

                DeduplicateHelper<Integer> intHelper = new DeduplicateHelper<Integer>();
                DeduplicateHelper<Short> shortHelper = new DeduplicateHelper<Short>();

                List<ArrayList<Address>> arraylistCache = new ArrayList<ArrayList<Address>>(); 
                
                TimingHelper timer = new TimingHelper();
                
                for (Address a : addressList) {
                        Integer gadeid = intHelper.getInstance( a.gadeid );
                        Short husnr = shortHelper.getInstance( a.husnr );
                        TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( gadeid );
                        
                        if (gade == null) {
                                gade = new TreeMap<Short,ArrayList<Address>>();
                                searchStructure.put(gadeid, gade);
                        }
                        
                        ArrayList<Address> litraList = gade.get(husnr);
                        if (litraList == null) {
                                litraList = new ArrayList<Address>();
                                gade.put(husnr, litraList);
                                arraylistCache.add(litraList);
                        }
                        
                        litraList.add(a);
                }
                
                for (ArrayList<Address> list : arraylistCache) {
                        list.trimToSize();
                }
                
                System.out.println("AddressManager ready, elapsed " + timer.getElapsed() + "ms");
                
                
        }
        
        public void closeUnvisitedAddresses(String distributor, EntryUgedage ugedage) {
                for (Address addr : addressList) {
                        if (addr.distributor == null)
                                continue;
                        
                        if (addr.distributor.equals(distributor) == false)//irrelevant for denne indlæsning
                                continue;
                        
                        int closedCount = 0;
                        
                        if (addr.visitedMan == false && ugedage.mandag) {
                                if (addr.ruteMandag != null)  {
                                        addr.ruteMandag = null;
                                        addr.korelisteMandag = null;
                                        addr.stateMan = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }
                        if (addr.visitedTir == false && ugedage.tirsdag) {
                                if (addr.ruteTirsdag != null)  {
                                        addr.ruteTirsdag = null;
                                        addr.korelisteTirsdag = null;
                                        addr.stateTir = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedOns == false && ugedage.onsdag) {
                                if (addr.ruteOnsdag != null)  {
                                        addr.ruteOnsdag = null;
                                        addr.korelisteOnsdag = null;
                                        addr.stateOns = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedTor == false && ugedage.torsdag) {
                                if (addr.ruteTorsdag != null)  {
                                        addr.ruteTorsdag = null;
                                        addr.korelisteTorsdag = null;
                                        addr.stateTor = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedFre == false && ugedage.fredag) {
                                if (addr.ruteFredag != null)  {
                                        addr.ruteFredag = null;
                                        addr.korelisteFredag = null;
                                        addr.stateFre = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedLor == false && ugedage.lordag) {
                                if (addr.ruteLordag != null)  {
                                        addr.ruteLordag = null;
                                        addr.korelisteLordag = null;
                                        addr.stateLor = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }

                        if (addr.visitedSon == false && ugedage.sondag) {
                                if (addr.ruteSondag != null)  {
                                        addr.ruteSondag = null;
                                        addr.korelisteSondag = null;
                                        addr.stateSon = AddressState.CLOSED;
                                        closedCount++;
                                }
                        }
                        
                        if (addr.state == AddressState.NOT_CHANGED && closedCount>0) {
                                addr.state = AddressState.CLOSED;
                        }
                
                }
        }
        public void dumpChanged() {
                int count = 0;
                for (Address addr : addressList) {
                        if (addr.state == AddressState.NOT_CHANGED) {
                                continue;
                        }
                        if (addr.stateMan == AddressState.NOT_CHANGED || addr.stateMan == AddressState.CREATED) {
                                continue;
                        }
                        
                        if (addr.stateMan != AddressState.MODIFIED ) {
                                continue;
                        }
                        
                        System.out.println(addr.state + ": " + addr.toStringExtended() );
                        System.out.println(addr.getRuteString() );
                        
                        if (count++ > 15)
                                return;
                }
        }
        
        public void writeBackChanges() {
                System.out.println("Writing back changes");
                TimingHelper timer = new TimingHelper();
                
                List<Address> updates = new ArrayList<Address>(1024*1024);
                List<Address> inserts = new ArrayList<Address>(16*1024);
                
                for (Address addr : addressList) {
                        if (addr.state == AddressState.CREATED) {
                                inserts.add(addr);
                        }
                        if (addr.state == AddressState.MODIFIED || addr.state == AddressState.OPENED || addr.state == AddressState.CLOSED) {
                                updates.add(addr);
                        }
                }
                
                DatabaseLayerImplementation db = new DatabaseLayerImplementation();
                db.updateAddresses(updates);
                
                System.out.println("Writeback done: elapsed " + timer.getElapsed() + "ms.");
        }
        
        
        public void visit(AddressSourceEntry entry) {
                if (entry.type == EntryType.TypeSingleAddress) {
                        visitSingle(entry);
                } else {
                        visitRange(entry);
                }
        }
        
        private void visitSingle(AddressSourceEntry entry) {
                TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( entry.gadeid );
                if (gade == null) {
                        createFromEntry(entry); // if we get here there was no match - so we need to create it
                        return;
                }
                
                ArrayList<Address> litraList = gade.get(entry.husnr);
                if (litraList == null) {
                        createFromEntry(entry); // if we get here there was no match - so we need to create it
                        return;
                }
                
                for (Address addr : litraList) {
                        if (addr.husnrbogstav.equals(entry.litra) ) {
                                updateAddress(addr, entry);
                                return; //Done for now - no need to look at the rest of the list
                        }
                }
                
                createFromEntry(entry); // if we get here there was no match - so we need to create it
        }
        
        private void visitRange(AddressSourceEntry entry) {
                
                throw new UnsupportedOperationException("Not implemented yet");
        }
        
        
        
        private void updateAddress(Address addr, AddressSourceEntry entry) {
                if ( addr.distributor != null && addr.distributor.equals(entry.distributor) == false) {
                        afvisteEntries.add(entry);
                        System.out.println("Afviser " + entry);
                        return;
                }
                
                addr.visited = true;
                if (addr.state == AddressState.NOT_CHANGED) {
                        if (addr.distributor == null) {
                                addr.state = AddressState.OPENED;
                                addr.distributor = entry.distributor;
                        } else {
                                addr.state = AddressState.MODIFIED;
                        }
                }
                
                if (entry.ugedage.mandag) {
                        addr.visitedMan = true;
                        if (addr.ruteMandag == null) {
                                addr.stateMan = AddressState.OPENED;
                                addr.ruteMandag = entry.rute;
                                addr.korelisteMandag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteMandag, entry.rute) == false || StringUtils.equals(addr.korelisteMandag, entry.koreliste) == false) {
                                        addr.stateMan = AddressState.MODIFIED;
                                        addr.ruteMandag = entry.rute;
                                        addr.korelisteMandag = entry.koreliste;                                 
                                }
                        }
                }
                
                
                if (entry.ugedage.tirsdag) {
                        addr.visitedTir = true;
                        if (addr.ruteTirsdag == null) {
                                addr.stateTir = AddressState.OPENED;
                                addr.ruteTirsdag = entry.rute;
                                addr.korelisteTirsdag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteTirsdag, entry.rute) == false || StringUtils.equals(addr.korelisteTirsdag, entry.koreliste) == false) {
                                        addr.stateTir = AddressState.MODIFIED;
                                        addr.ruteTirsdag = entry.rute;
                                        addr.korelisteTirsdag = entry.koreliste;                                        
                                }
                        }
                }

                if (entry.ugedage.onsdag) {
                        addr.visitedOns = true;
                        if (addr.ruteOnsdag == null) {
                                addr.stateOns = AddressState.OPENED;
                                addr.ruteOnsdag = entry.rute;
                                addr.korelisteOnsdag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteOnsdag, entry.rute) == false || StringUtils.equals(addr.korelisteOnsdag, entry.koreliste) == false) {
                                        addr.stateOns = AddressState.MODIFIED;
                                        addr.ruteOnsdag = entry.rute;
                                        addr.korelisteOnsdag = entry.koreliste;                                 
                                }
                        }
                }

                
                if (entry.ugedage.torsdag) {
                        addr.visitedTor = true;
                        if (addr.ruteTorsdag == null) {
                                addr.stateTor = AddressState.OPENED;
                                addr.ruteTorsdag = entry.rute;
                                addr.korelisteTorsdag = entry.koreliste;
                        } else {
                                
                                
                                if (StringUtils.equals(addr.ruteTorsdag, entry.rute) == false || StringUtils.equals(addr.korelisteTorsdag, entry.koreliste) == false) {
                                        addr.stateTor = AddressState.MODIFIED;
                                        addr.ruteTorsdag = entry.rute;
                                        addr.korelisteTorsdag = entry.koreliste;                                        
                                }
                        }
                }

                
                if (entry.ugedage.fredag) {
                        addr.visitedFre = true;
                        if (addr.ruteFredag == null) {
                                addr.stateFre = AddressState.OPENED;
                                addr.ruteFredag = entry.rute;
                                addr.korelisteFredag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteFredag, entry.rute) == false || StringUtils.equals(addr.korelisteFredag, entry.koreliste) == false) {
                                        addr.stateFre = AddressState.MODIFIED;
                                        addr.ruteFredag = entry.rute;
                                        addr.korelisteFredag = entry.koreliste;                                 
                                }
                        }
                }

                
                if (entry.ugedage.lordag) {
                        addr.visitedLor = true;
                        if (addr.ruteLordag == null) {
                                addr.stateLor = AddressState.OPENED;
                                addr.ruteLordag = entry.rute;
                                addr.korelisteLordag = entry.koreliste;
                        } else {
                                
                                
                                if (StringUtils.equals(addr.ruteLordag, entry.rute) == false || StringUtils.equals(addr.korelisteLordag, entry.koreliste) == false) {
                                        addr.stateLor = AddressState.MODIFIED;
                                        addr.ruteLordag = entry.rute;
                                        addr.korelisteLordag = entry.koreliste;                                 
                                }
                        }
                }

                
                if (entry.ugedage.sondag) {
                        addr.visitedSon = true;
                        if (addr.ruteSondag == null) {
                                addr.stateSon = AddressState.OPENED;
                                addr.ruteSondag = entry.rute;
                                addr.korelisteSondag = entry.koreliste;
                        } else {
                                
                                if (StringUtils.equals(addr.ruteSondag, entry.rute) == false || StringUtils.equals(addr.korelisteSondag, entry.koreliste) == false) {
                                        addr.stateSon = AddressState.MODIFIED;
                                        addr.ruteSondag = entry.rute;
                                        addr.korelisteSondag = entry.koreliste;                                 
                                }
                        }
                }

                
                
        }
        
        
        
        private void createFromEntry(AddressSourceEntry entry) {
                System.out.println("Opretter adresse ud fra " + entry);
                
                Address a = new Address();
                a.state = AddressState.CREATED;
                
                a.distributor = entry.distributor;
                a.gadeid = entry.gadeid;
                a.kommunekode = entry.kommunekode;
                a.vejkode = entry.vejkode;
                a.vejnavn = entry.vejnavn;
                a.husnr = entry.husnr;
                a.husnrbogstav = entry.litra;
                a.postnr = entry.postnr;
                a.visited = true;
                
                if (entry.ugedage.mandag) {
                        a.ruteMandag = entry.rute;
                        a.korelisteMandag = entry.koreliste;
                }
                if (entry.ugedage.tirsdag) {
                        a.ruteTirsdag = entry.rute;
                        a.korelisteTirsdag = entry.koreliste;
                }
                if (entry.ugedage.onsdag) {
                        a.ruteOnsdag = entry.rute;
                        a.korelisteOnsdag = entry.koreliste;
                }               
                if (entry.ugedage.torsdag) {
                        a.ruteTorsdag = entry.rute;
                        a.korelisteTorsdag = entry.koreliste;
                }               
                if (entry.ugedage.fredag) {
                        a.ruteFredag = entry.rute;
                        a.korelisteFredag = entry.koreliste;
                }               
                if (entry.ugedage.lordag) {
                        a.ruteLordag = entry.rute;
                        a.korelisteLordag = entry.koreliste;
                }               
                if (entry.ugedage.sondag) {
                        a.ruteSondag = entry.rute;
                        a.korelisteLordag = entry.koreliste;
                }               
                
                // Nu er det nye adresse object oprettet - nu skal det gemmes i søge strukturen og totallisten
                

                TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( a.gadeid );
                
                if (gade == null) {
                        gade = new TreeMap<Short,ArrayList<Address>>();
                        searchStructure.put(a.gadeid, gade);
                }
                
                ArrayList<Address> litraList = gade.get(a.husnr);
                if (litraList == null) {
                        litraList = new ArrayList<Address>();
                        gade.put(a.husnr, litraList);
                }
                
                litraList.add(a);
                addressList.add(a);
                                
        }
        
        public List<Address> getAddressList() {
                return Collections.unmodifiableList(addressList);
        }
        
        public int getAfvistAntal() {
                return afvisteEntries.size();
        }
        
}
1	package dk.daoas.adressevedligehold;
2
3	import java.sql.SQLException;
4	import java.util.ArrayList;
5	import java.util.Collections;
6	import java.util.List;
7	import java.util.Map;
8	import java.util.TreeMap;
9
10	import org.apache.commons.lang3.StringUtils;
11
12	import dk.daoas.adressevedligehold.AddressSourceEntry.EntryType;
13	import dk.daoas.adressevedligehold.beans.Address;
14	import dk.daoas.adressevedligehold.beans.Address.AddressState;
15	import dk.daoas.adressevedligehold.db.DatabaseLayerImplementation;
16	import dk.daoas.adressevedligehold.util.DeduplicateHelper;
17	import dk.daoas.adressevedligehold.util.TimingHelper;
18
19	/*
20	* TODO: implementer visitRange()
21	* TODO: håndtering af entry dupletter ! (+ rapportering af dem)
22	*/
23
24	public class AddressManager {
25
26
27	List<Address> addressList;
28
29	Map<Integer, TreeMap<Short, ArrayList<Address>> > searchStructure;
30
31	ArrayList<AddressSourceEntry> afvisteEntries = new ArrayList<AddressSourceEntry>();
32
33	public AddressManager() throws SQLException {
34	DatabaseLayerImplementation db = new DatabaseLayerImplementation();
35
36	searchStructure = new TreeMap<Integer, TreeMap<Short, ArrayList<Address>> >();
37
38	addressList = db.getAllAdresses();
39
40	DeduplicateHelper<Integer> intHelper = new DeduplicateHelper<Integer>();
41	DeduplicateHelper<Short> shortHelper = new DeduplicateHelper<Short>();
42
43	List<ArrayList<Address>> arraylistCache = new ArrayList<ArrayList<Address>>();
44
45	TimingHelper timer = new TimingHelper();
46
47	for (Address a : addressList) {
48	Integer gadeid = intHelper.getInstance( a.gadeid );
49	Short husnr = shortHelper.getInstance( a.husnr );
50	TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( gadeid );
51
52	if (gade == null) {
53	gade = new TreeMap<Short,ArrayList<Address>>();
54	searchStructure.put(gadeid, gade);
55	}
56
57	ArrayList<Address> litraList = gade.get(husnr);
58	if (litraList == null) {
59	litraList = new ArrayList<Address>();
60	gade.put(husnr, litraList);
61	arraylistCache.add(litraList);
62	}
63
64	litraList.add(a);
65	}
66
67	for (ArrayList<Address> list : arraylistCache) {
68	list.trimToSize();
69	}
70
71	System.out.println("AddressManager ready, elapsed " + timer.getElapsed() + "ms");
72
73
74	}
75
76	public void closeUnvisitedAddresses(String distributor, EntryUgedage ugedage) {
77	for (Address addr : addressList) {
78	if (addr.distributor == null)
79	continue;
80
81	if (addr.distributor.equals(distributor) == false)//irrelevant for denne indlæsning
82	continue;
83
84	int closedCount = 0;
85
86	if (addr.visitedMan == false && ugedage.mandag) {
87	if (addr.ruteMandag != null) {
88	addr.ruteMandag = null;
89	addr.korelisteMandag = null;
90	addr.stateMan = AddressState.CLOSED;
91	closedCount++;
92	}
93	}
94	if (addr.visitedTir == false && ugedage.tirsdag) {
95	if (addr.ruteTirsdag != null) {
96	addr.ruteTirsdag = null;
97	addr.korelisteTirsdag = null;
98	addr.stateTir = AddressState.CLOSED;
99	closedCount++;
100	}
101	}
102
103	if (addr.visitedOns == false && ugedage.onsdag) {
104	if (addr.ruteOnsdag != null) {
105	addr.ruteOnsdag = null;
106	addr.korelisteOnsdag = null;
107	addr.stateOns = AddressState.CLOSED;
108	closedCount++;
109	}
110	}
111
112	if (addr.visitedTor == false && ugedage.torsdag) {
113	if (addr.ruteTorsdag != null) {
114	addr.ruteTorsdag = null;
115	addr.korelisteTorsdag = null;
116	addr.stateTor = AddressState.CLOSED;
117	closedCount++;
118	}
119	}
120
121	if (addr.visitedFre == false && ugedage.fredag) {
122	if (addr.ruteFredag != null) {
123	addr.ruteFredag = null;
124	addr.korelisteFredag = null;
125	addr.stateFre = AddressState.CLOSED;
126	closedCount++;
127	}
128	}
129
130	if (addr.visitedLor == false && ugedage.lordag) {
131	if (addr.ruteLordag != null) {
132	addr.ruteLordag = null;
133	addr.korelisteLordag = null;
134	addr.stateLor = AddressState.CLOSED;
135	closedCount++;
136	}
137	}
138
139	if (addr.visitedSon == false && ugedage.sondag) {
140	if (addr.ruteSondag != null) {
141	addr.ruteSondag = null;
142	addr.korelisteSondag = null;
143	addr.stateSon = AddressState.CLOSED;
144	closedCount++;
145	}
146	}
147
148	if (addr.state == AddressState.NOT_CHANGED && closedCount>0) {
149	addr.state = AddressState.CLOSED;
150	}
151
152	}
153	}
154	public void dumpChanged() {
155	int count = 0;
156	for (Address addr : addressList) {
157	if (addr.state == AddressState.NOT_CHANGED) {
158	continue;
159	}
160	if (addr.stateMan == AddressState.NOT_CHANGED \|\| addr.stateMan == AddressState.CREATED) {
161	continue;
162	}
163
164	if (addr.stateMan != AddressState.MODIFIED ) {
165	continue;
166	}
167
168	System.out.println(addr.state + ": " + addr.toStringExtended() );
169	System.out.println(addr.getRuteString() );
170
171	if (count++ > 15)
172	return;
173	}
174	}
175
176	public void writeBackChanges() {
177	System.out.println("Writing back changes");
178	TimingHelper timer = new TimingHelper();
179
180	List<Address> updates = new ArrayList<Address>(1024*1024);
181	List<Address> inserts = new ArrayList<Address>(16*1024);
182
183	for (Address addr : addressList) {
184	if (addr.state == AddressState.CREATED) {
185	inserts.add(addr);
186	}
187	if (addr.state == AddressState.MODIFIED \|\| addr.state == AddressState.OPENED \|\| addr.state == AddressState.CLOSED) {
188	updates.add(addr);
189	}
190	}
191
192	DatabaseLayerImplementation db = new DatabaseLayerImplementation();
193	db.updateAddresses(updates);
194
195	System.out.println("Writeback done: elapsed " + timer.getElapsed() + "ms.");
196	}
197
198
199	public void visit(AddressSourceEntry entry) {
200	if (entry.type == EntryType.TypeSingleAddress) {
201	visitSingle(entry);
202	} else {
203	visitRange(entry);
204	}
205	}
206
207	private void visitSingle(AddressSourceEntry entry) {
208	TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( entry.gadeid );
209	if (gade == null) {
210	createFromEntry(entry); // if we get here there was no match - so we need to create it
211	return;
212	}
213
214	ArrayList<Address> litraList = gade.get(entry.husnr);
215	if (litraList == null) {
216	createFromEntry(entry); // if we get here there was no match - so we need to create it
217	return;
218	}
219
220	for (Address addr : litraList) {
221	if (addr.husnrbogstav.equals(entry.litra) ) {
222	updateAddress(addr, entry);
223	return; //Done for now - no need to look at the rest of the list
224	}
225	}
226
227	createFromEntry(entry); // if we get here there was no match - so we need to create it
228	}
229
230	private void visitRange(AddressSourceEntry entry) {
231
232	throw new UnsupportedOperationException("Not implemented yet");
233	}
234
235
236
237	private void updateAddress(Address addr, AddressSourceEntry entry) {
238	if ( addr.distributor != null && addr.distributor.equals(entry.distributor) == false) {
239	afvisteEntries.add(entry);
240	System.out.println("Afviser " + entry);
241	return;
242	}
243
244	addr.visited = true;
245	if (addr.state == AddressState.NOT_CHANGED) {
246	if (addr.distributor == null) {
247	addr.state = AddressState.OPENED;
248	addr.distributor = entry.distributor;
249	} else {
250	addr.state = AddressState.MODIFIED;
251	}
252	}
253
254	if (entry.ugedage.mandag) {
255	addr.visitedMan = true;
256	if (addr.ruteMandag == null) {
257	addr.stateMan = AddressState.OPENED;
258	addr.ruteMandag = entry.rute;
259	addr.korelisteMandag = entry.koreliste;
260	} else {
261
262	if (StringUtils.equals(addr.ruteMandag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteMandag, entry.koreliste) == false) {
263	addr.stateMan = AddressState.MODIFIED;
264	addr.ruteMandag = entry.rute;
265	addr.korelisteMandag = entry.koreliste;
266	}
267	}
268	}
269
270
271	if (entry.ugedage.tirsdag) {
272	addr.visitedTir = true;
273	if (addr.ruteTirsdag == null) {
274	addr.stateTir = AddressState.OPENED;
275	addr.ruteTirsdag = entry.rute;
276	addr.korelisteTirsdag = entry.koreliste;
277	} else {
278
279	if (StringUtils.equals(addr.ruteTirsdag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteTirsdag, entry.koreliste) == false) {
280	addr.stateTir = AddressState.MODIFIED;
281	addr.ruteTirsdag = entry.rute;
282	addr.korelisteTirsdag = entry.koreliste;
283	}
284	}
285	}
286
287	if (entry.ugedage.onsdag) {
288	addr.visitedOns = true;
289	if (addr.ruteOnsdag == null) {
290	addr.stateOns = AddressState.OPENED;
291	addr.ruteOnsdag = entry.rute;
292	addr.korelisteOnsdag = entry.koreliste;
293	} else {
294
295	if (StringUtils.equals(addr.ruteOnsdag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteOnsdag, entry.koreliste) == false) {
296	addr.stateOns = AddressState.MODIFIED;
297	addr.ruteOnsdag = entry.rute;
298	addr.korelisteOnsdag = entry.koreliste;
299	}
300	}
301	}
302
303
304	if (entry.ugedage.torsdag) {
305	addr.visitedTor = true;
306	if (addr.ruteTorsdag == null) {
307	addr.stateTor = AddressState.OPENED;
308	addr.ruteTorsdag = entry.rute;
309	addr.korelisteTorsdag = entry.koreliste;
310	} else {
311
312
313	if (StringUtils.equals(addr.ruteTorsdag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteTorsdag, entry.koreliste) == false) {
314	addr.stateTor = AddressState.MODIFIED;
315	addr.ruteTorsdag = entry.rute;
316	addr.korelisteTorsdag = entry.koreliste;
317	}
318	}
319	}
320
321
322	if (entry.ugedage.fredag) {
323	addr.visitedFre = true;
324	if (addr.ruteFredag == null) {
325	addr.stateFre = AddressState.OPENED;
326	addr.ruteFredag = entry.rute;
327	addr.korelisteFredag = entry.koreliste;
328	} else {
329
330	if (StringUtils.equals(addr.ruteFredag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteFredag, entry.koreliste) == false) {
331	addr.stateFre = AddressState.MODIFIED;
332	addr.ruteFredag = entry.rute;
333	addr.korelisteFredag = entry.koreliste;
334	}
335	}
336	}
337
338
339	if (entry.ugedage.lordag) {
340	addr.visitedLor = true;
341	if (addr.ruteLordag == null) {
342	addr.stateLor = AddressState.OPENED;
343	addr.ruteLordag = entry.rute;
344	addr.korelisteLordag = entry.koreliste;
345	} else {
346
347
348	if (StringUtils.equals(addr.ruteLordag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteLordag, entry.koreliste) == false) {
349	addr.stateLor = AddressState.MODIFIED;
350	addr.ruteLordag = entry.rute;
351	addr.korelisteLordag = entry.koreliste;
352	}
353	}
354	}
355
356
357	if (entry.ugedage.sondag) {
358	addr.visitedSon = true;
359	if (addr.ruteSondag == null) {
360	addr.stateSon = AddressState.OPENED;
361	addr.ruteSondag = entry.rute;
362	addr.korelisteSondag = entry.koreliste;
363	} else {
364
365	if (StringUtils.equals(addr.ruteSondag, entry.rute) == false \|\| StringUtils.equals(addr.korelisteSondag, entry.koreliste) == false) {
366	addr.stateSon = AddressState.MODIFIED;
367	addr.ruteSondag = entry.rute;
368	addr.korelisteSondag = entry.koreliste;
369	}
370	}
371	}
372
373
374
375	}
376
377
378
379	private void createFromEntry(AddressSourceEntry entry) {
380	System.out.println("Opretter adresse ud fra " + entry);
381
382	Address a = new Address();
383	a.state = AddressState.CREATED;
384
385	a.distributor = entry.distributor;
386	a.gadeid = entry.gadeid;
387	a.kommunekode = entry.kommunekode;
388	a.vejkode = entry.vejkode;
389	a.vejnavn = entry.vejnavn;
390	a.husnr = entry.husnr;
391	a.husnrbogstav = entry.litra;
392	a.postnr = entry.postnr;
393	a.visited = true;
394
395	if (entry.ugedage.mandag) {
396	a.ruteMandag = entry.rute;
397	a.korelisteMandag = entry.koreliste;
398	}
399	if (entry.ugedage.tirsdag) {
400	a.ruteTirsdag = entry.rute;
401	a.korelisteTirsdag = entry.koreliste;
402	}
403	if (entry.ugedage.onsdag) {
404	a.ruteOnsdag = entry.rute;
405	a.korelisteOnsdag = entry.koreliste;
406	}
407	if (entry.ugedage.torsdag) {
408	a.ruteTorsdag = entry.rute;
409	a.korelisteTorsdag = entry.koreliste;
410	}
411	if (entry.ugedage.fredag) {
412	a.ruteFredag = entry.rute;
413	a.korelisteFredag = entry.koreliste;
414	}
415	if (entry.ugedage.lordag) {
416	a.ruteLordag = entry.rute;
417	a.korelisteLordag = entry.koreliste;
418	}
419	if (entry.ugedage.sondag) {
420	a.ruteSondag = entry.rute;
421	a.korelisteLordag = entry.koreliste;
422	}
423
424	// Nu er det nye adresse object oprettet - nu skal det gemmes i søge strukturen og totallisten
425
426
427	TreeMap<Short, ArrayList<Address>> gade = searchStructure.get( a.gadeid );
428
429	if (gade == null) {
430	gade = new TreeMap<Short,ArrayList<Address>>();
431	searchStructure.put(a.gadeid, gade);
432	}
433
434	ArrayList<Address> litraList = gade.get(a.husnr);
435	if (litraList == null) {
436	litraList = new ArrayList<Address>();
437	gade.put(a.husnr, litraList);
438	}
439
440	litraList.add(a);
441	addressList.add(a);
442
443	}
444
445	public List<Address> getAddressList() {
446	return Collections.unmodifiableList(addressList);
447	}
448
449	public int getAfvistAntal() {
450	return afvisteEntries.size();
451	}
452
453	}