/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="es">The mechanism for storing content.</param>
public override void WriteData(EditSerializer es)
{
base.WriteData(es);
es.WriteString(DataField.UserName, this.UserName);
es.WriteString(DataField.MachineName, this.MachineName);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
// Nothing to do - the relevant info should have come out via the geometry object attached
// to the created line feature
Debug.Assert(base.Line.LineGeometry is SegmentGeometry);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
// Let the base class do it
// ArcFeature arc = (ArcFeature)base.Line;
// editSerializer.WritePersistent<ArcFeature>("Line", arc);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
// Do nothing - line features that are represented by simple line segments
// do not need to be written out (see comment in LineFeature.WriteData).
// This method should therefore never get called (I am virtually certain
// that it would not be used in any other context).
throw new ApplicationException("Unexpected call to SegmentGeometry.WriteData");
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteDouble(DataField.Value, ObservedValue);
editSerializer.WriteByte(DataField.Unit, (byte)m_EnteredUnit.UnitType);
if (m_IsFixed)
{
editSerializer.WriteBool(DataField.Fixed, true);
}
if (IsAnnotationFlipped)
{
editSerializer.WriteBool(DataField.Flipped, true);
}
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef <LineFeature>(DataField.Line, m_Line);
editSerializer.WritePersistent <LineSubdivisionFace>(DataField.Face, m_Face);
// When we initially write the primary face, this will always be undefined. Only the
// alternate face will write out the reference to the other side.
if (OtherSide != null)
{
editSerializer.WriteInternalId(DataField.OtherSide, OtherSide.InternalId);
}
editSerializer.WriteEntity(DataField.PointType, EditingController.Current.Project.DefaultPointType);
editSerializer.WriteIdMappings(DataField.Ids, this.Features);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WritePersistent <Direction>(DataField.Direction1, m_Direction1);
editSerializer.WritePersistent <Direction>(DataField.Direction2, m_Direction2);
editSerializer.WritePersistent <FeatureStub>(DataField.To, new FeatureStub(m_To));
if (m_Line1 != null)
{
editSerializer.WritePersistent <FeatureStub>(DataField.Line1, new FeatureStub(m_Line1));
}
if (m_Line2 != null)
{
editSerializer.WritePersistent <FeatureStub>(DataField.Line2, new FeatureStub(m_Line2));
}
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WritePersistent <Direction>(DataField.Direction, m_Direction);
editSerializer.WritePersistent <Observation>(DataField.Distance, m_Distance);
editSerializer.WriteFeatureRef <PointFeature>(DataField.From, m_From);
editSerializer.WriteBool(DataField.Default, m_Default);
editSerializer.WritePersistent <FeatureStub>(DataField.To, new FeatureStub(m_To));
if (m_DirLine != null)
{
editSerializer.WritePersistent <FeatureStub>(DataField.DirLine, new FeatureStub(m_DirLine));
}
if (m_DistLine != null)
{
editSerializer.WritePersistent <FeatureStub>(DataField.DistLine, new FeatureStub(m_DistLine));
}
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WritePersistent <Observation>(DataField.Distance1, m_Distance1);
editSerializer.WriteFeatureRef <PointFeature>(DataField.From1, m_From1);
editSerializer.WritePersistent <Observation>(DataField.Distance2, m_Distance2);
editSerializer.WriteFeatureRef <PointFeature>(DataField.From2, m_From2);
editSerializer.WriteBool(DataField.Default, m_Default);
editSerializer.WritePersistent <FeatureStub>(DataField.To, new FeatureStub(m_To));
if (m_Line1 != null)
{
editSerializer.WritePersistent <FeatureStub>(DataField.Line1, new FeatureStub(m_Line1));
}
if (m_Line2 != null)
{
editSerializer.WritePersistent <FeatureStub>(DataField.Line2, new FeatureStub(m_Line2));
}
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef <PointFeature>(DataField.Center, m_Center);
editSerializer.WritePersistent <Observation>(DataField.Radius, m_Radius);
// Record a closing point only if it was created by this edit -- in that case, the radius must
// be a plain Distance (if the radius is defined using an OffsetPoint observation, the closing
// point will coincide with the offset point itself -- we don't have to write anything further,
// because the reference to the offset point is part of the observation object written above).
if (Line.StartPoint.Creator == this)
{
Debug.Assert(m_Radius is Distance);
editSerializer.WritePersistent <FeatureStub>(DataField.ClosingPoint, new FeatureStub(Line.StartPoint));
}
else
{
Debug.Assert(m_Radius is OffsetPoint);
}
editSerializer.WritePersistent <FeatureStub>(DataField.Arc, new FeatureStub(Line));
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WritePersistent <Direction>(DataField.Direction, m_Direction);
editSerializer.WriteFeatureRef <LineFeature>(DataField.Line, m_Line);
editSerializer.WriteFeatureRef <PointFeature>(DataField.CloseTo, m_CloseTo);
editSerializer.WritePersistent <FeatureStub>(DataField.To, new FeatureStub(m_Intersection));
if (m_DirLine != null)
{
editSerializer.WritePersistent <FeatureStub>(DataField.DirLine, new FeatureStub(m_DirLine));
}
if (m_LineA != null)
{
editSerializer.WriteInternalId(DataField.SplitBefore, m_LineA.InternalId);
}
if (m_LineB != null)
{
editSerializer.WriteInternalId(DataField.SplitAfter, m_LineB.InternalId);
}
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteInternalId(DataField.Id, m_InternalId);
editSerializer.WriteUInt32(DataField.Key, m_RawId);
}
/// <summary>
/// Writes updates for an editing operation to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
/// <param name="data">The collection of changes to write</param>
public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data)
{
data.WriteItem<double>(editSerializer, DataField.X);
data.WriteItem<double>(editSerializer, DataField.Y);
}
/// <summary>
/// Writes updates for an editing operation to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
/// <param name="data">The collection of changes to write</param>
public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data)
{
throw new NotImplementedException();
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
if (m_Revisions.Length == 1)
m_Revisions[0].WriteData(editSerializer);
else
editSerializer.WritePersistentArray<RevisedEdit>(DataField.RevisedEdits, m_Revisions);
}
/// <summary> /// Writes the content of this instance to a persistent storage area. /// </summary> /// <param name="editSerializer">The mechanism for storing content.</param> public abstract void WriteData(EditSerializer editSerializer);
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="es">The mechanism for storing content.</param>
public override void WriteData(EditSerializer es)
{
base.WriteData(es);
es.WriteString(DataField.ProjectId, this.ProjectId.ToString().ToUpper());
es.WriteString(DataField.ProjectName, this.ProjectName);
es.WriteInt32(DataField.LayerId, this.LayerId);
es.WriteString(DataField.CoordinateSystem, this.DefaultSystem);
es.WriteString(DataField.UserName, this.UserName);
es.WriteString(DataField.MachineName, this.MachineName);
}
/// <summary>
/// Writes updates for an editing operation to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
/// <param name="data">The collection of changes to write</param>
public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data)
{
throw new NotImplementedException();
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRefArray <Feature>(DataField.Delete, m_Deletions.ToArray());
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef<LineFeature>(DataField.Line, m_Line);
editSerializer.WriteUInt32(DataField.PositionRatio, m_PositionRatio);
editSerializer.WritePersistent<FeatureStub>(DataField.Point, new FeatureStub(m_Point));
}
/// <summary>
/// Writes updates for an editing operation to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
/// <param name="data">The collection of changes to write</param>
public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data)
{
data.WriteObservation<Distance>(editSerializer, DataField.Distance);
data.WriteItem<bool>(editSerializer, DataField.EntryFromEnd);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef<LineFeature>(DataField.Line, m_Line);
editSerializer.WritePersistent<Distance>(DataField.Distance, m_Distance);
editSerializer.WriteBool(DataField.EntryFromEnd, m_IsFromEnd);
editSerializer.WritePersistent<FeatureStub>(DataField.NewPoint, new FeatureStub(m_NewPoint));
editSerializer.WriteInternalId(DataField.NewLine1, m_NewLine1.InternalId);
editSerializer.WriteInternalId(DataField.NewLine2, m_NewLine2.InternalId);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public virtual void WriteData(EditSerializer editSerializer)
{
if (m_Font != null)
editSerializer.WriteInt32(DataField.Font, m_Font.Id);
editSerializer.WritePointGeometry(DataField.X, DataField.Y, m_Position);
editSerializer.WriteDouble(DataField.Width, Math.Round((double)m_Width, 2));
editSerializer.WriteDouble(DataField.Height, Math.Round((double)m_Height, 2));
// TODO: May want to cover indirect rotations
editSerializer.WriteRadians(DataField.Rotation, new RadianValue(m_Rotation.Radians));
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRefArray<LineFeature>(DataField.Lines, m_Lines);
editSerializer.WriteFeatureRefArray<PointFeature>(DataField.Points, m_Points);
}
/// <summary>
/// Writes updates for an editing operation to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
/// <param name="data">The collection of changes to write</param>
public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data)
{
data.WriteFeature <PointFeature>(editSerializer, DataField.UpdatedPoint);
data.WriteItem <double>(editSerializer, DataField.X);
data.WriteItem <double>(editSerializer, DataField.Y);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteInternalId(DataField.RevisedEdit, m_Edit.InternalId);
(m_Edit as IRevisable).WriteUpdateItems(editSerializer, m_Changes);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteRadians(DataField.Value, new RadianValue(m_Rotation));
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteString(DataField.Source, m_Source);
editSerializer.WritePersistentArray <Feature>(DataField.Features, this.Features);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="es">The mechanism for storing content.</param>
public override void WriteData(EditSerializer es)
{
base.WriteData(es);
es.WriteInt32(DataField.GroupId, this.GroupId);
es.WriteInt32(DataField.LowestId, this.LowestId);
es.WriteInt32(DataField.HighestId, this.HighestId);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public virtual void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteUInt32(DataField.Id, m_Sequence);
editSerializer.WriteDateTime(DataField.When, m_When);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteFeatureRef <PointFeature>(DataField.Point, m_Point);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteInternalId(DataField.Id, m_InternalId);
editSerializer.WriteEntity(DataField.Entity, m_What);
editSerializer.WriteFeatureId(m_Id);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WritePersistent <PointFeature>(DataField.Point, m_NewPoint);
}
/// <summary>
/// Writes updates for an editing operation to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
/// <param name="data">The collection of changes to write</param>
public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data)
{
data.WriteObservation <Direction>(editSerializer, DataField.Direction1);
data.WriteObservation <Direction>(editSerializer, DataField.Direction2);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRefArray<Feature>(DataField.Delete, m_Deletions.ToArray());
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WritePersistent<PointFeature>(DataField.Point, m_NewPoint);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
}
/// <summary>
/// Writes updates for an editing operation to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
/// <param name="data">The collection of changes to write</param>
public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data)
{
data.WriteItem <bool>(editSerializer, DataField.ExtendFromEnd);
data.WriteObservation <Distance>(editSerializer, DataField.Distance);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteInternalId(DataField.Id, this.Sequence);
if (Leg.PrimaryFace != this)
editSerializer.WriteInternalId(DataField.PrimaryFaceId, Leg.PrimaryFace.Sequence);
editSerializer.WriteString(DataField.EntryString, GetEntryString(null));
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteFeatureRef<LineFeature>(DataField.Base, m_Base);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef<PointFeature>(DataField.Center, m_Center);
editSerializer.WritePersistent<Observation>(DataField.Radius, m_Radius);
// Record a closing point only if it was created by this edit -- in that case, the radius must
// be a plain Distance (if the radius is defined using an OffsetPoint observation, the closing
// point will coincide with the offset point itself -- we don't have to write anything further,
// because the reference to the offset point is part of the observation object written above).
if (Line.StartPoint.Creator == this)
{
Debug.Assert(m_Radius is Distance);
editSerializer.WritePersistent<FeatureStub>(DataField.ClosingPoint, new FeatureStub(Line.StartPoint));
}
else
{
Debug.Assert(m_Radius is OffsetPoint);
}
editSerializer.WritePersistent<FeatureStub>(DataField.Arc, new FeatureStub(Line));
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WritePersistentArray <PointFeature>(DataField.Points, m_Features.ToArray());
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRefArray <LineFeature>(DataField.Lines, m_Lines);
editSerializer.WriteFeatureRefArray <PointFeature>(DataField.Points, m_Points);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef<PointFeature>(DataField.From, m_From);
editSerializer.WriteFeatureRef<PointFeature>(DataField.To, m_To);
editSerializer.WriteString(DataField.EntryString, m_EntryString);
editSerializer.WriteDistanceUnit(DataField.DefaultEntryUnit, m_DefaultEntryUnit);
editSerializer.WriteEntity(DataField.PointType, EditingController.Current.Project.DefaultPointType);
editSerializer.WriteEntity(DataField.LineType, EditingController.Current.Project.DefaultLineType);
editSerializer.WriteIdMappings(DataField.Ids, this.Features);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef <LineFeature>(DataField.Line, m_Line);
editSerializer.WriteBool(DataField.Topological, m_Topological);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
editSerializer.WritePersistent <Distance>(DataField.Offset, m_Offset);
editSerializer.WriteBool(DataField.Left, m_IsLeft);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef<LineFeature>(DataField.Line, m_Line);
editSerializer.WriteBool(DataField.Topological, m_Topological);
}
/// <summary>
/// Represents this editing operation as a text string.
/// </summary>
/// <returns>A string that can be used to save a persistent version of this edit.</returns>
internal string GetEditString()
{
EditSerializer es = new EditSerializer();
es.WritePersistent<Operation>(DataField.Edit, this);
return es.ToSerializedString();
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteBool(DataField.EntryFromEnd, m_IsEntryFromEnd);
editSerializer.WritePersistentArray <Distance>(DataField.Sections, m_Distances);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef<PointFeature>(DataField.From, m_From);
editSerializer.WriteFeatureRef<PointFeature>(DataField.To, m_To);
editSerializer.WriteBool(DataField.Topological, IsTopological);
// For simple line segments (perhaps 80% of the case when dealing with cadastral
// data), we already have what we need with the from & to points.
if (!(m_Geom is SegmentGeometry))
editSerializer.WritePersistent<LineGeometry>(DataField.Type, m_Geom);
}
/// <summary>
/// Writes updates for an editing operation to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
/// <param name="data">The collection of changes to write</param>
public void WriteUpdateItems(EditSerializer editSerializer, UpdateItemCollection data)
{
data.WriteObservation <Direction>(editSerializer, DataField.Direction);
data.WriteFeature <LineFeature>(editSerializer, DataField.Line);
data.WriteFeature <PointFeature>(editSerializer, DataField.CloseTo);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public override void WriteData(EditSerializer editSerializer)
{
base.WriteData(editSerializer);
editSerializer.WriteFeatureRef<PointFeature>(DataField.Backsight, m_Backsight);
editSerializer.WriteFeatureRef<PointFeature>(DataField.From, m_From);
editSerializer.WriteRadians(DataField.Value, m_Observation);
}
/// <summary>
/// Writes the content of this instance to a persistent storage area.
/// </summary>
/// <param name="editSerializer">The mechanism for storing content.</param>
public void WriteData(EditSerializer editSerializer)
{
editSerializer.WriteInternalId(DataField.RevisedEdit, m_Edit.InternalId);
(m_Edit as IRevisable).WriteUpdateItems(editSerializer, m_Changes);
}
