Ejemplo n.º 1
0
 public void ApplyUpdateFile(UpdateFile updateFile)
 {
     throw new NotImplementedException("ApplyUpdateFile not implemented");
 }
Ejemplo n.º 2
0
        public void ApplyUpdateFile(UpdateFile updateFile)
        {
            DataField    target_vrid, target_frid;
            RecordUpdate ruin;
            uint         rver, target_rver;

            DataField attv, target_attv;
            DataField attf, target_attf;
            DataField natf, target_natf;
            bool      attribute_found = false;

            DataField    vrpt, target_vrpt, vrpc;
            RecordUpdate vpui;
            int          vpix, nvpt;

            DataField    coordinatefield, target_coordinatefield, sgcc;
            RecordUpdate ccui;
            int          ccix, ccnc;

            DataField    ffpt, target_ffpt, ffpc;
            RecordUpdate ffui;
            int          ffix, nfpt;

            DataField    fspt, target_fspt, fspc;
            RecordUpdate fsui;
            int          fsix, nspt;

            SFcontainer[] target_row;

            //throw new NotImplementedException("ApplyUpdateFile not implemented");
            foreach (DataRecord vr in updateFile.UpdateVectorRecords)
            {
                // Record Identifier Field
                vrid        = vr.Fields.GetFieldByTag("VRID");
                subFieldRow = vrid.subFields.Values[0];
                tagLookup   = vrid.subFields.TagIndex;
                rcnm        = subFieldRow.GetUInt32(tagLookup.IndexOf("RCNM"));
                rcid        = subFieldRow.GetUInt32(tagLookup.IndexOf("RCID"));
                rver        = subFieldRow.GetUInt32(tagLookup.IndexOf("RVER"));
                ruin        = (RecordUpdate)subFieldRow.GetUInt32(tagLookup.IndexOf("RUIN"));
                NAMEkey updateNAMEkey = new NAMEkey(rcnm, rcid);
                if (ruin == RecordUpdate.Insert)
                {
                    Vector newVec = new Vector(updateNAMEkey, vr);
                    eVectorRecords.Add(updateNAMEkey, newVec);
                }
                else
                {
                    target_vrid = eVectorRecords[updateNAMEkey].VectorRecord.Fields.GetFieldByTag("VRID");
                    target_rver = target_vrid.subFields.GetUInt32(0, "RVER");
                    if (ruin == RecordUpdate.Delete)
                    {
                        if (target_rver == rver - 1)
                        {
                            eVectorRecords.Remove(updateNAMEkey);
                        }
                    }
                    else if (ruin == RecordUpdate.Modify)
                    {
                        attv = vr.Fields.GetFieldByTag("ATTV"); //attribute update not tested
                        if (attv != null && target_rver == rver - 1)
                        {
                            int atvl, target_atvl;
                            int attl, target_attl;
                            target_attv = eVectorRecords[updateNAMEkey].VectorRecord.Fields.GetFieldByTag("ATTV");
                            if (target_attv == null)
                            {
                                eVectorRecords[updateNAMEkey].VectorRecord.Fields.Add(attv);
                            }
                            else
                            {
                                attl        = attv.subFields.TagIndex.IndexOf("ATTL");
                                target_attl = target_attv.subFields.TagIndex.IndexOf("ATTL");
                                atvl        = attv.subFields.TagIndex.IndexOf("ATVL");
                                target_atvl = target_attv.subFields.TagIndex.IndexOf("ATVL");
                                foreach (var row in attv.subFields.Values)
                                {
                                    attribute_found = false;
                                    for (int i = 0; i < target_attv.subFields.Values.Count; i++)
                                    {
                                        target_row = target_attv.subFields.Values[i];
                                        if (target_row[target_attl].Equals(row[attl])) //if attribute found, overwrite value
                                        {
                                            target_attv.subFields.Values[i][target_atvl] = row[atvl];
                                            attribute_found = true;
                                            break;
                                        }
                                    }
                                    if (!attribute_found)
                                    {
                                        target_attv.subFields.Values.Add(row); //risky, assumes same indices of ATTL and ATVl in source and target
                                    }
                                }
                            }
                        }

                        // VRPC update instruction Pointer Control Field
                        vrpc = vr.Fields.GetFieldByTag("VRPC");
                        if (vrpc != null && target_rver == rver - 1)
                        {
                            vpui        = (RecordUpdate)vrpc.subFields.GetUInt32(0, "VPUI");
                            vpix        = (int)vrpc.subFields.GetUInt32(0, "VPIX") - 1; //c sharp indices start at 0 while S57 indices start at 1
                            nvpt        = (int)vrpc.subFields.GetUInt32(0, "NVPT");     //number of vector record pointers to patch
                            vrpt        = vr.Fields.GetFieldByTag("VRPT");
                            target_vrpt = eVectorRecords[updateNAMEkey].VectorRecord.Fields.GetFieldByTag("VRPT");
                            if (vpui == RecordUpdate.Insert)
                            {
                                if (target_vrpt == null) //insert can also mean add to non-existing VRPT.
                                {
                                    eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.Add(vrpt);
                                }
                                else
                                {
                                    for (int i = 0; i < nvpt; i++)
                                    {
                                        target_vrpt.subFields.Values.Insert(vpix + i, vrpt.subFields.Values[i]); //maybe risky, assumes same subfield order in source and target
                                    }
                                }
                            }
                            else if (vpui == RecordUpdate.Delete)
                            {
                                for (int i = 0; i < nvpt; i++)
                                {
                                    target_vrpt.subFields.Values.RemoveAt(vpix);
                                }
                            }
                            else if (vpui == RecordUpdate.Modify)
                            {
                                for (int i = 0; i < nvpt; i++)
                                {
                                    target_vrpt.subFields.Values[vpix + i] = vrpt.subFields.Values[i]; //maybe risky, assumes same subfield order in source and target
                                }
                            }
                        }

                        // SGCC update instruction Coordinate Control Field
                        sgcc = vr.Fields.GetFieldByTag("SGCC");
                        if (sgcc != null && target_rver == rver - 1)
                        {
                            ccui                   = (RecordUpdate)sgcc.subFields.GetUInt32(0, "CCUI");
                            ccix                   = (int)sgcc.subFields.GetUInt32(0, "CCIX") - 1; //c sharp indices start at 0 while S57 indices start at 1
                            ccnc                   = (int)sgcc.subFields.GetUInt32(0, "CCNC");     //number of vector record pointers to patch
                            coordinatefield        = vr.Fields.GetFieldByTag("SG2D");
                            target_coordinatefield = eVectorRecords[updateNAMEkey].VectorRecord.Fields.GetFieldByTag("SG2D");
                            if (target_coordinatefield == null)
                            {
                                coordinatefield        = vr.Fields.GetFieldByTag("SG3D");
                                target_coordinatefield = eVectorRecords[updateNAMEkey].VectorRecord.Fields.GetFieldByTag("SG3D");
                            }
                            if (ccui == RecordUpdate.Insert)
                            {
                                if (target_coordinatefield == null) //insert can also mean add to non-existing coordinatefield.
                                {
                                    eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.Add(coordinatefield);
                                }
                                else
                                {
                                    for (int i = 0; i < ccnc; i++)
                                    {
                                        target_coordinatefield.subFields.Values.Insert(ccix + i, coordinatefield.subFields.Values[i]); //maybe risky, assumes same subfield order in source and target
                                    }
                                }
                            }
                            else if (ccui == RecordUpdate.Delete)
                            {
                                for (int i = 0; i < ccnc; i++)
                                {
                                    target_coordinatefield.subFields.Values.RemoveAt(ccix);
                                }
                            }
                            else if (ccui == RecordUpdate.Modify)
                            {
                                for (int i = 0; i < ccnc; i++)
                                {
                                    target_coordinatefield.subFields.Values[ccix + i] = coordinatefield.subFields.Values[i]; //risky, assumes same subfield order in source and target
                                }
                            }
                        }
                        target_vrid.subFields.Values[0][target_vrid.subFields.TagIndex.IndexOf("RVER")].uintValue = rver;
                    }
                }
            }

            foreach (DataRecord fr in updateFile.UpdateFeatureRecords)
            {
                // Record Identifier Field
                frid        = fr.Fields.GetFieldByTag("FRID");
                subFieldRow = frid.subFields.Values[0];
                tagLookup   = frid.subFields.TagIndex;
                rcnm        = subFieldRow.GetUInt32(tagLookup.IndexOf("RCNM"));
                rcid        = subFieldRow.GetUInt32(tagLookup.IndexOf("RCID"));
                rver        = subFieldRow.GetUInt32(tagLookup.IndexOf("RVER"));
                ruin        = (RecordUpdate)subFieldRow.GetUInt32(tagLookup.IndexOf("RUIN"));
                NAMEkey updateNAMEkey = new NAMEkey(rcnm, rcid);
                if (ruin == RecordUpdate.Insert)
                {
                    Feature newFeat = new Feature(updateNAMEkey, fr);
                    eFeatureRecords.Add(updateNAMEkey, newFeat);
                }
                else
                {
                    target_frid = eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.GetFieldByTag("FRID");
                    target_rver = target_frid.subFields.GetUInt32(0, "RVER");
                    if (ruin == RecordUpdate.Delete)
                    {
                        if (target_rver == rver - 1)
                        {
                            eFeatureRecords.Remove(updateNAMEkey);
                        }
                    }
                    else if (ruin == RecordUpdate.Modify)
                    {
                        attf = fr.Fields.GetFieldByTag("ATTF"); //attribute update not tested
                        if (attf != null && target_rver == rver - 1)
                        {
                            int atvl, target_atvl;
                            int attl, target_attl;
                            target_attf = eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.GetFieldByTag("ATTF");
                            if (target_attf == null)
                            {
                                eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.Add(attf);
                            }
                            else
                            {
                                attl        = attf.subFields.TagIndex.IndexOf("ATTL");
                                target_attl = target_attf.subFields.TagIndex.IndexOf("ATTL");
                                atvl        = attf.subFields.TagIndex.IndexOf("ATVL");
                                target_atvl = target_attf.subFields.TagIndex.IndexOf("ATVL");
                                foreach (var row in attf.subFields.Values)
                                {
                                    attribute_found = false;
                                    for (int i = 0; i < target_attf.subFields.Values.Count; i++)
                                    {
                                        target_row = target_attf.subFields.Values[i];
                                        if (target_row[target_attl].Equals(row[attl])) //if attribute found, overwrite value
                                        {
                                            target_attf.subFields.Values[i][target_atvl] = row[atvl];
                                            attribute_found = true;
                                            break;
                                        }
                                    }
                                    if (!attribute_found)
                                    {
                                        target_attf.subFields.Values.Add(row); //risky, assumes same indices of ATTL and ATVl in source and target
                                    }
                                }
                            }
                        }
                        natf = fr.Fields.GetFieldByTag("NATF"); //attribute update not tested
                        if (natf != null && target_rver == rver - 1)
                        {
                            int atvl, target_atvl;
                            int attl, target_attl;
                            target_natf = eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.GetFieldByTag("NATF");
                            if (target_natf == null)
                            {
                                eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.Add(natf);
                            }
                            else
                            {
                                attl        = natf.subFields.TagIndex.IndexOf("ATTL");
                                target_attl = target_natf.subFields.TagIndex.IndexOf("ATTL");
                                atvl        = natf.subFields.TagIndex.IndexOf("ATVL");
                                target_atvl = target_natf.subFields.TagIndex.IndexOf("ATVL");
                                foreach (var row in natf.subFields.Values)
                                {
                                    attribute_found = false;
                                    for (int i = 0; i < target_natf.subFields.Values.Count; i++)
                                    {
                                        target_row = target_natf.subFields.Values[i];
                                        if (target_row[target_attl].Equals(row[attl])) //if attribute found, overwrite value
                                        {
                                            target_natf.subFields.Values[i][target_atvl] = row[atvl];
                                            attribute_found = true;
                                            break;
                                        }
                                    }
                                    if (!attribute_found)
                                    {
                                        target_natf.subFields.Values.Add(row); //risky, assumes same indices of ATTL and ATVl in source and target
                                    }
                                }
                            }
                        }

                        // FFPC update instruction Pointer Control Field
                        ffpc = fr.Fields.GetFieldByTag("FFPC");
                        if (ffpc != null && target_rver == rver - 1)
                        {
                            ffui        = (RecordUpdate)ffpc.subFields.GetUInt32(0, "FFUI");
                            ffix        = (int)ffpc.subFields.GetUInt32(0, "FFIX") - 1; //c sharp indices start at 0 while S57 indices start at 1
                            nfpt        = (int)ffpc.subFields.GetUInt32(0, "NFPT");     //number of vector record pointers to patch
                            ffpt        = fr.Fields.GetFieldByTag("FFPT");
                            target_ffpt = eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.GetFieldByTag("FFPT");
                            var target = eFeatureRecords[updateNAMEkey];
                            if (ffui == RecordUpdate.Insert)
                            {
                                if (target_ffpt == null) //insert can also mean add to non-existing FFPT.
                                {
                                    eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.Add(ffpt);
                                }
                                else
                                {
                                    for (int i = 0; i < nfpt; i++)
                                    {
                                        target_ffpt.subFields.Values.Insert(ffix + i, ffpt.subFields.Values[i]); //maybe risky, assumes same subfield order in source and target
                                    }
                                }
                            }
                            else if (ffui == RecordUpdate.Delete)
                            {
                                for (int i = 0; i < nfpt; i++)
                                {
                                    target_ffpt.subFields.Values.RemoveAt(ffix);
                                }
                            }
                            else if (ffui == RecordUpdate.Modify)
                            {
                                for (int i = 0; i < nfpt; i++)
                                {
                                    target_ffpt.subFields.Values[ffix + i] = ffpt.subFields.Values[i]; //maybe risky, assumes same subfield order in source and target
                                }
                            }
                        }

                        // FSPC update instruction Pointer Control Field
                        fspc = fr.Fields.GetFieldByTag("FSPC");
                        if (fspc != null && target_rver == rver - 1)
                        {
                            fsui        = (RecordUpdate)fspc.subFields.GetUInt32(0, "FSUI");
                            fsix        = (int)fspc.subFields.GetUInt32(0, "FSIX") - 1; //c sharp indices start at 0 while S57 indices start at 1
                            nspt        = (int)fspc.subFields.GetUInt32(0, "NSPT");     //number of vector record pointers to patch
                            fspt        = fr.Fields.GetFieldByTag("FSPT");
                            target_fspt = eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.GetFieldByTag("FSPT");
                            if (fsui == RecordUpdate.Insert)
                            {
                                if (target_fspt == null) //insert can also mean add to non-existing FSPT.
                                {
                                    eFeatureRecords[updateNAMEkey].FeatureRecord.Fields.Add(fspt);
                                }
                                else
                                {
                                    for (int i = 0; i < nspt; i++)
                                    {
                                        target_fspt.subFields.Values.Insert(fsix + i, fspt.subFields.Values[i]); //maybe risky, assumes same subfield order in source and target
                                    }
                                }
                            }
                            else if (fsui == RecordUpdate.Delete)
                            {
                                for (int i = 0; i < nspt; i++)
                                {
                                    target_fspt.subFields.Values.RemoveAt(fsix);
                                }
                            }
                            else if (fsui == RecordUpdate.Modify)
                            {
                                for (int i = 0; i < nspt; i++)
                                {
                                    target_fspt.subFields.Values[fsix + i] = fspt.subFields.Values[i]; //maybe risky, assumes same subfield order in source and target
                                }
                            }
                        }
                        target_frid.subFields.Values[0][target_frid.subFields.TagIndex.IndexOf("RVER")].uintValue = rver;
                    }
                }
            }
        }