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.Map.Entry;
import java.util.TreeMap;

import org.apache.commons.lang3.StringUtils;

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

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

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

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

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

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

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

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

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

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