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	torben	2838	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	torben	2839	public int getAfvistAntal() {
445			return afvisteEntries.size();
446			}
447
448	torben	2838	}