/// <inheritdoc/>
        public override int GetHashCode()
        {
            var hashCode = 2038336081;

            hashCode = hashCode *
                       -1521134295 + Handle.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + SymbolicName.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + NodeId.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + NodeClass.GetHashCode();
            hashCode = hashCode *
                       -1521134295 + BrowseName.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + DisplayName.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + Description.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + WriteMask.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + UserWriteMask.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + AccessRestrictions.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + RolePermissions.GetHashSafe();
            hashCode = hashCode *
                       -1521134295 + UserRolePermissions.GetHashSafe();
            return(hashCode);
        }
Example #2
0
        public override int GetHashCode()
        {
            int num  = string.IsNullOrEmpty(SymbolicName) ? 0 : SymbolicName.GetHashCode();
            int num2 = (Version == null) ? 0 : Version.GetHashCode();

            return(num ^ num2);
        }
Example #3
0
 public Builder(BuiltInFunctions.Predicates predicate, SymbolicName name)
 {
     Ensure.IsNotNull(predicate, "The predicate is required");
     Ensure.IsNotNull(name, "The name is required");
     _predicate = predicate;
     _name      = name;
 }
 public ListComprehension(
     SymbolicName variable,
     Expression listExpression,
     Where where,
     Expression listDefinition)
 {
     Variable       = variable;
     ListExpression = listExpression;
     Where          = where;
     ListDefinition = listDefinition;
 }
Example #5
0
        /// <summary>
        /// Adds the node to the address space <see cref="IAddressSpaceCreator" />.
        /// </summary>
        /// <param name="space">The address space as a tree of nodes.</param>
        protected override void AddNode2AddressSpace(IAddressSpaceCreator space)
        {
            int _addressSpaceIndex = space.AddNode2AddressSpace(this, SymbolicName.ToString());

            foreach (Reference item in this.References)
            {
                space.AddReference(_addressSpaceIndex, item.Wrapper.ReferenceType.XmlQualifiedName, item.Wrapper.IsInverse, item.Wrapper.TargetId.XmlQualifiedName);
            }
            IInstanceNodesCollection children = AddChildren(space, SymbolicName, _addressSpaceIndex, false);

            children.RegisterChildrenInAddressSpace();
            space.AddReference(_addressSpaceIndex, BuildInXmlQualifiedNames.HasSubtype, true, this.Wrapper.BaseType.ValueOrDefault);
        }
 public RelationshipDetails Named(SymbolicName newSymbolicName)
 {
     Ensure.IsNotNull(newSymbolicName, "Symbolic name is required.");
     return(new(Direction, newSymbolicName, Types, Length, Properties));
 }
 public RelationshipDetails Named(string newSymbolicName)
 {
     Ensure.IsNotNull(newSymbolicName, "Symbolic name is required.");
     return(Named(SymbolicName.Of(newSymbolicName)));
 }
 ///<summary>
 ///Returns a <see cref="T:System.String"/> that represents the current <see cref="UsbDeviceNotifyInfo"/>.
 ///</summary>
 ///
 ///<returns>
 ///A <see cref="System.String"/> that represents the current <see cref="UsbDeviceNotifyInfo"/>.
 ///</returns>
 public override string ToString()
 {
     return(SymbolicName.ToString());
 }
 public Builder(SymbolicName variable)
 {
     _variable = variable;
 }
Example #10
0
 public static IOngoingDefinitionWithVariable With(SymbolicName variable)
 {
     return(new Builder(variable));
 }
Example #11
0
 public SymbolicName AsName() => SymbolicName.Of(Alias);
Example #12
0
 public ListPredicate(SymbolicName variable, Expression listExpression, Where where)
 {
     Variable       = variable;
     ListExpression = listExpression;
     Where          = where;
 }
Example #13
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="variable"></param>
 /// <returns></returns>
 public static IOngoingListBasedPredicateFunction Single(string variable) =>
 Single(SymbolicName.Of(variable));
Example #14
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="variable"></param>
 /// <returns></returns>
 public static IOngoingListBasedPredicateFunction None(SymbolicName variable) =>
 new Builder(BuiltInFunctions.Predicates.None, variable);
Example #15
0
 /// <summary>
 /// Reuse an existing symbolic name to alias this expression
 /// </summary>
 /// <param name="alias"></param>
 /// <returns>An aliased expression.</returns>
 public AliasedExpression As(SymbolicName alias)
 {
     Ensure.IsNotNull(alias, "The alias may not be null.");
     return(As(alias.Value));
 }