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