/// <summary>
/// Конструктор
/// </summary>
/// <param name="essence"></param>
/// <param name="referenceType"></param>
/// <param name="referenceDirection"></param>
public LinkedEssence(Essence essence, ReferenceType referenceType, ReferenceDirection referenceDirection)
{
Essence = essence;
ReferenceType = referenceType;
LinkDirection = referenceDirection;
ReferenceName = referenceDirection == ReferenceDirection.AsOwner
? referenceType.ReferenceTypeNameLine
: referenceType.ReferenceTypeNameReverse;
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="essence"></param>
/// <param name="referenceType"></param>
/// <param name="referenceDirection"></param>
public LinkedEssence(Essence essence, ReferenceType referenceType, ReferenceDirection referenceDirection)
{
Essence = essence;
ReferenceType = referenceType;
LinkDirection = referenceDirection;
ReferenceName = referenceDirection == ReferenceDirection.AsOwner
? referenceType.ReferenceTypeNameLine
: referenceType.ReferenceTypeNameReverse;
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="referenceType"></param>
/// <param name="direction"></param>
public ReferenceTypeWithDirection(ReferenceType referenceType, ReferenceDirection direction)
{
Direction = direction;
// ReSharper disable DoNotCallOverridableMethodsInConstructor
ReferenceTypeId = referenceType.ReferenceTypeId;
ReferenceTypeNameLine = referenceType.ReferenceTypeNameLine;
ReferenceTypeNameReverse = referenceType.ReferenceTypeNameReverse;
ReferenceTypeCode = referenceType.ReferenceTypeCode;
Comment = referenceType.Comment;
UpdateInfo = referenceType.UpdateInfo;
// ReSharper restore DoNotCallOverridableMethodsInConstructor
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="referenceType"></param>
/// <param name="direction"></param>
public ReferenceTypeWithDirection(ReferenceType referenceType, ReferenceDirection direction)
{
Direction = direction;
// ReSharper disable DoNotCallOverridableMethodsInConstructor
ReferenceTypeId = referenceType.ReferenceTypeId;
ReferenceTypeNameLine = referenceType.ReferenceTypeNameLine;
ReferenceTypeNameReverse = referenceType.ReferenceTypeNameReverse;
ReferenceTypeCode = referenceType.ReferenceTypeCode;
Comment = referenceType.Comment;
UpdateInfo = referenceType.UpdateInfo;
// ReSharper restore DoNotCallOverridableMethodsInConstructor
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Wraps the GetLinkedObjs$ stored procedure.
/// </summary>
/// <param name="ids">Array of ids to process.</param>
/// <param name="linkedObjectType">Mask that indicates what types of related objects
/// should be retrieved.</param>
/// <param name="fIncludeBaseClasses">A flag that determines if the base classes of owned
/// objects are included in the object list (e.g., rows for each object + all
/// superclasses except CmObject. So if a CmPerson is included, it will also have a row
/// for CmPossibility)</param>
/// <param name="fIncludeSubClasses">A flag that determines if the sub classes of owned
/// objects are included in the object list.</param>
/// <param name="fRecurse">A flag that determines if the owning tree is traversed.
/// </param>
/// <param name="referenceDirection">Determines which reference directions will be
/// included in the results.</param>
/// <param name="filterByClass">only return objects of this class (including subclasses
/// of this class). Zero (0) returns all classes.</param>
/// <param name="fCalculateOrderKey">A flag that determines if the order key is
/// calculated.</param>
///
/// <returns>A generic list that contains zero, or more, LinkedObjectInfo objects.</returns>
/// <remarks>
/// The <b>ids</b> parameter handles the first two parameters in the actual stored
/// procedure (@ObjId and @hXMLDocObjList).
/// </remarks>
/// ------------------------------------------------------------------------------------
public override List<LinkedObjectInfo> GetLinkedObjects(List<int> ids, LinkedObjectType linkedObjectType,
bool fIncludeBaseClasses, bool fIncludeSubClasses, bool fRecurse,
ReferenceDirection referenceDirection, int filterByClass, bool fCalculateOrderKey)
{
CheckDisposed();
List<LinkedObjectInfo> result = new List<LinkedObjectInfo>();
Hashtable ht = ((NewCacheBase)m_odde).Hashtable;
if (linkedObjectType == LinkedObjectType.Reference ||
linkedObjectType == LinkedObjectType.OwningAndReference)
{
if (referenceDirection == ReferenceDirection.Inbound
|| referenceDirection == ReferenceDirection.InboundAndOutbound)
{
// at the moment, we expect this method to get called only by
// CmObject.BackReferences or CmObject.LinkedObjects.
Debug.Assert(fCalculateOrderKey == false);
Debug.Assert(filterByClass == 0);
Debug.Assert(fIncludeBaseClasses == true);
// NOTE: cacheEntry is a System.Collections.DictionaryEntry, which has NOTHING to do with
// linguistic lexicon stuff!
foreach (DictionaryEntry cacheEntry in ht)
{
CacheKey key = cacheEntry.Key as CacheKey;
bool fOwningProp = IsOwningProperty(key.Tag);
bool fFoundLinkedObj = false;
if (cacheEntry.Value is int && ids.Contains((int)cacheEntry.Value))
{
fFoundLinkedObj = true;
int hvoVal = (int)cacheEntry.Value;
foreach (int id in ids)
{
if (id == hvoVal)
{
if (fOwningProp && key.Hvo == GetOwnerOfObject(id))
fFoundLinkedObj = false;
break;
}
}
if (fFoundLinkedObj)
SaveLinkedObjInfo(hvoVal, key, linkedObjectType, result);
}
else if (cacheEntry.Value is int[])
{
ArrayList hvos = new ArrayList((int[])cacheEntry.Value);
foreach (int id in ids)
{
if (hvos.Contains(id) && !(fOwningProp && key.Hvo == GetOwnerOfObject(id)))
{
SaveLinkedObjInfo(id, key, linkedObjectType, result);
}
}
}
}
}
return result;
}
throw new NotImplementedException("Not yet implemented in NewFdoCache");
}
