C# IVertex.GetProperty方法代码示例

        private static IComparable GetValue(this IPropertyDefinition myProperty, IVertex myVertex)
        {
            if (myProperty.RelatedType == null)
                throw new ArgumentException("A property with nor related type is not allowed.");

            if (!myProperty.RelatedType.Name.Equals(GlobalConstants.Vertex))
                return myVertex.GetProperty<IComparable>(myProperty.ID);

            switch (myProperty.Name)
            {
                case GlobalConstants.VertexDotComment:
                    return myVertex.Comment;

                case GlobalConstants.VertexDotCreationDate:
                    return myVertex.CreationDate;

                case GlobalConstants.VertexDotEdition:
                    return myVertex.EditionName;

                case GlobalConstants.VertexDotModificationDate:
                    return myVertex.ModificationDate;

                case GlobalConstants.VertexDotRevision:
                    return myVertex.VertexRevisionID;

                case GlobalConstants.VertexDotVertexTypeID:
                    return myVertex.VertexTypeID;

                case GlobalConstants.VertexDotVertexTypeName:
                    return myProperty.RelatedType.GetDescendantTypesAndSelf().Where(_ => _.ID == myVertex.VertexTypeID).Select(__ => __.Name).FirstOrDefault();

                case GlobalConstants.VertexDotVertexID:
                    return myVertex.VertexID;

                default:
                    throw new System.Exception(
                        "A new property was added to the vertex type Vertex, but this switch stement was not changed.");

            }
        }

        private static PropertyMultiplicity GetPropertyMultiplicity(IVertex myVertex)
        {
            var multID = myVertex.GetProperty<Byte>((long)AttributeDefinitions.PropertyDotMultiplicity);

            if (!Enum.IsDefined(typeof(PropertyMultiplicity), multID))
                throw new UnknownDBException("The value for the property multiplicity is incorrect.");

            return (PropertyMultiplicity)multID;
        }

 private static bool GetIsMandatory(IVertex myVertex)
 {
     return myVertex.GetProperty<bool>((long)AttributeDefinitions.PropertyDotIsMandatory);
 }

 private static bool GetIndexDotIsUserDefined(IVertex myIndexVertex)
 {
     return myIndexVertex.GetProperty<bool>((long)AttributeDefinitions.IndexDotIsUserDefined);
 }

        private static EdgeMultiplicity GetEdgeMultiplicity(IVertex myOutgoingEdgeVertex)
        {
            var multID = myOutgoingEdgeVertex.GetProperty<Byte>((long)AttributeDefinitions.OutgoingEdgeDotMultiplicity);

            if (!Enum.IsDefined(typeof(EdgeMultiplicity), multID))
                throw new UnknownDBException("The value for the edge multiplicity is incorrect.");

            return (EdgeMultiplicity)multID;
        }

        public static IIndexDefinition CreateIndexDefinition(IVertex myIndexVertex, IVertexType myDefiningVertexType = null)
        {
            var id = GetUUID(myIndexVertex);
            var props = GetIndexedProperties(myIndexVertex);
            var typeName = GetIndexTypeName(myIndexVertex);
            var edition = myIndexVertex.EditionName;
            var isUserDefined = GetIndexDotIsUserDefined(myIndexVertex);
            var name = GetIndexDotName(myIndexVertex);
            var single = myIndexVertex.GetProperty<bool>((long)AttributeDefinitions.IndexDotIsSingleValue);
            var range = myIndexVertex.GetProperty<bool>((long)AttributeDefinitions.IndexDotIsRange);
            var version = myIndexVertex.GetProperty<bool>((long)AttributeDefinitions.IndexDotIsVersioned);
            var sourceIndex = (myIndexVertex.HasOutgoingEdge((long)AttributeDefinitions.IndexDotSourceIndex))
                ? CreateIndexDefinition(myIndexVertex.GetOutgoingSingleEdge((long)AttributeDefinitions.IndexDotSourceIndex).GetTargetVertex())
                : null;

            myDefiningVertexType = myDefiningVertexType ?? GetDefiningVertexType(myIndexVertex);

            return new IndexDefinition
            {
                ID = id,
                IndexedProperties = props,
                Edition = edition,
                IndexTypeName = typeName,
                IsUserdefined = isUserDefined,
                Name = name,
                VertexType = myDefiningVertexType,
                IsSingle = single,
                IsRange = range,
                IsVersioned = version,
                SourceIndex = sourceIndex,
            };
        }

 /// <summary>
 /// Creates a search key by checking which properties are indexed.
 /// </summary>
 /// <param name="myIndexedProperties">Indexed properties</param>
 /// <param name="myVertex">Vertex which shall be stored in the index.</param>
 /// <returns>A search key for that index</returns>
 private static IComparable CreateIndexEntry(IList<Int64> myIndexedProperties, IVertex myVertex)
 {
     if (myIndexedProperties.Count > 1)
     {
         var values = new List<IComparable>(myIndexedProperties.Count);
         for (int i = 0; i < myIndexedProperties.Count; i++)
         {
             if (myVertex.HasProperty(myIndexedProperties[i]))
             {
                 values[i] = myVertex.GetProperty(myIndexedProperties[i]);
             }
         }
         return new ListCollectionWrapper(values);
     }
     else if (myIndexedProperties.Count == 1)
     {
         if (myVertex.HasProperty(myIndexedProperties[0]))
         {
             return myVertex.GetProperty(myIndexedProperties[0]);
         }
         return null;
     }
     throw new ArgumentException("A unique definition must contain at least one element.");
 }

 private bool GetAttributeDotIsUserDefined(IVertex myVertex)
 {
     return myVertex.GetProperty<bool>((long)AttributeDefinitions.AttributeDotIsUserDefined);
 }

 /// <summary>
 /// Creates a search key by checking which properties are indexed.
 /// </summary>
 /// <param name="myIndexedProperties">Indexed properties</param>
 /// <param name="myVertex">Vertex which shall be stored in the index.</param>
 /// <returns>A search key for that index</returns>
 private static IComparable CreateIndexEntry(Int64 myIndexedProperty, IVertex myVertex)
 {
     if (myVertex.HasProperty(myIndexedProperty))
     {
         return myVertex.GetProperty(myIndexedProperty);
     }
     return null;
 }

 /// <summary>
 /// Creates a search key by checking which properties are indexed.
 /// </summary>
 /// <param name="myIndexedProperties">Indexed properties</param>
 /// <param name="myVertex">Vertex which shall be stored in the index.</param>
 /// <returns>A search key for that index</returns>
 private static IEnumerable<KeyValuePair<IComparable, long?>> CreateIndexEntries(IList<Int64> myIndexedProperties, IVertex myVertex)
 {
     if (myIndexedProperties.Count > 0)
     {
         var values = new List<KeyValuePair<IComparable,long?>>();
         for (int i = 0; i < myIndexedProperties.Count; i++)
         {
             if (myVertex.HasProperty(myIndexedProperties[i]))
             {
                 values.Add(new KeyValuePair<IComparable,long?>(myVertex.GetProperty(myIndexedProperties[i]), myVertex.VertexID));
             }
         }
         return values;
     }
     throw new ArgumentException("A unique definition must contain at least one element.");
 }