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;

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