コード例 #1
0
        public void TranslateReturnsExpectedResult(ZipArchive archive, TranslatedChanges expected)
        {
            using (archive)
            {
                var sut = new ZipArchiveTranslator(Encoding.UTF8);

                var result = sut.Translate(archive);

                Assert.Equal(expected, result, new TranslatedChangeEqualityComparer());
            }
        }
コード例 #2
0
        public TranslatedChanges Translate(ZipArchiveEntry entry, TranslatedChanges changes)
        {
            if (entry == null)
            {
                throw new ArgumentNullException(nameof(entry));
            }
            if (changes == null)
            {
                throw new ArgumentNullException(nameof(changes));
            }

            using (var stream = entry.Open())
                using (var reader = new BinaryReader(stream, _encoding))
                {
                    var header     = DbaseFileHeader.Read(reader);
                    var enumerator = header.CreateDbaseRecordEnumerator <TRecord>(reader);
                    return(_translator.Translate(entry, enumerator, changes));
                }
        }
コード例 #3
0
        public TranslatedChanges Translate(ZipArchiveEntry entry, IDbaseRecordEnumerator <NumberedRoadChangeDbaseRecord> records, TranslatedChanges changes)
        {
            if (entry == null)
            {
                throw new ArgumentNullException(nameof(entry));
            }
            if (records == null)
            {
                throw new ArgumentNullException(nameof(records));
            }
            if (changes == null)
            {
                throw new ArgumentNullException(nameof(changes));
            }

            while (records.MoveNext())
            {
                var record = records.Current;
                if (record != null)
                {
                    switch (record.RECORDTYPE.Value)
                    {
                    case RecordType.AddedIdentifier:
                        changes = changes.Append(
                            new AddRoadSegmentToNumberedRoad(
                                new AttributeId(record.GW_OIDN.Value),
                                new RoadSegmentId(record.WS_OIDN.Value),
                                NumberedRoadNumber.Parse(record.IDENT8.Value),
                                RoadSegmentNumberedRoadDirection.ByIdentifier[record.RICHTING.Value],
                                new RoadSegmentNumberedRoadOrdinal(record.VOLGNUMMER.Value)
                                )
                            );
                        break;
                    }
                }
            }

            return(changes);
        }
コード例 #4
0
 public TranslatedChanges Translate(ZipArchiveEntry entry, IEnumerator <ShapeRecord> records, TranslatedChanges changes)
 {
     if (entry == null)
     {
         throw new ArgumentNullException(nameof(entry));
     }
     if (records == null)
     {
         throw new ArgumentNullException(nameof(records));
     }
     if (changes == null)
     {
         throw new ArgumentNullException(nameof(changes));
     }
     while (records.MoveNext())
     {
         var record = records.Current;
         if (record != null && record.Content is PointShapeContent content)
         {
             if (changes.TryTranslateToRoadNodeId(record.Header.RecordNumber, out var id))
             {
                 if (changes.TryFindAddRoadNode(id, out var change))
                 {
                     changes = changes.Replace(change, change.WithGeometry(GeometryTranslator.ToGeometryPoint(content.Shape)));
                 }
             }
         }
     }
     return(changes);
 }
コード例 #5
0
        public TranslatedChanges Translate(ZipArchiveEntry entry, IDbaseRecordEnumerator <RoadNodeChangeDbaseRecord> records, TranslatedChanges changes)
        {
            if (entry == null)
            {
                throw new ArgumentNullException(nameof(entry));
            }
            if (records == null)
            {
                throw new ArgumentNullException(nameof(records));
            }
            if (changes == null)
            {
                throw new ArgumentNullException(nameof(changes));
            }

            var recordNumber = RecordNumber.Initial;

            while (records.MoveNext())
            {
                var record = records.Current;
                if (record != null)
                {
                    switch (record.RECORDTYPE.Value)
                    {
                    case RecordType.AddedIdentifier:
                        changes = changes.Append(
                            new AddRoadNode(
                                recordNumber,
                                new RoadNodeId(record.WEGKNOOPID.Value),
                                RoadNodeType.ByIdentifier[record.TYPE.Value]
                                )
                            );
                        break;
                    }
                }
                recordNumber = recordNumber.Next();
            }

            return(changes);
        }
