persolijn

DenseNodes.java (3807B)

---

 package osm.message;
 
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.function.Supplier;
 
 import protobuf.Message;
 import protobuf.ProtobufReader;
 
 // repeated sint64 id = 1 [packed = true]; // DELTA coded
 // optional DenseInfo denseinfo = 5;
 // repeated sint64 lat = 8 [packed = true]; // DELTA coded
 // repeated sint64 lon = 9 [packed = true]; // DELTA coded
 // repeated int32 keys_vals = 10 [packed = true]; 
 public class DenseNodes implements Message<List<Node>> {
     public final PrimitiveBlock block;
 
     public DenseNodes(PrimitiveBlock block) {
         this.block = block;
     }
 
     private <T> void expandList(List<T> list, int index, Supplier<T> with) {
         while (list.size() <= index)
             list.add(with.get());
     }
 
     @Override
     public List<Node> parse(Iterator<ProtobufReader> iter) {
         boolean isKey = true;
 
         int indexID = 0,
                 indexLatiude = 0,
                 indexLongitude = 0,
                 indexTags = 0;
 
         List<Node> nodes = new ArrayList<>();
 
         while (iter.hasNext()) {
             ProtobufReader stream = iter.next();
 
             switch (stream.tag()) {
                 case 1:
                     Iterator<Long> ids = stream.packed(stream::svarint64, 0l, Long::sum);
                     while (ids.hasNext()) {
                         expandList(nodes, indexID, () -> new Node(block));
 
                         nodes.get(indexID).id = ids.next();
                         indexID++;
                     }
                     break;
                 case 5:
                     stream.skip();
                     break;
                 case 8:
                     Iterator<Double> lats = stream.packed(stream::svarint64,
                             n -> block.latitudeOffset + block.granularity * n,
                             0.0d, Double::sum);
                     while (lats.hasNext()) {
                         expandList(nodes, indexLatiude, () -> new Node(block));
 
                         nodes.get(indexLatiude).latitude = lats.next();
 
                         indexLatiude++;
                     }
                     break;
                 case 9:
                     Iterator<Double> lons = stream.packed(stream::svarint64,
                             n -> block.longitudeOffset + block.granularity * n,
                             0.0d, Double::sum);
                     while (lons.hasNext()) {
                         expandList(nodes, indexLongitude, () -> new Node(block));
                         nodes.get(indexLongitude).longitude = lons.next();
 
                         indexLongitude++;
                     }
                     break;
                 case 10:
                     Iterator<Integer> tags = stream.packed(stream::varint32);
                     while (tags.hasNext()) {
                         int strIndex = tags.next();
                         if (isKey) {
                             expandList(nodes, indexTags, () -> new Node(block));
                             if (strIndex == 0) {
                                 indexTags++;
                                 continue;
                             }
                             String key = block.stringtable.get(strIndex);
                             nodes.get(indexTags).keys.add(key);
 
                             isKey = false;
                         } else {
                             String value = block.stringtable.get(strIndex);
                             nodes.get(indexTags).values.add(value);
 
                             isKey = true;
                         }
                     }
                     break;
                 default:
                     stream.throwUnexpected();
                     break;
             }
         }
 
         return nodes;
     }
 }