/// <summary>
/// Initializes a new instance of the <see cref="MultiSegmentGeometry"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal MultiSegmentGeometry(EditDeserializer editDeserializer)
: base(editDeserializer)
{
// LineString assumes 2D, with X preceding Y. Each coordinate pair is separated
// with a comma, with a space between each X and Y (e.g. "123 345,124 349,129 341")
string s = editDeserializer.ReadString(DataField.LineString);
string[] xys = s.Split(',');
m_Data = new IPointGeometry[xys.Length];
for (int i = 0; i < xys.Length; i++)
{
string xy = xys[i].Trim();
int blankPos = xy.IndexOf(' ');
if (blankPos <= 0)
{
throw new FormatException();
}
double x = Double.Parse(xy.Substring(0, blankPos));
double y = Double.Parse(xy.Substring(blankPos + 1));
m_Data[i] = new PointGeometry(x, y);
}
m_Extent = LineStringGeometry.GetExtent(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="IdAllocation"/> class.
/// </summary>
/// <param name="ed">The mechanism for reading back content.</param>
internal IdAllocation(EditDeserializer ed)
: base(ed)
{
this.GroupId = ed.ReadInt32(DataField.GroupId);
this.LowestId = ed.ReadInt32(DataField.LowestId);
this.HighestId = ed.ReadInt32(DataField.HighestId);
}
/// <summary>
/// Initializes a new instance of the <see cref="ArcGeometry"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal ArcGeometry(EditDeserializer editDeserializer)
: base(editDeserializer)
{
m_IsClockwise = editDeserializer.ReadBool(DataField.Clockwise);
if (editDeserializer.IsNextField(DataField.Center))
{
PointFeature center = editDeserializer.ReadFeatureRef <PointFeature>(this, DataField.Center);
// The arc is the first arc attached to the circle. However, we cannot
// calculate the radius just yet because the bc/ec points are not persisted
// as part of the ArcGeometry definition (they are defined as part of the
// LineFeature object that utilizes the ArcGeometry).
// Even if we did have the bc/ec points at this stage, their positions will
// only be available if the data came from an import (they will still be
// undefined if the geometry is calculated, since calculation only occurs
// after deserialization has been completed).
if (center != null)
{
ApplyFeatureRef(DataField.Center, center);
}
}
else
{
ArcFeature firstArc = editDeserializer.ReadFeatureRef <ArcFeature>(this, DataField.FirstArc);
if (firstArc != null)
{
ApplyFeatureRef(DataField.FirstArc, firstArc);
}
}
}
/// <summary>
/// Loads the content of an editing event.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
/// <returns>The created editing event object</returns>
static internal Change Deserialize(EditDeserializer editDeserializer)
{
Change result = editDeserializer.ReadPersistent <Change>(DataField.Edit);
// Note that calculated geometry is NOT defined at this stage. That happens
// when the model is asked to index the data.
// Associate referenced features with the edit
result.AddReferences();
// If we're dealing with an update, exchange update items. Do this NOW (rather than at it's natural
// spot in the editing sequence) so as to avoid repeated calculation loops during loading. When an
// update is applied during regular editing work, we have to rework the calculation sequence and
// rollforward all the subsequent edits. So we'd have to do that for every update. By applying changes
// now, we'll end up doing a single calculation loop.
UpdateOperation upo = (result as UpdateOperation);
if (upo != null)
{
upo.ApplyChanges();
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="Operation"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
protected Operation(EditDeserializer editDeserializer)
: base(editDeserializer)
{
editDeserializer.CurrentEdit = this;
m_Session = editDeserializer.MapModel.LastSession;
Debug.Assert(m_Session != null);
}
/// <summary>
/// Initializes a new instance of the <see cref="PointFeature"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal PointFeature(EditDeserializer editDeserializer)
: base(editDeserializer)
{
long x, y;
ReadData(editDeserializer, out x, out y);
m_Geom = new Node(this, new PointGeometry(x, y));
}
/// <summary>
/// Initializes a new instance of the <see cref="LineGeometry"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
protected LineGeometry(EditDeserializer editDeserializer)
{
// When deserializing line geometry (in the context of line features), passing
// the terminal down via the EditDeserializer is a bit too contrived. Instead,
// we'll set the terminals back in LineFeature.ReadData.
m_Start = m_End = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="MiscTextGeometry"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal RowTextGeometry(EditDeserializer editDeserializer)
: base(editDeserializer)
{
// This constructor exists only to satisfy the requirement that classes implementing
// IPersistent (as specified by the TextGeometry class) must also provide a constructor
// that accepts a deserializer object. The RowTextContent class must be used instead.
throw new ApplicationException("Unexpected attempt to deserialize RowTextGeometry");
}
/// <summary>
/// Initializes a new instance of the <see cref="SectionGeometry"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal SectionGeometry(EditDeserializer editDeserializer)
: base(editDeserializer)
{
m_Base = editDeserializer.ReadFeatureRef <LineFeature>(DataField.Base);
if (m_Base == null)
{
throw new ArgumentNullException();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NewProjectEvent"/> class.
/// </summary>
/// <param name="ed">The mechanism for reading back content.</param>
internal NewProjectEvent(EditDeserializer ed)
: base(ed)
{
this.ProjectId = new Guid(ed.ReadString(DataField.ProjectId));
this.ProjectName = ed.ReadString(DataField.ProjectName);
this.LayerId = ed.ReadInt32(DataField.LayerId);
this.DefaultSystem = ed.ReadString(DataField.CoordinateSystem);
this.UserName = ed.ReadString(DataField.UserName);
this.MachineName = ed.ReadString(DataField.MachineName);
}
/// <summary>
/// Loads a miscellaneous value back from a storage medium (so long as it comes next in the supplied
/// deserialization stream).
/// </summary>
/// <typeparam name="T">The type of value expected by the caller.</typeparam>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
/// <param name="field">The tag that identifies the value.</param>
/// <returns>True if an item was loaded, false if the next item in the deserialization
/// stream does not have the specified name.</returns>
internal bool ReadItem <T>(EditDeserializer editDeserializer, DataField field) where T : IConvertible
{
if (editDeserializer.IsNextField(field))
{
T result = editDeserializer.ReadValue <T>(field);
Add(new UpdateItem(field, result));
return(true);
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="Change"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="ed">The mechanism for reading back content.</param>
protected Change(EditDeserializer ed)
{
m_Sequence = ed.ReadUInt32(DataField.Id);
m_When = ed.ReadDateTime(DataField.When);
// Handle old files
//if (ed.IsNextField(DataField.When))
// m_When = ed.ReadDateTime(DataField.When);
//else
// m_When = DateTime.Now; // could perhaps grab the session start time
}
/// <summary>
/// Loads an observation back from a storage medium (so long as it comes next in the supplied
/// deserialization stream).
/// </summary>
/// <typeparam name="T">The type of object expected by the caller.</typeparam>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
/// <param name="field">The tag that identifies the item.</param>
/// <returns>True if an observation was loaded, false if the next item in the deserialization
/// stream does not have the specified name.</returns>
internal bool ReadObservation <T>(EditDeserializer editDeserializer, DataField field) where T : Observation
{
if (editDeserializer.IsNextField(field))
{
T result = editDeserializer.ReadPersistent <T>(field);
Add(new UpdateItem(field, result));
return(true);
}
return(false);
}
/// <summary>
/// Loads a feature reference back from a storage medium (so long as it comes next in the supplied
/// deserialization stream).
/// </summary>
/// <typeparam name="T">The type of feature expected by the caller.</typeparam>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
/// <param name="field">The tag that identifies the item.</param>
/// <returns>True if a feature reference was loaded, false if the next item in the deserialization
/// stream does not have the specified name.</returns>
internal bool ReadFeature <T>(EditDeserializer editDeserializer, DataField field) where T : Feature
{
if (editDeserializer.IsNextField(field))
{
T result = editDeserializer.ReadFeatureRef <T>(field);
Add(new UpdateItem(field, result));
return(true);
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="TextFeature"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal TextFeature(EditDeserializer editDeserializer)
: base(editDeserializer)
{
bool isTopological;
ReadData(editDeserializer, out isTopological, out m_PolygonPosition, out m_Geom);
SetTopology(isTopological);
if (m_Geom is KeyTextGeometry)
{
(m_Geom as KeyTextGeometry).Label = this;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LegFace"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal LegFace(EditDeserializer editDeserializer)
{
// Only connection paths should generate LegFace instances
PathOperation op = (editDeserializer.CurrentEdit as PathOperation);
if (op == null)
{
throw new ApplicationException("Unexpected creating edit for a leg face");
}
this.Sequence = editDeserializer.ReadInternalId(DataField.Id);
if (editDeserializer.IsNextField(DataField.PrimaryFaceId))
{
InternalIdValue primaryFaceId = editDeserializer.ReadInternalId(DataField.PrimaryFaceId);
LegFace face = op.FindFace(primaryFaceId);
if (face == null)
{
throw new ApplicationException("Cannot locate primary face " + primaryFaceId);
}
Leg = face.Leg;
Leg.AlternateFace = this;
}
else
{
// This should never happen. Primary faces are not serialized using the LegFace
// class (we only use LegFace as part of a PathOperation to simplify import of
// extra legs from old CEdit files).
throw new ApplicationException();
}
// Convert the data entry string into observed spans
string entryString = editDeserializer.ReadString(DataField.EntryString);
DistanceUnit defaultEntryUnit = EditingController.Current.EntryUnit;
Distance[] dists = LineSubdivisionFace.GetDistances(entryString, defaultEntryUnit, false);
m_Spans = new SpanInfo[dists.Length];
for (int i = 0; i < m_Spans.Length; i++)
{
m_Spans[i] = new SpanInfo()
{
ObservedDistance = dists[i]
};
}
}
/// <summary>
/// Reads data that was previously written using <see cref="WriteData"/>
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
/// <param name="isTopological">Are we dealing with a polygon label</param>
/// <param name="polPos">The label reference point (usually applies onlt to polygon labels). Null if it's
/// identical to the position recorded via the geometry object.</param>
/// <param name="geom">The geometry for the text.</param>
static void ReadData(EditDeserializer editDeserializer, out bool isTopological, out PointGeometry polPos, out TextGeometry geom)
{
isTopological = editDeserializer.ReadBool(DataField.Topological);
if (editDeserializer.IsNextField(DataField.PolygonX))
{
polPos = editDeserializer.ReadPointGeometry(DataField.PolygonX, DataField.PolygonY);
}
else
{
polPos = null;
}
geom = editDeserializer.ReadPersistent <TextGeometry>(DataField.Type);
}
/// <summary>
/// Initializes a new instance of the <see cref="Feature"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
protected Feature(EditDeserializer editDeserializer)
{
m_Creator = editDeserializer.CurrentEdit;
Debug.Assert(m_Creator != null);
ReadData(editDeserializer, out m_InternalId, out m_What, out m_Id);
m_References = null;
m_Flag = 0;
// If a user-defined ID is present, ensure it knows about this feature, and vice versa
if (m_Id != null)
{
m_Id.AddReference(this);
}
// Remember this feature as part of the model
m_Creator.MapModel.AddFeature(this);
}
/// <summary>
/// Reads data that was previously written using <see cref="WriteData"/>
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
/// <param name="font">The text style</param>
/// <param name="position">Position of the text's reference point</param>
/// <param name="height">The height of the text, in meters on the ground.</param>
/// <param name="width">The total width of the text, in meters on the ground.</param>
/// <param name="rotation">Clockwise rotation from horizontal</param>
static void ReadData(EditDeserializer editDeserializer, out IFont font, out PointGeometry position,
out float height, out float width, out IAngle rotation)
{
if (editDeserializer.IsNextField(DataField.Font))
{
int fontId = editDeserializer.ReadInt32(DataField.Font);
font = EnvironmentContainer.FindFontById(fontId);
}
else
{
font = null;
}
position = editDeserializer.ReadPointGeometry(DataField.X, DataField.Y);
width = (float)editDeserializer.ReadDouble(DataField.Width);
height = (float)editDeserializer.ReadDouble(DataField.Height);
rotation = editDeserializer.ReadRadians(DataField.Rotation);
}
void LoadDataFiles(string folderName, uint[] fileNums)
{
Trace.Write("Reading data...");
EditDeserializer ed = new EditDeserializer(this);
Session lastSession = null;
IdManager idMan = m_MapModel.IdManager;
foreach (uint fileNum in fileNums)
{
string editFile = Path.Combine(folderName, ProjectDatabase.GetDataFileName(fileNum));
using (TextReader tr = File.OpenText(editFile))
{
TextEditReader er = new TextEditReader(tr);
// Ignore any empty files altogether
while (er.HasNext)
{
ed.SetReader(er);
Change edit = Change.Deserialize(ed);
if (edit is NewProjectEvent)
{
m_ProjectInfo = (NewProjectEvent)edit;
// If the project settings don't have default entity types, initialize them with
// the layer defaults. This covers a case where the settings file has been lost, and
// automatically re-created by ProjectSettings.CreateInstance.
var layer = EnvironmentContainer.FindLayerById(m_ProjectInfo.LayerId);
m_Settings.SetEntityTypeDefaults(layer);
}
else if (edit is NewSessionEvent)
{
lastSession = new Session(this, (NewSessionEvent)edit, editFile);
m_MapModel.AddSession(lastSession);
}
else if (edit is EndSessionEvent)
{
Debug.Assert(lastSession != null);
lastSession.EndTime = edit.When;
}
else if (edit is IdAllocation)
{
if (idMan != null)
{
IdAllocation alloc = (IdAllocation)edit;
IdGroup g = idMan.FindGroupById(alloc.GroupId);
g.AddIdPacket(alloc);
// Remember that allocations have been made in the session (bit of a hack
// to ensure the session isn't later removed if no edits are actually
// performed).
lastSession.AddAllocation(alloc);
}
}
else
{
Debug.Assert(edit is Operation);
Debug.Assert(lastSession != null);
lastSession.AddOperation((Operation)edit);
}
}
}
}
if (m_ProjectInfo == null)
{
throw new ApplicationException("Could not locate the project creation event");
}
// Apply any forward references
ed.ApplyForwardRefs();
// Remember the highest internal ID used by the project
SetLastItem(fileNums[fileNums.Length - 1]);
}
/// <summary>
/// Initializes a new instance of the <see cref="MiscTextGeometry"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal MiscTextGeometry(EditDeserializer editDeserializer)
: base(editDeserializer)
{
m_Text = editDeserializer.ReadString(DataField.Text);
}
/// <summary>
/// Initializes a new instance of the <see cref="RowTextContent"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal RowTextContent(EditDeserializer editDeserializer)
: base(editDeserializer)
{
m_TableId = editDeserializer.ReadInt32(DataField.Table);
m_TemplateId = editDeserializer.ReadInt32(DataField.Template);
}
/// <summary>
/// Reads data that was previously written using <see cref="WriteData"/>
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
/// <param name="line">The line the point should appear on </param>
/// <param name="positionRatio">The position ratio of the attached point.</param>
/// <param name="point">The point that was created.</param>
static void ReadData(EditDeserializer editDeserializer, out long x, out long y)
{
x = editDeserializer.ReadInt64(DataField.X);
y = editDeserializer.ReadInt64(DataField.Y);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnsectionedLineGeometry"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
protected UnsectionedLineGeometry(EditDeserializer editDeserializer)
: base(editDeserializer)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="FeatureStub"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal FeatureStub(EditDeserializer editDeserializer)
{
m_Creator = editDeserializer.CurrentEdit;
Debug.Assert(m_Creator != null);
ReadData(editDeserializer, out m_InternalId, out m_What, out m_Id);
}
/// <summary>
/// Reads data that was previously written using <see cref="WriteData"/>
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
/// <param name="id">The internal of the feature within the project that created it.</param>
/// <param name="entity">The type of real-world object that the feature corresponds to.</param>
/// <param name="fid">The ID of the feature (may be null).</param>
static void ReadData(EditDeserializer editDeserializer, out InternalIdValue id, out IEntity entity, out FeatureId fid)
{
id = editDeserializer.ReadInternalId(DataField.Id);
entity = editDeserializer.ReadEntity(DataField.Entity);
fid = editDeserializer.ReadFeatureId();
}
/// <summary>
/// Initializes a new instance of the <see cref="TextGeometry"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
protected TextGeometry(EditDeserializer editDeserializer)
{
ReadData(editDeserializer, out m_Font, out m_Position, out m_Height, out m_Width, out m_Rotation);
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyTextGeometry"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal KeyTextGeometry(EditDeserializer editDeserializer)
: base(editDeserializer)
{
// Nothing to do - the TextFeature constructor must define the Label property after
// this geometry object has been created.
}
/// <summary>
/// Initializes a new instance of the <see cref="ArcFeature"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal ArcFeature(EditDeserializer editDeserializer)
: base(editDeserializer)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="IdMapping"/> class
/// using the data read from persistent storage.
/// </summary>
/// <param name="editDeserializer">The mechanism for reading back content.</param>
internal IdMapping(EditDeserializer editDeserializer)
{
m_InternalId = editDeserializer.ReadInternalId(DataField.Id);
m_RawId = editDeserializer.ReadUInt32(DataField.Key);
}