adressevedligehold/coveragefileupload/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	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
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			}