/// <summary> /// A single parameter /// </summary> /// <param name="myParameterName">The name of the parameter. Currently this is not used.</param> /// <param name="myParameterDBType">The DBType of the parameter</param> /// <param name="myVariableNumOfParams">True if this parameter occurs 1 or more time. This have to be the last parameter!</param> public ParameterValue(String myParameterName, ADBBaseObject myParameterDBType, Boolean myVariableNumOfParams) : this() { Name = myParameterName; DBType = myParameterDBType; VariableNumOfParams = myVariableNumOfParams; }
public override IEnumerable<ObjectUUID> IndexSingleOperation(AAttributeIndex myIndex, ADBBaseObject myOperationValue, AttributeUUID myAttributeUUID, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { IndexKey lookup = new IndexKey(myAttributeUUID, myOperationValue, myIndex.IndexKeyDefinition); var currentType = dbContext.DBTypeManager.GetTypeByUUID(myIndex.IndexRelatedTypeUUID); var result = myIndex.Contains(lookup, currentType, dbContext); if (result.Value) { var interestingUUIDs = myIndex.GetValues(lookup, currentType, dbContext); foreach (var aIndexValue in myIndex.GetAllValues(currentType, dbContext)) { foreach (var aUUID in aIndexValue) { if (!interestingUUIDs.Contains(aUUID)) { yield return aUUID; } } } } else { foreach (var aIndexValue in myIndex.GetKeyValues(currentType, dbContext).Select(kv => kv.Value)) { foreach (var aUUID in aIndexValue) { yield return aUUID; } } } yield break; }
public SetRefDefinition(Structures.TupleDefinition tupleDefinition, ADBBaseObject[] myParameters) { System.Diagnostics.Debug.Assert(tupleDefinition != null); this.TupleDefinition = tupleDefinition; this.Parameters = myParameters; }
/// <summary> /// A single parameter /// </summary> /// <param name="myParameterName">The name of the parameter. Currently this is not used.</param> /// <param name="myParameterDBType">The DBType of the parameter</param> public ParameterValue(String myParameterName, ADBBaseObject myParameterDBType) : this() { Name = myParameterName; DBType = myParameterDBType; VariableNumOfParams = false; }
public ADBSettingsBase(ADBSettingsBase myCopy) { Name = myCopy.Name; Description = myCopy.Description; OwnerID = myCopy.OwnerID; Type = myCopy.Type; Default = myCopy.Default; _Value = myCopy._Value; }
public ADBSettingsBase(String myName, String myDescription, EntityUUID myOwnerID, TypeUUID myType, ADBBaseObject myDefault, ADBBaseObject myValue) { Name = myName; Description = myDescription; OwnerID = myOwnerID; Type = myType; Default = myDefault; _Value = myValue; }
/// <summary> /// Adds a single ADBBaseObject to the IndexKex /// </summary> /// <param name="myAttributeUUID">AttributeUUID corresponding to the ADBBaseObject</param> /// <param name="myIndexKeyPayload">The ADBBaseObject that is going to be added</param> /// <param name="myIndexDefinition">The corresponding IndexKeyDefinition</param> public IndexKey(AttributeUUID myAttributeUUID, ADBBaseObject myIndexKeyPayload, IndexKeyDefinition myIndexDefinition) { if (!myIndexDefinition.IndexKeyAttributeUUIDs.Contains(myAttributeUUID)) { throw new GraphDBException(new Error_IndexKeyCreationError(myAttributeUUID, myIndexKeyPayload, myIndexDefinition)); } else { AddAAKey(myAttributeUUID, myIndexKeyPayload); } }
public override IEnumerable<ObjectUUID> IndexSingleOperation(AAttributeIndex myIndex, ADBBaseObject myOperationValue, AttributeUUID myAttributeUUID, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { var myIndeyKey = new IndexKey(myAttributeUUID, myOperationValue, myIndex.IndexKeyDefinition); var currentType = dbContext.DBTypeManager.GetTypeByUUID(myIndex.IndexRelatedTypeUUID); if (myIndex.Contains(myIndeyKey, currentType, dbContext)) { foreach (var aUUID in myIndex.GetValues(myIndeyKey, currentType, dbContext)) { yield return aUUID; } } yield break; }
public override void ApplyParams(params EdgeTypeParamDefinition[] myParams) { if (myParams.Count() == 0) throw new GraphDBException(new Error_EdgeParameterCountMismatch(EdgeTypeName, 0, 1)); // The first parameter has to be the type if (myParams[0].Type != ParamType.GraphType) { throw new GraphDBException(new Error_DataTypeDoesNotMatch(myParams[0].Type.ToString(), "BaseType like 'Integer', 'Double, etc")); } else { _CountBy = myParams[0].Param as ADBBaseObject; } _Count = _CountBy.Clone(); _Count.SetValue(DBObjectInitializeType.Default); #region Get default node if exists if (myParams.Any(p => p.Type == ParamType.DefaultValueDef)) { var def = (from p in myParams where p.Type == ParamType.DefaultValueDef select p).First(); if (_CountBy.IsValidValue(def.Param)) { _CountBy.SetValue(def.Param); } else { throw new GraphDBException(new Error_DataTypeDoesNotMatch(_CountBy.ObjectName, def.Param.GetType().Name)); } } else { _CountBy.SetValue(1); } #endregion CalcEstimatedSize(this); }
public virtual IEnumerable<ObjectUUID> IndexSingleOperation(AAttributeIndex myIndex, ADBBaseObject myOperationValue, AttributeUUID myAttributeUUID, TypesOfBinaryExpression typeOfBinExpr, DBContext dbContext) { foreach (var keyValPair in myIndex.GetKeyValues(dbContext.DBTypeManager.GetTypeByUUID(myIndex.IndexRelatedTypeUUID), dbContext)) { var res = Compare(keyValPair.Key.IndexKeyValues[0], myOperationValue); if (res.Failed()) { throw new GraphDBException(res.PushIError(new Error_InvalidIndexOperation(myIndex.IndexName, keyValPair.Key.IndexKeyValues[0].Value, myOperationValue.Value)).IErrors); } if (res.Value) { foreach (var aUUID in keyValPair.Value) { yield return aUUID; } } } yield break; }
public override void Sub(ADBBaseObject myGraphObject) { }
public override ADBBaseObject Sub(ADBBaseObject myGraphObjectA, ADBBaseObject myGraphObjectB) { return myGraphObjectA; }
/// <summary> /// Check for a containing element /// </summary> /// <param name="myValue"></param> /// <returns></returns> public override bool Contains(ADBBaseObject myValue) { return _Objects.Contains((ADBBaseObject)myValue); }
/// <summary> /// Adds a new value with some optional parameters /// </summary> /// <param name="myValue"></param> /// <param name="myParameters"></param> public override void Add(ADBBaseObject myValue, params ADBBaseObject[] myParameters) { _Objects.Add(myValue); }
/// <summary> /// Remove a value /// </summary> /// <param name="myValue"></param> /// <returns></returns> public override Boolean Remove(ADBBaseObject myValue) { return _Objects.Remove((ADBBaseObject)myValue); }
private static Boolean ConvertToBestMatchingTypeReverse(ref ADBBaseObject myDBBaseObjectB, ref ADBBaseObject myDBBaseObjectA) { #region Both are not unknown if ((myDBBaseObjectA.Type != BasicType.Unknown) && (myDBBaseObjectB.Type != BasicType.Unknown)) { #region Types matching, we can leave if (myDBBaseObjectA.Type == myDBBaseObjectB.Type) { return true; } #endregion #region DBList and DBReference are not matchable with other types else if (myDBBaseObjectA is DBEdge || myDBBaseObjectA is DBReference || myDBBaseObjectB is DBEdge || myDBBaseObjectB is DBReference) { return false; } #endregion #region The types does not match - so try to convert the right-handed to the left handed type else if (myDBBaseObjectA is DBUInt64) { // if (DBUInt64.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return true; } return false; } else if (myDBBaseObjectA is DBInt64) { // if (DBInt64.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return true; } // do not change to ConvertToBestMatchingType(ref myDBBaseObjectB, ref myDBBaseObjectA) return false; } else if (myDBBaseObjectA is DBDouble) { // if (DBDouble.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return true; } return false; } else if (myDBBaseObjectA is DBDateTime) { // if (DBDateTime.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return true; } return false; } else if (myDBBaseObjectA is DBBoolean) { // if (DBDouble.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return true; } return false; } else if (myDBBaseObjectA is DBString) { // if (DBString.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return true; } return false; } #endregion // we couldnt find a matching type for both are not unknown return false; } #endregion #region Both are strings - thats fine else if (myDBBaseObjectA is DBString && myDBBaseObjectB is DBString) { return true; } #endregion #region only one is unknown else if (!(myDBBaseObjectA.Type == BasicType.Unknown && myDBBaseObjectB.Type == BasicType.Unknown)) { #region myDBBaseObjectA is unknown - try to use the type of myDBBaseObjectB if (myDBBaseObjectA.Type == BasicType.Unknown) { try { // avaoid changing a Double to Int64 if (myDBBaseObjectA is DBNumber && (myDBBaseObjectB.Type == BasicType.Int64 || myDBBaseObjectB.Type == BasicType.UInt64)) { if (myDBBaseObjectA.Value is Double && DBDouble.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBDouble(myDBBaseObjectA.Value); myDBBaseObjectB = new DBDouble(myDBBaseObjectB.Value); return true; } } myDBBaseObjectA = myDBBaseObjectB.Clone(myDBBaseObjectA.Value); } catch { return false; } } #endregion #region myDBBaseObjectB is unknown - try to use the type of myDBBaseObjectA else if (myDBBaseObjectB.Type == BasicType.Unknown) { try { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); } catch { return false; } } else { return false; } #endregion } #endregion #region both are unknown #region One of them is expected as a Number - so try to parse both as a number else if (myDBBaseObjectA is DBNumber || myDBBaseObjectB is DBNumber) { if (DBInt64.IsValid(myDBBaseObjectA.Value) && DBInt64.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBInt64(myDBBaseObjectA.Value); myDBBaseObjectB = new DBInt64(myDBBaseObjectB.Value); } else if (DBUInt64.IsValid(myDBBaseObjectA.Value) && DBUInt64.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBUInt64(myDBBaseObjectA.Value); myDBBaseObjectB = new DBUInt64(myDBBaseObjectB.Value); } else if (DBDouble.IsValid(myDBBaseObjectA.Value) && DBDouble.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBDouble(myDBBaseObjectA.Value); myDBBaseObjectB = new DBDouble(myDBBaseObjectB.Value); } else { return false; } } #endregion #region Try all other dataTypes else { // check all types beginning with the hardest and ending with string (matches all) if (DBDateTime.IsValid(myDBBaseObjectA.Value) && DBDateTime.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBDateTime(myDBBaseObjectA.Value); myDBBaseObjectB = new DBDateTime(myDBBaseObjectB.Value); } else if (DBBoolean.IsValid(myDBBaseObjectA.Value) && DBBoolean.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBBoolean(myDBBaseObjectA.Value); myDBBaseObjectB = new DBBoolean(myDBBaseObjectB.Value); } else if (DBEdge.IsValid(myDBBaseObjectA.Value) && DBEdge.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBEdge(myDBBaseObjectA.Value); myDBBaseObjectB = new DBEdge(myDBBaseObjectB.Value); } else if (DBReference.IsValid(myDBBaseObjectA.Value) && DBReference.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBReference(myDBBaseObjectA.Value); myDBBaseObjectB = new DBReference(myDBBaseObjectB.Value); } else if (DBString.IsValid(myDBBaseObjectA.Value) && DBString.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBString(myDBBaseObjectA.Value); myDBBaseObjectB = new DBString(myDBBaseObjectB.Value); } else { return false; } } #endregion #endregion return true; }
/// <summary> /// Remove a value /// </summary> /// <param name="myValue"></param> /// <returns></returns> public abstract Boolean Remove(ADBBaseObject myValue);
public override ADBBaseObject Sub(ADBBaseObject myGraphObjectA, ADBBaseObject myGraphObjectB) { throw new NotImplementedException(); }
public Error_EdgeParameterTypeMismatch(ADBBaseObject currentType, params ADBBaseObject[] expectedTypes) { CurrentType = currentType; ExpectedTypes = expectedTypes; }
public Error_IndexKeyCreationError(AttributeUUID myAttributeUUID, ADBBaseObject myIndexKeyPayload, IndexKeyDefinition myIndexDefinition) { AttributeUUID = myAttributeUUID; IndexKeyPayload = myIndexKeyPayload; IndexDefinition = myIndexDefinition; }
/// <summary> /// Check for a containing element /// </summary> /// <param name="myValue"></param> /// <returns></returns> public abstract Boolean Contains(ADBBaseObject myValue);
/// <summary> /// Adds a new value with some optional parameters /// </summary> /// <param name="myValue"></param> /// <param name="myParameters"></param> public abstract void Add(ADBBaseObject myValue, params ADBBaseObject[] myParameters);
public override void Sub(ADBBaseObject myGraphObject) { _Value -= Convert.ToDouble(myGraphObject.Value); }
public static Exceptional<Boolean> ConvertToBestMatchingType(ref ADBBaseObject myDBBaseObjectA, ref ADBBaseObject myDBBaseObjectB) { #region Both are not unknown if ((myDBBaseObjectA.Type != BasicType.Unknown) && (myDBBaseObjectB.Type != BasicType.Unknown)) { #region Types matching, we can leave if (myDBBaseObjectA.Type == myDBBaseObjectB.Type) { return new Exceptional<Boolean>(true); } #endregion #region DBList and DBReference are not matchable with other types else if (myDBBaseObjectA is DBEdge || myDBBaseObjectB is DBEdge) { return new Exceptional<Boolean>(false); } #endregion #region The types does not match - so try to convert the right-handed to the left handed type else if (myDBBaseObjectA is DBUInt64) { // if (DBUInt64.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return new Exceptional<Boolean>(true); } return new Exceptional<Boolean>(ConvertToBestMatchingTypeReverse(ref myDBBaseObjectA, ref myDBBaseObjectB)); } else if (myDBBaseObjectA is DBInt64) { // if (DBInt64.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return new Exceptional<Boolean>(true); } return new Exceptional<Boolean>(ConvertToBestMatchingTypeReverse(ref myDBBaseObjectA, ref myDBBaseObjectB)); } else if (myDBBaseObjectA is DBInt32) { // if (DBInt32.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return new Exceptional<Boolean>(true); } return new Exceptional<Boolean>(ConvertToBestMatchingTypeReverse(ref myDBBaseObjectA, ref myDBBaseObjectB)); } else if (myDBBaseObjectA is DBDouble) { // if (DBDouble.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return new Exceptional<Boolean>(true); } return new Exceptional<Boolean>(ConvertToBestMatchingTypeReverse(ref myDBBaseObjectA, ref myDBBaseObjectB)); } else if (myDBBaseObjectA is DBDateTime) { // if (DBDateTime.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return new Exceptional<Boolean>(true); } return new Exceptional<Boolean>(ConvertToBestMatchingTypeReverse(ref myDBBaseObjectA, ref myDBBaseObjectB)); } else if (myDBBaseObjectA is DBBoolean) { // if (DBBoolean.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); return new Exceptional<Boolean>(true); } return new Exceptional<Boolean>(ConvertToBestMatchingTypeReverse(ref myDBBaseObjectA, ref myDBBaseObjectB)); } #endregion // we couldnt find a matching type for both are not unknown return new Exceptional<bool>(new Error_NotImplemented(new StackTrace(true), String.Format("no type conversion implemented for {0} and {1}", myDBBaseObjectA.GetType(), myDBBaseObjectB.GetType()))); } #endregion #region Both are strings - thats fine else if (myDBBaseObjectA is DBString && myDBBaseObjectB is DBString) { return new Exceptional<Boolean>(true); } #endregion #region only one is unknown else if (!(myDBBaseObjectA.Type == BasicType.Unknown && myDBBaseObjectB.Type == BasicType.Unknown)) { #region myDBBaseObjectA is unknown - try to use the type of myDBBaseObjectB if (myDBBaseObjectA.Type == BasicType.Unknown) { // avoid changing a Double to Int64 if (myDBBaseObjectA is DBNumber && (myDBBaseObjectB.Type == BasicType.Int64 || myDBBaseObjectB.Type == BasicType.UInt64)) { if (myDBBaseObjectA.Value is Double && DBDouble.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBDouble(myDBBaseObjectA.Value); myDBBaseObjectB = new DBDouble(myDBBaseObjectB.Value); return new Exceptional<bool>(true); } } try { myDBBaseObjectA = myDBBaseObjectB.Clone(myDBBaseObjectA.Value); } catch { return new Exceptional<bool>(new Error_DataTypeDoesNotMatch(myDBBaseObjectB.GetType().Name, myDBBaseObjectA.Value.GetType().Name)); } } #endregion #region myDBBaseObjectB is unknown - try to use the type of myDBBaseObjectA else if (myDBBaseObjectB.Type == BasicType.Unknown) { // avoid changing a Double to Int64 if (myDBBaseObjectB is DBNumber && (myDBBaseObjectA.Type == BasicType.Int64 || myDBBaseObjectA.Type == BasicType.UInt64)) { if (myDBBaseObjectB.Value is Double && DBDouble.IsValid(myDBBaseObjectA.Value)) { myDBBaseObjectA = new DBDouble(myDBBaseObjectA.Value); myDBBaseObjectB = new DBDouble(myDBBaseObjectB.Value); return new Exceptional<bool>(true); } } try { myDBBaseObjectB = myDBBaseObjectA.Clone(myDBBaseObjectB.Value); } catch { return new Exceptional<bool>(new Error_DataTypeDoesNotMatch(myDBBaseObjectA.Value.GetType().ToString(), myDBBaseObjectB.GetType().ToString())); } } else { return new Exceptional<bool>(false); } #endregion } #endregion #region both are unknown #region One of them is expected as a Number - so try to parse both as a number else if (myDBBaseObjectA is DBNumber || myDBBaseObjectB is DBNumber) { if (DBInt64.IsValid(myDBBaseObjectA.Value) && DBInt64.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBInt64(myDBBaseObjectA.Value); myDBBaseObjectB = new DBInt64(myDBBaseObjectB.Value); } else if (DBUInt64.IsValid(myDBBaseObjectA.Value) && DBUInt64.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBUInt64(myDBBaseObjectA.Value); myDBBaseObjectB = new DBUInt64(myDBBaseObjectB.Value); } else if (DBDouble.IsValid(myDBBaseObjectA.Value) && DBDouble.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBDouble(myDBBaseObjectA.Value); myDBBaseObjectB = new DBDouble(myDBBaseObjectB.Value); } else { return new Exceptional<Boolean>(false); } } #endregion #region Try all other dataTypes else { // check all types beginning with the hardest and ending with string (matches all) if (DBDateTime.IsValid(myDBBaseObjectA.Value) && DBDateTime.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBDateTime(myDBBaseObjectA.Value); myDBBaseObjectB = new DBDateTime(myDBBaseObjectB.Value); } else if (DBBoolean.IsValid(myDBBaseObjectA.Value) && DBBoolean.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBBoolean(myDBBaseObjectA.Value); myDBBaseObjectB = new DBBoolean(myDBBaseObjectB.Value); } else if (DBEdge.IsValid(myDBBaseObjectA.Value) && DBEdge.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBEdge(myDBBaseObjectA.Value); myDBBaseObjectB = new DBEdge(myDBBaseObjectB.Value); } else if (DBReference.IsValid(myDBBaseObjectA.Value) && DBReference.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBReference(myDBBaseObjectA.Value); myDBBaseObjectB = new DBReference(myDBBaseObjectB.Value); } else if (DBString.IsValid(myDBBaseObjectA.Value) && DBString.IsValid(myDBBaseObjectB.Value)) { myDBBaseObjectA = new DBString(myDBBaseObjectA.Value); myDBBaseObjectB = new DBString(myDBBaseObjectB.Value); } else { return new Exceptional<Boolean>(false); } } #endregion #endregion return new Exceptional<bool>(true); }
public override void ApplyParams(params EdgeTypeParamDefinition[] myParams) { if (myParams.Count() == 0) throw new ArgumentException("EdgeTypeWeightedList: Expected at least 1 parameter for edge type WeightedList!"); // The first parameter has to be the type if (myParams[0].Type != ParamType.GraphType) { throw new ArgumentException("EdgeTypeWeightedList: The first parameter has to be the type 'Integer', 'Double, etc"); } else { weightDataType = myParams[0].Param as ADBBaseObject; } #region Get default node if exists if (myParams.Any(p => p.Type == ParamType.DefaultValueDef)) { var def = (from p in myParams where p.Type == ParamType.DefaultValueDef select p).First(); weightDataType.SetValue(def.Param); } #endregion weightedSet.SetWeightedDefaultValue((DBNumber)weightDataType); #region Get sort if exists if (myParams.Any(p => p.Type == ParamType.Sort)) { var sort = (from p in myParams where p.Type == ParamType.Sort select p).First(); weightedSet.SetSortDirection((SortDirection)sort.Param); } #endregion CalcEstimatedSize(this); }
/// <summary> /// check for the correct type of each list item /// </summary> /// <param name="myObjects">current object in list</param> /// <param name="myLastObject">last object in list</param> /// <returns>an ADBBaseObject</returns> private ADBBaseObject CheckTypeOfItems(object myObjects, ADBBaseObject myLastObject) { var baseObject = GraphDBTypeMapper.GetBaseObjectFromCSharpType(myObjects); if (baseObject.Type == myLastObject.Type) { return baseObject; } else { throw new GraphDBException(new Error_InvalidAttrDefaultValueAssignment(baseObject.ObjectName, myLastObject.ObjectName)); } }
public override int CompareTo(ADBBaseObject obj) { return CompareTo(obj.Value); }
protected override Exceptional<Boolean> Compare(ADBBaseObject myLeft, ADBBaseObject myRight) { if (!GraphDBTypeMapper.ConvertToBestMatchingType(ref myLeft, ref myRight).Value) { return new Exceptional<Boolean>(new Error_DataTypeDoesNotMatch(myLeft.Type.ToString(), myRight.Type.ToString())); } return new Exceptional<Boolean>(myLeft.CompareTo(myRight) == 0); }
public override void Sub(ADBBaseObject myGraphObject) { throw new NotImplementedException(); }
protected abstract Exceptional<Boolean> Compare(ADBBaseObject myLeft, ADBBaseObject myRight);