internal ICmObjectId GetCanonicalID(CmObjectId candidate)
{
lock (SyncRoot)
{
ICmObjectOrSurrogate existing;
if (!m_IdentityMap.TryGetValue(candidate, out existing))
{
m_IdentityMap[candidate] = candidate;
existing = candidate;
}
return(existing.Id);
}
}
// IReferenceTypeHandler override
public override void Activate(IReferenceActivationContext context)
{
if (m_serverOnlyMode)
{
ActivateServer(context);
return;
}
if (m_cache == null)
{
throw new NullReferenceException("m_cache");
}
if (m_identitymap == null)
{
throw new NullReferenceException("m_identitymap");
}
var context2 = (UnmarshallingContext)context;
var buffer = (ByteArrayBuffer)context2.Buffer();
// Get Guid and CmObjectId.
// Earlier code used a special CmObject.Create() method, I think because it is faster,
// and on the assumption that we only activate objects at startup, so none of the
// IDs have been seen before. However, with a background thread fluffing things, we
// COULD have seen it, even during startup, if we've fluffed some object that references
// this one. Also, this code is called in client-server mode when we Refresh an object
// to see whether someone else changed it, and then the ID is very likely to exist already.
// It MAY be possible to re-introduce the faster ID creation code just during startup
// if we're not overlapping fluffing and reading.
var reconId = CmObjectId.FromGuid(new Guid(buffer.ReadBytes(16)), m_identitymap);
// Get class name.
var className = m_unicodeEnc.GetString(buffer.ReadBytes(buffer.ReadInt()));
// Get the data.
var dataLength = buffer.ReadInt();
// Reconstitute the surrogate.
((CmObjectSurrogate)context.PersistentObject()).InitializeFromDataStore(
m_cache,
reconId,
className,
buffer.ReadBytes(dataLength));
}
/// <summary>
/// This method should be used when it is desirable to have HVOs associated with
/// Guids for objects which may not yet have been fluffed up. The ObjectOrId may be
/// passed to GetHvoFromObjectOrId to get an HVO; anything that actually uses
/// the HVO will result in the object being fluffed, but that can be delayed (e.g.,
/// when persisting a pre-sorted list of guids).
/// It will return null if the guid does not correspond to a real object (that is,
/// for success the identity map must contain either a CmObject or a surrogate, not
/// just a CmObjectId.)
/// </summary>
internal ICmObjectOrId GetObjectOrIdWithHvoFromGuid(Guid guid)
{
ICmObjectOrSurrogate canonicalItem;
lock (SyncRoot)
{
var oldCanonicalId = CmObjectId.FromGuid(guid, this);
canonicalItem = m_IdentityMap[oldCanonicalId];
}
if (canonicalItem is ICmObject)
{
return((ICmObject)canonicalItem);
}
if (canonicalItem is CmObjectSurrogate)
{
return(((CmObjectSurrogate)canonicalItem).ObjectOrIdWithHvo);
}
// If it's neither, it doesn't map to a valid object, and we don't want to
// assign it an HVO.
return(null);
}
/// <summary>
/// returns null if there are no more CmObejtcSurroages on the stream.
/// </summary>
internal CmObjectSurrogate GetNextCmObjectSurrogate(GZipStream stream)
{
var temp = new byte[16];
if (stream.Read(temp, 0, 16) <= 0)
{
return(null);
}
var cmObjectId = CmObjectId.FromGuid(new Guid(temp), m_identityMap);
string className = m_unicodeEncoding.GetString(stream.ReadBytes(stream.ReadInt()));
byte[] xmldata = stream.ReadBytes(stream.ReadInt());
long id = stream.ReadLong();
var ret = new CmObjectSurrogate(m_cache, cmObjectId, className, xmldata);
m_mapId.Add(ret.Id, id);
return(ret);
}
/// <summary>
/// Create a surrogate from some other surrogate (or CmObject).
/// This is used for porting from one BEP to another,
/// and it is faster than getting all the stuff from the xml string.
/// </summary>
public ICmObjectSurrogate Create(ICmObjectOrSurrogate source)
{
var sourceSurrogate = source as ICmObjectSurrogate;
// No! This is not what is needed in porting,
// since it makes a new surrogate with the ICmObject from the source BEP.
//if (sourceSurrogate == null)
// return Create(source as ICmObject);
if (sourceSurrogate == null)
{
// Have to make a new surrogate from the extant ICmObject information,
// since we don't even want to think of just reusing the ICmObject.
var asCmObject = (ICmObject)source;
var asInternal = (ICmObjectInternal)asCmObject;
return(new CmObjectSurrogate(
m_cache,
CmObjectId.Create(asCmObject.Guid),
asCmObject.ClassName,
asInternal.ToXmlString()));
}
return(new CmObjectSurrogate(m_cache, sourceSurrogate));
}
/// <summary>
/// object ids are equal if their guids are.
/// </summary>
public bool Equals(CmObjectId id)
{
return m_guid == id.m_guid;
}
ICmObjectId ICmObjectIdFactory.NewId()
{
return(CmObjectId.FromGuid(Guid.NewGuid(), this));
}
ICmObjectId ICmObjectIdFactory.FromGuid(Guid guid)
{
return(CmObjectId.FromGuid(guid, this));
}
ICmObjectId ICmObjectIdFactory.FromBase64String(string guid)
{
return(CmObjectId.FromGuid(GuidServices.GetGuid(guid), this));
}
/// <summary>
/// object ids are equal if their guids are.
/// </summary>
public bool Equals(CmObjectId id)
{
return(m_guid == id.m_guid);
}
