persolijn

Relation.java (3208B)

---

 package osm.message;
 
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.function.Supplier;
 
 import protobuf.ProtobufReader;
 
 // enum MemberType {
 // NODE = 0;
 // WAY = 1;
 // RELATION = 2;
 // } 
 // required int64 id = 1;
 // repeated uint32 keys = 2 [packed = true];
 // repeated uint32 vals = 3 [packed = true];
 // optional Info info = 4;
 // repeated int32 roles_sid = 8 [packed = true]; // This should have been defined as uint32 for consistency, but it is now too late to change it
 // repeated sint64 memids = 9 [packed = true]; // DELTA encoded
 // repeated MemberType types = 10 [packed = true];
 public class Relation extends AbstractEntity<Relation> {
     public static enum RelationMemberType {
         NODE, WAY, RELATION
     }
 
     public static class RelationMember {
         private RelationMemberType type;
         private long id;
         private String role;
 
         public RelationMemberType getType() {
             return type;
         }
 
         public long getID() {
             return id;
         }
 
         public String getRole() {
             return role;
         }
     }
 
     private List<RelationMember> members = new ArrayList<>();
 
     public Relation(PrimitiveBlock block) {
         super(block);
     }
 
     private <T> void expandList(List<T> list, int index, Supplier<T> with) {
         while (list.size() <= index)
             list.add(with.get());
     }
 
     @Override
     public Relation parseRemaining(Iterator<ProtobufReader> tags) {
         int indexRole = 0,
                 indexID = 0,
                 indexType = 0;
 
         while (tags.hasNext()) {
             ProtobufReader message = tags.next();
             switch (message.tag()) {
                 case 4:
                     message.skip();
                     break;
                 case 8:
                     Iterator<Integer> roles = message.packed(message::varint32);
                     while (roles.hasNext()) {
                         expandList(members, indexRole, RelationMember::new);
 
                         members.get(indexRole).role = block.stringtable.get(roles.next());
                         indexRole++;
                     }
                     break;
                 case 9:
                     Iterator<Long> ids = message.packed(message::svarint64, 0L, Long::sum);
                     while (ids.hasNext()) {
                         expandList(members, indexID, RelationMember::new);
 
                         members.get(indexID).id = ids.next();
                         indexID++;
                     }
                     break;
                 case 10:
                     Iterator<Integer> types = message.packed(message::varint32);
                     while (types.hasNext()) {
                         expandList(members, indexType, RelationMember::new);
 
                         members.get(indexType).type = RelationMemberType.values()[types.next()];
                         indexType++;
                     }
                     break;
                 default:
                     message.throwUnexpected();
             }
         }
         return this;
     }
 
     public List<RelationMember> getMembers() {
         return members;
     }
 }