public override Exceptional<IObject> ExtractValue(DBObjectStream dbObjectStream, GraphDBType graphDBType, DBContext dbContext)
{
EdgeTypeListOfBaseObjects streams = new EdgeTypeListOfBaseObjects();
foreach (var item in dbObjectStream.ObjectStreams)
streams.Add(new DBString(item.Key + " " + item.Value.ToString()));
return new Exceptional<IObject>(streams);
}
public override Exceptional<IObject> ExtractValue(DBObjectStream dbObjectStream, GraphDBType graphDBType, DBContext dbContext)
{
EdgeTypeListOfBaseObjects parentRevisions = new EdgeTypeListOfBaseObjects();
foreach (var item in dbObjectStream.ParentRevisionIDs)
parentRevisions.Add(new DBString(item.ToString()));
return new Exceptional<IObject>(parentRevisions);
}
public void GetContent(CompilerContext context, ParseTreeNode parseNode)
{
if (parseNode.HasChildNodes())
{
if (parseNode.ChildNodes.Count >= 3)
{
IBaseEdge ListOfDefaults;
var firstListObject = GraphDBTypeMapper.GetBaseObjectFromCSharpType(parseNode.ChildNodes[2].ChildNodes[0].Token.Value);
if (parseNode.ChildNodes[1].Token.Text.ToUpper() == DBConstants.SETOF)
{
ListOfDefaults = new EdgeTypeSetOfBaseObjects();
}
else if (parseNode.ChildNodes[1].Token.Text.ToUpper() == DBConstants.LISTOF)
{
ListOfDefaults = new EdgeTypeListOfBaseObjects();
}
else
{
throw new GraphDBException(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
ListOfDefaults.AddRange(parseNode.ChildNodes[2].ChildNodes.Select(item => CheckTypeOfItems(item.Token.Value, firstListObject)));
Value = ListOfDefaults;
}
else
{
var baseObject = GraphDBTypeMapper.GetBaseObjectFromCSharpType(parseNode.ChildNodes[1].Token.Value);
Value = (IObject)baseObject;
}
}
else
{
Value = null;
}
}
private void Serialize(ref SerializationWriter mySerializationWriter, EdgeTypeListOfBaseObjects myValue)
{
mySerializationWriter.WriteUInt32((UInt32)myValue._Objects.Count);
foreach (var obj in myValue._Objects)
{
mySerializationWriter.WriteObject(obj);
}
}
private object Deserialize(ref SerializationReader mySerializationReader, EdgeTypeListOfBaseObjects myValue)
{
var count = mySerializationReader.ReadUInt32();
myValue._Objects = new List<ADBBaseObject>();
for (UInt32 i = 0; i < count; i++)
{
myValue._Objects.Add((ADBBaseObject)mySerializationReader.ReadObject());
}
return myValue;
}
public override Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>> Update(DBContext myDBContext, DBObjectStream myDBObjectStream, GraphDBType myGraphDBType)
{
Dictionary<String, Tuple<TypeAttribute, IObject>> attrsForResult = new Dictionary<String, Tuple<TypeAttribute, IObject>>();
#region AttributeUpdateList
#region data
Exceptional validateResult = AttributeIDChain.Validate(myDBContext, false);
if (validateResult.Failed())
{
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(validateResult);
}
TypeAttribute attrDef = AttributeIDChain.LastAttribute;
IEdgeType elementsToBeAdded;
EdgeTypeListOfBaseObjects undefAttrList;
#endregion
#region undefined attributes
if (AttributeIDChain.IsUndefinedAttribute)
{
if (Assign)
{
undefAttrList = new EdgeTypeListOfBaseObjects();
}
else
{
var loadExcept = LoadUndefAttributes(AttributeIDChain.UndefinedAttribute, myDBContext, myDBObjectStream);
if (loadExcept.Failed())
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(loadExcept);
if (!loadExcept.Value.ContainsKey(AttributeIDChain.UndefinedAttribute))
{
undefAttrList = new EdgeTypeListOfBaseObjects();
var addExcept = myDBContext.DBObjectManager.AddUndefinedAttribute(AttributeIDChain.UndefinedAttribute, undefAttrList, myDBObjectStream);
if (addExcept.Failed())
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(addExcept);
}
else if (!(loadExcept.Value[AttributeIDChain.UndefinedAttribute] is EdgeTypeListOfBaseObjects))
{
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(new Error_InvalidAttributeKind());
}
else
{
undefAttrList = (EdgeTypeListOfBaseObjects) loadExcept.Value[AttributeIDChain.UndefinedAttribute];
}
}
var elementsToBeAddedEdge = (IBaseEdge)undefAttrList.GetNewInstance();
foreach (var tuple in CollectionDefinition.TupleDefinition)
{
if (tuple.Value is ValueDefinition)
{
var elemToAdd = (tuple.Value as ValueDefinition).Value;
((EdgeTypeListOfBaseObjects)elementsToBeAddedEdge).Add(elemToAdd);
undefAttrList.Add(elemToAdd);
}
else
{
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
}
if (CollectionDefinition.CollectionType == CollectionType.Set)
undefAttrList.UnionWith(undefAttrList);
var addUndefExcept = myDBContext.DBObjectManager.AddUndefinedAttribute(AttributeIDChain.UndefinedAttribute, undefAttrList, myDBObjectStream);
if (addUndefExcept.Failed())
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(addUndefExcept);
attrsForResult.Add(AttributeIDChain.UndefinedAttribute, new Tuple<TypeAttribute, IObject>(AttributeIDChain.LastAttribute, elementsToBeAddedEdge));
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(attrsForResult);
}
#endregion
#region Validation that this is really a list
if (attrDef.KindOfType == KindsOfType.SetOfReferences && CollectionDefinition.CollectionType == CollectionType.List)
{
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(new Error_InvalidAssignOfSet(attrDef.Name));
}
#endregion
if (attrDef.KindOfType == KindsOfType.ListOfNoneReferences || attrDef.KindOfType == KindsOfType.SetOfNoneReferences)
{
#region ListOfNoneReferences or SetOfNoneReferences - the edge is in this case IBaseEdge
elementsToBeAdded = ((IEdgeType)AttributeIDChain.LastAttribute.EdgeType.GetNewInstance());
foreach (var tupleElem in CollectionDefinition.TupleDefinition)
{
(elementsToBeAdded as IBaseEdge).Add(GraphDBTypeMapper.GetGraphObjectFromTypeName(attrDef.GetDBType(myDBContext.DBTypeManager).Name, (tupleElem.Value as ValueDefinition).Value.Value), tupleElem.Parameters.ToArray());
}
#endregion
}
else
{
#region References
if (CollectionDefinition.CollectionType == CollectionType.SetOfUUIDs)
{
var result = CollectionDefinition.TupleDefinition.GetAsUUIDEdge(myDBContext, attrDef);
if (result.Failed())
{
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(result);
}
elementsToBeAdded = (IEdgeType)result.Value;
}
else
{
if (AttributeIDChain.LastAttribute.EdgeType == null)
{
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(new Error_InvalidEdgeType(AttributeIDChain.LastAttribute.GetType()));
}
var result = CollectionDefinition.TupleDefinition.GetCorrespondigDBObjectUUIDAsList(myGraphDBType, myDBContext, AttributeIDChain.LastAttribute.EdgeType.GetNewInstance(), AttributeIDChain.LastAttribute.GetDBType(myDBContext.DBTypeManager));
if (result.Failed())
{
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(result);
}
elementsToBeAdded = (IEdgeType)result.Value;
}
#endregion
}
#region add elements
if (elementsToBeAdded == null)
{
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(new Error_UpdateAttributeNoElements(AttributeIDChain.LastAttribute));
}
if (myDBObjectStream.HasAttribute(AttributeIDChain.LastAttribute.UUID, attrDef.GetRelatedType(myDBContext.DBTypeManager)))
{
if (Assign)
{
if (elementsToBeAdded is IReferenceEdge)
{
var oldEdge = ((IListOrSetEdgeType)myDBObjectStream.GetAttribute(AttributeIDChain.LastAttribute.UUID));
var removeRefExcept = RemoveBackwardEdgesOnReferences(this, (IReferenceEdge)oldEdge, myDBObjectStream, myDBContext);
if (!removeRefExcept.Success())
{
return new Exceptional<Dictionary<string,Tuple<TypeAttribute,IObject>>>(removeRefExcept.IErrors.First());
}
}
var alterResult = myDBObjectStream.AlterAttribute(AttributeIDChain.LastAttribute.UUID, elementsToBeAdded);
if (alterResult.Failed())
{
return new Exceptional<Dictionary<string, Tuple<TypeAttribute, IObject>>>(alterResult);
}
}
else
{
((IListOrSetEdgeType)myDBObjectStream.GetAttribute(AttributeIDChain.LastAttribute.UUID)).UnionWith((IListOrSetEdgeType)elementsToBeAdded);
}
}
else
{
myDBObjectStream.AddAttribute(AttributeIDChain.LastAttribute.UUID, elementsToBeAdded);
}
#region add backward edges
if (AttributeIDChain.LastAttribute.GetDBType(myDBContext.DBTypeManager).IsUserDefined)
{
Dictionary<AttributeUUID, IObject> userdefinedAttributes = new Dictionary<AttributeUUID, IObject>();
userdefinedAttributes.Add(AttributeIDChain.LastAttribute.UUID, elementsToBeAdded);
var omm = new ObjectManipulationManager();
var setBackEdgesExcept = omm.SetBackwardEdges(myGraphDBType, userdefinedAttributes, myDBObjectStream.ObjectUUID, myDBContext);
if (setBackEdgesExcept.Failed())
return new Exceptional<Dictionary<String, Tuple<TypeAttribute, IObject>>>(setBackEdgesExcept);
}
#endregion
attrsForResult.Add(AttributeIDChain.LastAttribute.Name, new Tuple<TypeAttribute, IObject>(AttributeIDChain.LastAttribute, elementsToBeAdded));
return new Exceptional<Dictionary<string, Tuple<TypeAttribute, IObject>>>(attrsForResult);
#endregion
#endregion
}
/// <summary>
/// Get attribute assignments for new DBObjects.
/// </summary>
/// <param name="myAttributeAssigns">The interesting ParseTreeNode.</param>
/// <param name="typeManager">The TypeManager of the GraphDB.</param>
/// <returns>A Dictionary of AttributeAssignments</returns>
private Exceptional<ManipulationAttributes> GetRecursiveAttributes(List<AAttributeAssignOrUpdate> myAttributeAssigns, DBContext myDBContext, GraphDBType myGraphDBType)
{
#region Data
var manipulationAttributes = new ManipulationAttributes();
var resultExcept = new Exceptional<ManipulationAttributes>();
if (myAttributeAssigns == null)
{
return new Exceptional<ManipulationAttributes>(manipulationAttributes);
}
TypeAttribute attr;
ADBBaseObject typedAttributeValue;
BasicType correspondingCSharpType;
Warning_UndefinedAttribute undefAttrWarning = null;
var typeMandatoryAttribs = myGraphDBType.GetMandatoryAttributesUUIDs(myDBContext.DBTypeManager);
var setExcept = myDBContext.DBSettingsManager.GetSetting(SettingUndefAttrBehaviour.UUID, myDBContext, TypesSettingScope.DB);
if (!setExcept.Success())
{
return new Exceptional<ManipulationAttributes>(setExcept);
}
var undefAttrBehave = (SettingUndefAttrBehaviour)setExcept.Value;
#endregion
#region get Data
#region proceed list
foreach (var aAttributeAssign in myAttributeAssigns)
{
var validateResult = aAttributeAssign.AttributeIDChain.Validate(myDBContext, true);
if (validateResult.Failed())
{
return new Exceptional<ManipulationAttributes>(validateResult);
}
#region Undefined attributes - Refactor and add undefined logic into defined attribute AssignsOrUpdate
System.Diagnostics.Debug.Assert(aAttributeAssign.AttributeIDChain != null);
//in this case we have an undefined attribute
if (aAttributeAssign.AttributeIDChain.IsUndefinedAttribute)
{
var UndefAttrName = aAttributeAssign.AttributeIDChain.UndefinedAttribute;
switch (undefAttrBehave.Behaviour)
{
case UndefAttributeBehaviour.disallow:
return new Exceptional<ManipulationAttributes>(new Error_UndefinedAttributes());
case UndefAttributeBehaviour.warn:
if (undefAttrWarning == null)
{
undefAttrWarning = new Warning_UndefinedAttribute();
}
resultExcept.PushIWarning(undefAttrWarning);
break;
}
if (aAttributeAssign is AttributeAssignOrUpdateList)
{
#region AttributeAssignCollection
var colDefinition = (aAttributeAssign as AttributeAssignOrUpdateList).CollectionDefinition;
EdgeTypeListOfBaseObjects valueList = new EdgeTypeListOfBaseObjects();
foreach (var tuple in colDefinition.TupleDefinition)
{
if (tuple.TypeOfValue == BasicType.Unknown)
valueList.Add((tuple.Value as ValueDefinition).Value);
else if (tuple.Value is ValueDefinition)
valueList.Add((tuple.Value as ValueDefinition).Value);
else
return new Exceptional<ManipulationAttributes>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
if (colDefinition.CollectionType == CollectionType.Set)
valueList.UnionWith(valueList);
manipulationAttributes.UndefinedAttributes.Add(UndefAttrName, valueList);
var undefAttr = new UndefinedAttributeDefinition() { AttributeName = UndefAttrName, AttributeValue = valueList };
var undefAttrAssign = new AttributeAssignOrUpdateUndefined((aAttributeAssign as AttributeAssignOrUpdateList).AttributeIDChain, undefAttr);
manipulationAttributes.AttributeToUpdateOrAssign.Add(undefAttrAssign);
#endregion
}
else if (aAttributeAssign is AttributeAssignOrUpdateValue)
{
#region AttributeAssignValue
var value = GraphDBTypeMapper.GetBaseObjectFromCSharpType((aAttributeAssign as AttributeAssignOrUpdateValue).Value);
manipulationAttributes.UndefinedAttributes.Add(UndefAttrName, value);
var undefAttr = new UndefinedAttributeDefinition() { AttributeName = UndefAttrName, AttributeValue = value };
var undefAttrAssign = new AttributeAssignOrUpdateUndefined((aAttributeAssign as AttributeAssignOrUpdateValue).AttributeIDChain, undefAttr);
manipulationAttributes.AttributeToUpdateOrAssign.Add(undefAttrAssign);
#endregion
}
else if (aAttributeAssign is AttributeAssignOrUpdateSetRef)
{
return new Exceptional<ManipulationAttributes>(new Error_InvalidReferenceAssignmentOfUndefAttr());
}
else
{
return new Exceptional<ManipulationAttributes>(new Error_InvalidUndefinedAttributeName());
}
continue;
}
#endregion
attr = aAttributeAssign.AttributeIDChain.LastAttribute;
manipulationAttributes.AttributeToUpdateOrAssign.Add(aAttributeAssign);
#region checks
if (aAttributeAssign.AttributeIDChain.LastType != myGraphDBType)
{
return new Exceptional<ManipulationAttributes>(new Error_InvalidAttribute(aAttributeAssign.AttributeIDChain.ToString()));
}
if (attr.GetDBType(myDBContext.DBTypeManager).IsBackwardEdge)
{
return new Exceptional<ManipulationAttributes>(new Error_Logic("Adding values to BackwardEdges Attributes are not allowed! (" + attr.Name + ") is an BackwardEdge Attribute of GraphType \"" + myGraphDBType.Name + "\"."));
}
#endregion
#region SpecialTypeAttribute
if (attr is ASpecialTypeAttribute)
{
if (!(aAttributeAssign is AttributeAssignOrUpdateValue))
{
return new Exceptional<ManipulationAttributes>(new Error_InvalidAttributeValue((attr as ASpecialTypeAttribute).Name, aAttributeAssign.ToString()));
}
manipulationAttributes.SpecialTypeAttributes.Add((attr as ASpecialTypeAttribute), (aAttributeAssign as AttributeAssignOrUpdateValue).Value);
continue;
}
#endregion
#region check & add
if (aAttributeAssign.AttributeIDChain.Edges.Count > 1)
{
//in case of those statements: INSERT INTO Flower VALUES (Colors.Name = 'red')
//Colors.Name is an IDNode with 2 Edges. This is not possible.
return new Exceptional<ManipulationAttributes>(new Error_Logic("Invalid attribute assignment : " + aAttributeAssign.AttributeIDChain.ToString() + " = " + aAttributeAssign));
}
if (aAttributeAssign is AttributeAssignOrUpdateList)
{
#region SetOfDBObjects
#region Check, whether this is valid for SetOfDBObjects
if (attr.KindOfType != KindsOfType.SetOfReferences)
{
if (attr.KindOfType != KindsOfType.ListOfNoneReferences)
{
if (attr.KindOfType != KindsOfType.SetOfNoneReferences)
{
return new Exceptional<ManipulationAttributes>(new Error_ReferenceAssignmentExpected(attr));//"Please use SETREF keyword instead of REF/REFERENCE or LISTOF."));
}
}
}
#endregion
#region list stuff
#region process tuple
#region process as list
var collectionDefinition = ((AttributeAssignOrUpdateList)aAttributeAssign).CollectionDefinition;
var dbType = attr.GetDBType(myDBContext.DBTypeManager);
if (dbType.IsUserDefined)
{
#region List of references
var uuids = collectionDefinition.GetEdge(attr, dbType, myDBContext);
if (uuids.Failed())
{
return new Exceptional<ManipulationAttributes>(uuids);
}
manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, dbType), uuids.Value);
if (typeMandatoryAttribs.Contains(attr.UUID))
{
manipulationAttributes.MandatoryAttributes.Add(attr.UUID);
}
#endregion
}
else
{
#region List of ADBBaseObjects (Integer, String, etc)
var edge = (aAttributeAssign as AttributeAssignOrUpdateList).GetBasicList(myDBContext);
if (edge.Failed())
{
return new Exceptional<ManipulationAttributes>(edge);
}
// If the collection was declared as a SETOF insert
if (collectionDefinition.CollectionType == CollectionType.Set)
edge.Value.Distinction();
manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), edge.Value);
if (typeMandatoryAttribs.Contains(attr.UUID))
{
manipulationAttributes.MandatoryAttributes.Add(attr.UUID);
}
#endregion
}
#endregion
#endregion
#endregion
#endregion
}
else if (aAttributeAssign is AttributeAssignOrUpdateSetRef)
{
#region reference
var aSetRefNode = ((AttributeAssignOrUpdateSetRef)aAttributeAssign).SetRefDefinition;
var singleedge = aSetRefNode.GetEdge(attr, myDBContext, attr.GetRelatedType(myDBContext.DBTypeManager));
if (singleedge.Failed())
{
return new Exceptional<ManipulationAttributes>(singleedge);
}
if (attr.GetRelatedType(myDBContext.DBTypeManager).IsUserDefined)
{
//a list which carries elements of userdefined types consists of GUIDS
manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), singleedge.Value);
if (typeMandatoryAttribs.Contains(attr.UUID))
{
manipulationAttributes.MandatoryAttributes.Add(attr.UUID);
}
}
else
{
return new Exceptional<ManipulationAttributes>(new Error_UnknownDBError("Reference types cannot be basic types."));
}
#endregion
}
else if (aAttributeAssign is AttributeAssignOrUpdateExpression)
{
#region Expression
(aAttributeAssign as AttributeAssignOrUpdateExpression).BinaryExpressionDefinition.Validate(myDBContext);
var value = (aAttributeAssign as AttributeAssignOrUpdateExpression).BinaryExpressionDefinition.ResultValue;
if (value.Failed())
{
return new Exceptional<ManipulationAttributes>(value.IErrors.First());
}
if (value.Value is ValueDefinition)
{
#region AtomValue
if (attr.KindOfType == KindsOfType.SetOfReferences || attr.KindOfType == KindsOfType.ListOfNoneReferences || attr.KindOfType == KindsOfType.SetOfNoneReferences)
return new Exceptional<ManipulationAttributes>(new Error_InvalidTuple(aAttributeAssign.ToString()));
if (!(value.Value as ValueDefinition).IsDefined)
{
(value.Value as ValueDefinition).ChangeType(attr.GetDBType(myDBContext.DBTypeManager).UUID);
}
var val = (value.Value as ValueDefinition).Value.Value;
correspondingCSharpType = GraphDBTypeMapper.ConvertGraph2CSharp(attr, attr.GetDBType(myDBContext.DBTypeManager));
if (GraphDBTypeMapper.GetEmptyGraphObjectFromType(correspondingCSharpType).IsValidValue(val))
{
typedAttributeValue = GraphDBTypeMapper.GetGraphObjectFromType(correspondingCSharpType, val);
manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), typedAttributeValue);
if (typeMandatoryAttribs.Contains(attr.UUID))
manipulationAttributes.MandatoryAttributes.Add(attr.UUID);
}
else
{
return new Exceptional<ManipulationAttributes>(new Error_InvalidAttributeValue(attr.Name, (aAttributeAssign as AttributeAssignOrUpdateValue).Value));
}
#endregion
}
else // TupleValue!
{
#region TupleValue
if (attr.KindOfType != KindsOfType.SetOfReferences)
return new Exceptional<ManipulationAttributes>(new Error_InvalidTuple(aAttributeAssign.ToString()));
if (!(attr.EdgeType is IBaseEdge))
return new Exceptional<ManipulationAttributes>(new Error_InvalidEdgeType(attr.EdgeType.GetType(), typeof(IBaseEdge)));
correspondingCSharpType = GraphDBTypeMapper.ConvertGraph2CSharp(attr, attr.GetDBType(myDBContext.DBTypeManager));
if ((value.Value as TupleDefinition).TypeOfOperatorResult != correspondingCSharpType)
return new Exceptional<ManipulationAttributes>(new Error_DataTypeDoesNotMatch(correspondingCSharpType.ToString(), (value.Value as TupleDefinition).TypeOfOperatorResult.ToString()));
var edge = attr.EdgeType.GetNewInstance() as IBaseEdge;
edge.AddRange((value.Value as TupleDefinition).Select(te => (te.Value as ValueDefinition).Value));
manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), edge as IBaseEdge);
#endregion
}
#endregion
}
else if (aAttributeAssign is AttributeAssignOrUpdateValue)
{
#region Simple value
var attrVal = aAttributeAssign as AttributeAssignOrUpdateValue;
if (attr.KindOfType == KindsOfType.ListOfNoneReferences)
return new Exceptional<ManipulationAttributes>(new Error_InvalidTuple(attrVal.ToString()));
correspondingCSharpType = GraphDBTypeMapper.ConvertGraph2CSharp(attr, attr.GetDBType(myDBContext.DBTypeManager));
if (GraphDBTypeMapper.GetEmptyGraphObjectFromType(correspondingCSharpType).IsValidValue(attrVal.Value))
{
typedAttributeValue = GraphDBTypeMapper.GetGraphObjectFromType(correspondingCSharpType, attrVal.Value);
manipulationAttributes.Attributes.Add(new TypeAndAttributeDefinition(attr, attr.GetDBType(myDBContext.DBTypeManager)), typedAttributeValue);
if (typeMandatoryAttribs.Contains(attr.UUID))
manipulationAttributes.MandatoryAttributes.Add(attr.UUID);
}
else
{
return new Exceptional<ManipulationAttributes>(new Error_InvalidAttributeValue(attr.Name, attrVal.Value));
}
#endregion
}
else
{
return new Exceptional<ManipulationAttributes>(new Error_NotImplemented(new System.Diagnostics.StackTrace(true)));
}
#endregion
}
#endregion
#endregion
resultExcept.Value = manipulationAttributes;
return resultExcept;
}
private void CalcEstimatedSize(EdgeTypeListOfBaseObjects myTypeAttribute)
{
_estimatedSize = base.GetBaseSize();
//Objects
if (_Objects != null)
{
foreach (var aADBBaseObject in _Objects)
{
_estimatedSize += aADBBaseObject.GetEstimatedSize();
}
}
}