コード例 #6
0
        public TranslatedChanges Translate(ZipArchiveEntry entry, IDbaseRecordEnumerator <TransactionZoneDbaseRecord> records, TranslatedChanges changes)
        {
            if (entry == null)
            {
                throw new ArgumentNullException(nameof(entry));
            }
            if (records == null)
            {
                throw new ArgumentNullException(nameof(records));
            }
            if (changes == null)
            {
                throw new ArgumentNullException(nameof(changes));
            }

            if (records.MoveNext() && records.Current != null)
            {
                return(changes
                       .WithReason(new Reason(records.Current.BESCHRIJV.Value))
                       .WithOperatorName(new OperatorName(records.Current.OPERATOR.Value))
                       .WithOrganization(new OrganizationId(records.Current.ORG.Value)));
            }
            return(changes);
        }
        public TranslatedChanges Translate(ZipArchiveEntry entry, IDbaseRecordEnumerator <EuropeanRoadChangeDbaseRecord> records, TranslatedChanges changes)
        {
            if (entry == null)
            {
                throw new ArgumentNullException(nameof(entry));
            }
            if (records == null)
            {
                throw new ArgumentNullException(nameof(records));
            }
            if (changes == null)
            {
                throw new ArgumentNullException(nameof(changes));
            }

            while (records.MoveNext())
            {
                var record = records.Current;
                if (record != null)
                {
                    switch (record.RECORDTYPE.Value)
                    {
                    case RecordType.AddedIdentifier:
                        changes = changes.Append(
                            new AddRoadSegmentToEuropeanRoad(
                                new AttributeId(record.EU_OIDN.Value),
                                new RoadSegmentId(record.WS_OIDN.Value),
                                EuropeanRoadNumber.Parse(record.EUNUMMER.Value)
                                )
                            );
                        break;
                    }
                }
            }

            return(changes);
        }
        public TranslatedChanges Translate(ZipArchiveEntry entry, IDbaseRecordEnumerator <GradeSeparatedJunctionChangeDbaseRecord> records, TranslatedChanges changes)
        {
            if (entry == null)
            {
                throw new ArgumentNullException(nameof(entry));
            }
            if (records == null)
            {
                throw new ArgumentNullException(nameof(records));
            }
            if (changes == null)
            {
                throw new ArgumentNullException(nameof(changes));
            }

            while (records.MoveNext())
            {
                var record = records.Current;
                if (record != null)
                {
                    switch (record.RECORDTYPE.Value)
                    {
                    case RecordType.AddedIdentifier:
                        changes = changes.Append(
                            new AddGradeSeparatedJunction(
                                new GradeSeparatedJunctionId(record.OK_OIDN.Value),
                                GradeSeparatedJunctionType.ByIdentifier[record.TYPE.Value],
                                new RoadSegmentId(record.BO_WS_OIDN.Value),
                                new RoadSegmentId(record.ON_WS_OIDN.Value)
                                )
                            );
                        break;
                    }
                }
            }

            return(changes);
        }
コード例 #9
0
            public TranslatedChanges Translate(ZipArchiveEntry entry, IDbaseRecordEnumerator <FakeDbaseRecord> records, TranslatedChanges changes)
            {
                var collected = new List <FakeDbaseRecord>();

                while (records.MoveNext())
                {
                    collected.Add(records.Current);
                }
                Collected = collected.ToArray();

                return(changes);
            }
コード例 #10
0
 public TranslatedChanges Translate(ZipArchiveEntry entry, IDbaseRecordEnumerator <FakeDbaseRecord> records, TranslatedChanges changes)
 {
     return(_translation(changes));
 }
        public TranslatedChanges Translate(ZipArchiveEntry entry, IDbaseRecordEnumerator <RoadSegmentSurfaceChangeDbaseRecord> records, TranslatedChanges changes)
        {
            if (entry == null)
            {
                throw new ArgumentNullException(nameof(entry));
            }
            if (records == null)
            {
                throw new ArgumentNullException(nameof(records));
            }
            if (changes == null)
            {
                throw new ArgumentNullException(nameof(changes));
            }

            while (records.MoveNext())
            {
                var record = records.Current;
                if (record != null)
                {
                    switch (record.RECORDTYPE.Value)
                    {
                    case RecordType.EqualIdentifier:
                    case RecordType.AddedIdentifier:
                    case RecordType.ModifiedIdentifier:
                        var segmentId = new RoadSegmentId(record.WS_OIDN.Value);
                        if (changes.TryFindAddRoadSegment(segmentId, out var before))
                        {
                            var surface = new RoadSegmentSurfaceAttribute(
                                new AttributeId(record.WV_OIDN.Value),
                                RoadSegmentSurfaceType.ByIdentifier[record.TYPE.Value],
                                RoadSegmentPosition.FromDouble(record.VANPOSITIE.Value),
                                RoadSegmentPosition.FromDouble(record.TOTPOSITIE.Value)
                                );
                            changes = changes.Replace(before, before.WithSurface(surface));
                        }
                        break;
                    }
                }
            }

            return(changes);
        }
        public TranslatedChanges Translate(ZipArchiveEntry entry, IDbaseRecordEnumerator <RoadSegmentChangeDbaseRecord> records, TranslatedChanges changes)
        {
            if (entry == null)
            {
                throw new ArgumentNullException(nameof(entry));
            }
            if (records == null)
            {
                throw new ArgumentNullException(nameof(records));
            }
            if (changes == null)
            {
                throw new ArgumentNullException(nameof(changes));
            }

            while (records.MoveNext())
            {
                var record = records.Current;
                if (record != null)
                {
                    switch (record.RECORDTYPE.Value)
                    {
                    case RecordType.AddedIdentifier:
                        changes = changes.Append(
                            new AddRoadSegment(
                                records.CurrentRecordNumber,
                                new RoadSegmentId(record.WS_OIDN.Value),
                                new RoadNodeId(record.B_WK_OIDN.Value),
                                new RoadNodeId(record.E_WK_OIDN.Value),
                                new OrganizationId(record.BEHEERDER.Value),
                                RoadSegmentGeometryDrawMethod.ByIdentifier[record.METHODE.Value],
                                RoadSegmentMorphology.ByIdentifier[record.MORFOLOGIE.Value],
                                RoadSegmentStatus.ByIdentifier[record.STATUS.Value],
                                RoadSegmentCategory.ByIdentifier[record.WEGCAT.Value],
                                RoadSegmentAccessRestriction.ByIdentifier[record.TGBEP.Value],
                                record.LSTRNMID.Value.HasValue ? new CrabStreetnameId(record.LSTRNMID.Value.Value) : new CrabStreetnameId?(),
                                record.RSTRNMID.Value.HasValue ? new CrabStreetnameId(record.RSTRNMID.Value.Value) : new CrabStreetnameId?()
                                )
                            );
                        break;
                    }
                }
            }

            return(changes);
        }