int.Equals(object)

Here are the examples of the csharp api int.Equals(object) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

1492 Examples 7

19 Source : DestroyClonedVMTaskInfoProto.cs
with Apache License 2.0
from cohesity

public bool Equals(DestroyClonedVMTaskInfoProto input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.DatastoreNotUnmountedReason == input.DatastoreNotUnmountedReason ||
                    (this.DatastoreNotUnmountedReason != null &&
                    this.DatastoreNotUnmountedReason.Equals(input.DatastoreNotUnmountedReason))
                ) && 
                (
                    this.DatastoreUnmounted == input.DatastoreUnmounted ||
                    (this.DatastoreUnmounted != null &&
                    this.DatastoreUnmounted.Equals(input.DatastoreUnmounted))
                ) && 
                (
                    this.DestroyClonedEnreplacedyInfoVec == input.DestroyClonedEnreplacedyInfoVec ||
                    this.DestroyClonedEnreplacedyInfoVec != null &&
                    input.DestroyClonedEnreplacedyInfoVec != null &&
                    this.DestroyClonedEnreplacedyInfoVec.SequenceEqual(input.DestroyClonedEnreplacedyInfoVec)
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                ) && 
                (
                    this.ViewDeleted == input.ViewDeleted ||
                    (this.ViewDeleted != null &&
                    this.ViewDeleted.Equals(input.ViewDeleted))
                );
        }

19 Source : DeviceTree.cs
with Apache License 2.0
from cohesity

public bool Equals(DeviceTree input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.ChildVec == input.ChildVec ||
                    this.ChildVec != null &&
                    input.ChildVec != null &&
                    this.ChildVec.SequenceEqual(input.ChildVec)
                ) && 
                (
                    this.DeviceId == input.DeviceId ||
                    (this.DeviceId != null &&
                    this.DeviceId.Equals(input.DeviceId))
                ) && 
                (
                    this.DeviceLength == input.DeviceLength ||
                    (this.DeviceLength != null &&
                    this.DeviceLength.Equals(input.DeviceLength))
                ) && 
                (
                    this.StripeSize == input.StripeSize ||
                    (this.StripeSize != null &&
                    this.StripeSize.Equals(input.StripeSize))
                ) && 
                (
                    this.ThinPoolChunkSize == input.ThinPoolChunkSize ||
                    (this.ThinPoolChunkSize != null &&
                    this.ThinPoolChunkSize.Equals(input.ThinPoolChunkSize))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                );
        }

19 Source : DeviceTreeChildDevice.cs
with Apache License 2.0
from cohesity

public bool Equals(DeviceTreeChildDevice input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Device == input.Device ||
                    (this.Device != null &&
                    this.Device.Equals(input.Device))
                ) && 
                (
                    this.DeviceType == input.DeviceType ||
                    (this.DeviceType != null &&
                    this.DeviceType.Equals(input.DeviceType))
                ) && 
                (
                    this.ParreplacedionSlice == input.ParreplacedionSlice ||
                    (this.ParreplacedionSlice != null &&
                    this.ParreplacedionSlice.Equals(input.ParreplacedionSlice))
                );
        }

19 Source : DeviceTreeDetails.cs
with Apache License 2.0
from cohesity

public bool Equals(DeviceTreeDetails input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.CombineMethod == input.CombineMethod ||
                    this.CombineMethod.Equals(input.CombineMethod)
                ) && 
                (
                    this.DeviceLength == input.DeviceLength ||
                    (this.DeviceLength != null &&
                    this.DeviceLength.Equals(input.DeviceLength))
                ) && 
                (
                    this.DeviceNodes == input.DeviceNodes ||
                    this.DeviceNodes != null &&
                    input.DeviceNodes != null &&
                    this.DeviceNodes.SequenceEqual(input.DeviceNodes)
                ) && 
                (
                    this.StripeSize == input.StripeSize ||
                    (this.StripeSize != null &&
                    this.StripeSize.Equals(input.StripeSize))
                );
        }

19 Source : DeviceTreePartitionSlice.cs
with Apache License 2.0
from cohesity

public bool Equals(DeviceTreeParreplacedionSlice input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.DiskFileName == input.DiskFileName ||
                    (this.DiskFileName != null &&
                    this.DiskFileName.Equals(input.DiskFileName))
                ) && 
                (
                    this.Length == input.Length ||
                    (this.Length != null &&
                    this.Length.Equals(input.Length))
                ) && 
                (
                    this.LvmDataOffset == input.LvmDataOffset ||
                    (this.LvmDataOffset != null &&
                    this.LvmDataOffset.Equals(input.LvmDataOffset))
                ) && 
                (
                    this.Offset == input.Offset ||
                    (this.Offset != null &&
                    this.Offset.Equals(input.Offset))
                ) && 
                (
                    this.ParreplacedionNumber == input.ParreplacedionNumber ||
                    (this.ParreplacedionNumber != null &&
                    this.ParreplacedionNumber.Equals(input.ParreplacedionNumber))
                );
        }

19 Source : DSESolrInfo.cs
with Apache License 2.0
from cohesity

public bool Equals(DSESolrInfo input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.SolrNodeVec == input.SolrNodeVec ||
                    this.SolrNodeVec != null &&
                    input.SolrNodeVec != null &&
                    this.SolrNodeVec.SequenceEqual(input.SolrNodeVec)
                ) && 
                (
                    this.SolrPort == input.SolrPort ||
                    (this.SolrPort != null &&
                    this.SolrPort.Equals(input.SolrPort))
                );
        }

19 Source : ElastifileContainer.cs
with Apache License 2.0
from cohesity

public bool Equals(ElastifileContainer input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.IsNfsInterface == input.IsNfsInterface ||
                    (this.IsNfsInterface != null &&
                    this.IsNfsInterface.Equals(input.IsNfsInterface))
                ) && 
                (
                    this.IsSmbInterface == input.IsSmbInterface ||
                    (this.IsSmbInterface != null &&
                    this.IsSmbInterface.Equals(input.IsSmbInterface))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Protocols == input.Protocols ||
                    this.Protocols.SequenceEqual(input.Protocols)
                ) && 
                (
                    this.UsedBytes == input.UsedBytes ||
                    (this.UsedBytes != null &&
                    this.UsedBytes.Equals(input.UsedBytes))
                ) && 
                (
                    this.Uuid == input.Uuid ||
                    (this.Uuid != null &&
                    this.Uuid.Equals(input.Uuid))
                );
        }

19 Source : ExchangeProtectionSource.cs
with Apache License 2.0
from cohesity

public bool Equals(ExchangeProtectionSource input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.DagInfo == input.DagInfo ||
                    (this.DagInfo != null &&
                    this.DagInfo.Equals(input.DagInfo))
                ) && 
                (
                    this.ApplicationServerInfo == input.ApplicationServerInfo ||
                    (this.ApplicationServerInfo != null &&
                    this.ApplicationServerInfo.Equals(input.ApplicationServerInfo))
                ) && 
                (
                    this.DagDatabaseCopyInfo == input.DagDatabaseCopyInfo ||
                    (this.DagDatabaseCopyInfo != null &&
                    this.DagDatabaseCopyInfo.Equals(input.DagDatabaseCopyInfo))
                ) && 
                (
                    this.DagDatabaseInfo == input.DagDatabaseInfo ||
                    (this.DagDatabaseInfo != null &&
                    this.DagDatabaseInfo.Equals(input.DagDatabaseInfo))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.OwnerId == input.OwnerId ||
                    (this.OwnerId != null &&
                    this.OwnerId.Equals(input.OwnerId))
                ) && 
                (
                    this.StandaloneDatabaseCopyInfo == input.StandaloneDatabaseCopyInfo ||
                    (this.StandaloneDatabaseCopyInfo != null &&
                    this.StandaloneDatabaseCopyInfo.Equals(input.StandaloneDatabaseCopyInfo))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                ) && 
                (
                    this.Uuid == input.Uuid ||
                    (this.Uuid != null &&
                    this.Uuid.Equals(input.Uuid))
                );
        }

19 Source : EncryptionConfiguration.cs
with Apache License 2.0
from cohesity

public bool Equals(EncryptionConfiguration input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.EnableEncryption == input.EnableEncryption ||
                    (this.EnableEncryption != null &&
                    this.EnableEncryption.Equals(input.EnableEncryption))
                ) && 
                (
                    this.EnableFipsMode == input.EnableFipsMode ||
                    (this.EnableFipsMode != null &&
                    this.EnableFipsMode.Equals(input.EnableFipsMode))
                ) && 
                (
                    this.RotationPeriod == input.RotationPeriod ||
                    (this.RotationPeriod != null &&
                    this.RotationPeriod.Equals(input.RotationPeriod))
                );
        }

19 Source : EntitySchemaProto.cs
with Apache License 2.0
from cohesity

public bool Equals(EnreplacedySchemaProto input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AttributesDescriptor == input.AttributesDescriptor ||
                    (this.AttributesDescriptor != null &&
                    this.AttributesDescriptor.Equals(input.AttributesDescriptor))
                ) && 
                (
                    this.EnableRollup == input.EnableRollup ||
                    (this.EnableRollup != null &&
                    this.EnableRollup.Equals(input.EnableRollup))
                ) && 
                (
                    this.FlushIntervalSecs == input.FlushIntervalSecs ||
                    (this.FlushIntervalSecs != null &&
                    this.FlushIntervalSecs.Equals(input.FlushIntervalSecs))
                ) && 
                (
                    this.IsInternalSchema == input.IsInternalSchema ||
                    (this.IsInternalSchema != null &&
                    this.IsInternalSchema.Equals(input.IsInternalSchema))
                ) && 
                (
                    this.LargestFlushIntervalSecs == input.LargestFlushIntervalSecs ||
                    (this.LargestFlushIntervalSecs != null &&
                    this.LargestFlushIntervalSecs.Equals(input.LargestFlushIntervalSecs))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.RollupGranularityVec == input.RollupGranularityVec ||
                    this.RollupGranularityVec != null &&
                    input.RollupGranularityVec != null &&
                    this.RollupGranularityVec.SequenceEqual(input.RollupGranularityVec)
                ) && 
                (
                    this.SchemaDescriptiveName == input.SchemaDescriptiveName ||
                    (this.SchemaDescriptiveName != null &&
                    this.SchemaDescriptiveName.Equals(input.SchemaDescriptiveName))
                ) && 
                (
                    this.SchemaHelpText == input.SchemaHelpText ||
                    (this.SchemaHelpText != null &&
                    this.SchemaHelpText.Equals(input.SchemaHelpText))
                ) && 
                (
                    this.TimeSeriesDescriptorVec == input.TimeSeriesDescriptorVec ||
                    this.TimeSeriesDescriptorVec != null &&
                    input.TimeSeriesDescriptorVec != null &&
                    this.TimeSeriesDescriptorVec.SequenceEqual(input.TimeSeriesDescriptorVec)
                ) && 
                (
                    this.TimeToLiveSecs == input.TimeToLiveSecs ||
                    (this.TimeToLiveSecs != null &&
                    this.TimeToLiveSecs.Equals(input.TimeToLiveSecs))
                ) && 
                (
                    this.Version == input.Version ||
                    (this.Version != null &&
                    this.Version.Equals(input.Version))
                );
        }

19 Source : EntitySchemaProtoAttributesDescriptor.cs
with Apache License 2.0
from cohesity

public bool Equals(EnreplacedySchemaProtoAttributesDescriptor input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AttributeVec == input.AttributeVec ||
                    this.AttributeVec != null &&
                    input.AttributeVec != null &&
                    this.AttributeVec.SequenceEqual(input.AttributeVec)
                ) && 
                (
                    this.KeyAttributeNameIndex == input.KeyAttributeNameIndex ||
                    (this.KeyAttributeNameIndex != null &&
                    this.KeyAttributeNameIndex.Equals(input.KeyAttributeNameIndex))
                );
        }

19 Source : EntitySchemaProtoGranularity.cs
with Apache License 2.0
from cohesity

public bool Equals(EnreplacedySchemaProtoGranularity input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.RollupIntervalSecs == input.RollupIntervalSecs ||
                    (this.RollupIntervalSecs != null &&
                    this.RollupIntervalSecs.Equals(input.RollupIntervalSecs))
                ) && 
                (
                    this.TimeToLiveSecs == input.TimeToLiveSecs ||
                    (this.TimeToLiveSecs != null &&
                    this.TimeToLiveSecs.Equals(input.TimeToLiveSecs))
                );
        }

19 Source : EntitySchemaProtoKeyValueDescriptor.cs
with Apache License 2.0
from cohesity

public bool Equals(EnreplacedySchemaProtoKeyValueDescriptor input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.KeyName == input.KeyName ||
                    (this.KeyName != null &&
                    this.KeyName.Equals(input.KeyName))
                ) && 
                (
                    this.ValueType == input.ValueType ||
                    (this.ValueType != null &&
                    this.ValueType.Equals(input.ValueType))
                );
        }

19 Source : EntitySchemaProtoTimeSeriesDescriptor.cs
with Apache License 2.0
from cohesity

public bool Equals(EnreplacedySchemaProtoTimeSeriesDescriptor input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.MetricDescriptiveName == input.MetricDescriptiveName ||
                    (this.MetricDescriptiveName != null &&
                    this.MetricDescriptiveName.Equals(input.MetricDescriptiveName))
                ) && 
                (
                    this.MetricName == input.MetricName ||
                    (this.MetricName != null &&
                    this.MetricName.Equals(input.MetricName))
                ) && 
                (
                    this.MetricUnit == input.MetricUnit ||
                    (this.MetricUnit != null &&
                    this.MetricUnit.Equals(input.MetricUnit))
                ) && 
                (
                    this.RawMetricPublishIntervalHintSecs == input.RawMetricPublishIntervalHintSecs ||
                    (this.RawMetricPublishIntervalHintSecs != null &&
                    this.RawMetricPublishIntervalHintSecs.Equals(input.RawMetricPublishIntervalHintSecs))
                ) && 
                (
                    this.TimeToLiveSecs == input.TimeToLiveSecs ||
                    (this.TimeToLiveSecs != null &&
                    this.TimeToLiveSecs.Equals(input.TimeToLiveSecs))
                ) && 
                (
                    this.ValueType == input.ValueType ||
                    (this.ValueType != null &&
                    this.ValueType.Equals(input.ValueType))
                );
        }

19 Source : EntitySchemaProtoTimeSeriesDescriptorMetricUnit.cs
with Apache License 2.0
from cohesity

public bool Equals(EnreplacedySchemaProtoTimeSeriesDescriptorMetricUnit input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                );
        }

19 Source : ErasureCodingInfo.cs
with Apache License 2.0
from cohesity

public bool Equals(ErasureCodingInfo input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Algorithm == input.Algorithm ||
                    this.Algorithm.Equals(input.Algorithm)
                ) && 
                (
                    this.ErasureCodingEnabled == input.ErasureCodingEnabled ||
                    (this.ErasureCodingEnabled != null &&
                    this.ErasureCodingEnabled.Equals(input.ErasureCodingEnabled))
                ) && 
                (
                    this.InlineErasureCoding == input.InlineErasureCoding ||
                    (this.InlineErasureCoding != null &&
                    this.InlineErasureCoding.Equals(input.InlineErasureCoding))
                ) && 
                (
                    this.NumCodedStripes == input.NumCodedStripes ||
                    (this.NumCodedStripes != null &&
                    this.NumCodedStripes.Equals(input.NumCodedStripes))
                ) && 
                (
                    this.NumDataStripes == input.NumDataStripes ||
                    (this.NumDataStripes != null &&
                    this.NumDataStripes.Equals(input.NumDataStripes))
                );
        }

19 Source : Error.cs
with Apache License 2.0
from cohesity

public bool Equals(Error input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.ErrorCode == input.ErrorCode ||
                    (this.ErrorCode != null &&
                    this.ErrorCode.Equals(input.ErrorCode))
                ) && 
                (
                    this.ErrorMessage == input.ErrorMessage ||
                    (this.ErrorMessage != null &&
                    this.ErrorMessage.Equals(input.ErrorMessage))
                );
        }

19 Source : ErrorProto.cs
with Apache License 2.0
from cohesity

public bool Equals(ErrorProto input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.ErrorMsg == input.ErrorMsg ||
                    (this.ErrorMsg != null &&
                    this.ErrorMsg.Equals(input.ErrorMsg))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                );
        }

19 Source : ExtendedRetentionPolicy.cs
with Apache License 2.0
from cohesity

public bool Equals(ExtendedRetentionPolicy input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.BackupRunType == input.BackupRunType ||
                    this.BackupRunType.Equals(input.BackupRunType)
                ) && 
                (
                    this.DaysToKeep == input.DaysToKeep ||
                    (this.DaysToKeep != null &&
                    this.DaysToKeep.Equals(input.DaysToKeep))
                ) && 
                (
                    this.Multiplier == input.Multiplier ||
                    (this.Multiplier != null &&
                    this.Multiplier.Equals(input.Multiplier))
                ) && 
                (
                    this.Periodicity == input.Periodicity ||
                    this.Periodicity.Equals(input.Periodicity)
                );
        }

19 Source : FileFstatResult.cs
with Apache License 2.0
from cohesity

public bool Equals(FileFstatResult input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Cookie == input.Cookie ||
                    (this.Cookie != null &&
                    this.Cookie.Equals(input.Cookie))
                ) && 
                (
                    this.FstatInfo == input.FstatInfo ||
                    (this.FstatInfo != null &&
                    this.FstatInfo.Equals(input.FstatInfo))
                );
        }

19 Source : FileLevelDataLockConfig.cs
with Apache License 2.0
from cohesity

public bool Equals(FileLevelDataLockConfig input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AutoLockAfterDurationIdle == input.AutoLockAfterDurationIdle ||
                    (this.AutoLockAfterDurationIdle != null &&
                    this.AutoLockAfterDurationIdle.Equals(input.AutoLockAfterDurationIdle))
                ) && 
                (
                    this.DefaultFileRetentionDurationMsecs == input.DefaultFileRetentionDurationMsecs ||
                    (this.DefaultFileRetentionDurationMsecs != null &&
                    this.DefaultFileRetentionDurationMsecs.Equals(input.DefaultFileRetentionDurationMsecs))
                ) && 
                (
                    this.ExpiryTimestampMsecs == input.ExpiryTimestampMsecs ||
                    (this.ExpiryTimestampMsecs != null &&
                    this.ExpiryTimestampMsecs.Equals(input.ExpiryTimestampMsecs))
                ) && 
                (
                    this.LockingProtocol == input.LockingProtocol ||
                    this.LockingProtocol.Equals(input.LockingProtocol)
                ) && 
                (
                    this.MaxRetentionDurationMsecs == input.MaxRetentionDurationMsecs ||
                    (this.MaxRetentionDurationMsecs != null &&
                    this.MaxRetentionDurationMsecs.Equals(input.MaxRetentionDurationMsecs))
                ) && 
                (
                    this.MinRetentionDurationMsecs == input.MinRetentionDurationMsecs ||
                    (this.MinRetentionDurationMsecs != null &&
                    this.MinRetentionDurationMsecs.Equals(input.MinRetentionDurationMsecs))
                ) && 
                (
                    this.Mode == input.Mode ||
                    this.Mode.Equals(input.Mode)
                );
        }

19 Source : FileLockStatus.cs
with Apache License 2.0
from cohesity

public bool Equals(FileLockStatus input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.ExpiryTimestampMsecs == input.ExpiryTimestampMsecs ||
                    (this.ExpiryTimestampMsecs != null &&
                    this.ExpiryTimestampMsecs.Equals(input.ExpiryTimestampMsecs))
                ) && 
                (
                    this.HoldTimestampMsecs == input.HoldTimestampMsecs ||
                    (this.HoldTimestampMsecs != null &&
                    this.HoldTimestampMsecs.Equals(input.HoldTimestampMsecs))
                ) && 
                (
                    this.LockTimestampMsecs == input.LockTimestampMsecs ||
                    (this.LockTimestampMsecs != null &&
                    this.LockTimestampMsecs.Equals(input.LockTimestampMsecs))
                ) && 
                (
                    this.Mode == input.Mode ||
                    this.Mode.Equals(input.Mode)
                ) && 
                (
                    this.State == input.State ||
                    (this.State != null &&
                    this.State.Equals(input.State))
                );
        }

19 Source : FilerAuditLogConfiguration.cs
with Apache License 2.0
from cohesity

public bool Equals(FilerAuditLogConfiguration input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Enabled == input.Enabled ||
                    (this.Enabled != null &&
                    this.Enabled.Equals(input.Enabled))
                ) && 
                (
                    this.RetentionPeriodDays == input.RetentionPeriodDays ||
                    (this.RetentionPeriodDays != null &&
                    this.RetentionPeriodDays.Equals(input.RetentionPeriodDays))
                );
        }

19 Source : FileStatInfo.cs
with Apache License 2.0
from cohesity

public bool Equals(FileStatInfo input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.MtimeUsecs == input.MtimeUsecs ||
                    (this.MtimeUsecs != null &&
                    this.MtimeUsecs.Equals(input.MtimeUsecs))
                ) && 
                (
                    this.Size == input.Size ||
                    (this.Size != null &&
                    this.Size.Equals(input.Size))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                );
        }

19 Source : FileStubbingParams.cs
with Apache License 2.0
from cohesity

public bool Equals(FileStubbingParams input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.ColdFileWindow == input.ColdFileWindow ||
                    (this.ColdFileWindow != null &&
                    this.ColdFileWindow.Equals(input.ColdFileWindow))
                ) && 
                (
                    this.DeleteOrphanData == input.DeleteOrphanData ||
                    (this.DeleteOrphanData != null &&
                    this.DeleteOrphanData.Equals(input.DeleteOrphanData))
                ) && 
                (
                    this.FileSelectPolicy == input.FileSelectPolicy ||
                    (this.FileSelectPolicy != null &&
                    this.FileSelectPolicy.Equals(input.FileSelectPolicy))
                ) && 
                (
                    this.FileSize == input.FileSize ||
                    (this.FileSize != null &&
                    this.FileSize.Equals(input.FileSize))
                ) && 
                (
                    this.FileSizePolicy == input.FileSizePolicy ||
                    (this.FileSizePolicy != null &&
                    this.FileSizePolicy.Equals(input.FileSizePolicy))
                ) && 
                (
                    this.FilteringPolicy == input.FilteringPolicy ||
                    (this.FilteringPolicy != null &&
                    this.FilteringPolicy.Equals(input.FilteringPolicy))
                ) && 
                (
                    this.MigrateWithoutStub == input.MigrateWithoutStub ||
                    (this.MigrateWithoutStub != null &&
                    this.MigrateWithoutStub.Equals(input.MigrateWithoutStub))
                ) && 
                (
                    this.NfsMountPath == input.NfsMountPath ||
                    (this.NfsMountPath != null &&
                    this.NfsMountPath.Equals(input.NfsMountPath))
                ) && 
                (
                    this.TargetViewName == input.TargetViewName ||
                    (this.TargetViewName != null &&
                    this.TargetViewName.Equals(input.TargetViewName))
                );
        }

19 Source : FileUptieringParams.cs
with Apache License 2.0
from cohesity

public bool Equals(FileUptieringParams input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.FileSelectPolicy == input.FileSelectPolicy ||
                    (this.FileSelectPolicy != null &&
                    this.FileSelectPolicy.Equals(input.FileSelectPolicy))
                ) && 
                (
                    this.FileSize == input.FileSize ||
                    (this.FileSize != null &&
                    this.FileSize.Equals(input.FileSize))
                ) && 
                (
                    this.FileSizePolicy == input.FileSizePolicy ||
                    (this.FileSizePolicy != null &&
                    this.FileSizePolicy.Equals(input.FileSizePolicy))
                ) && 
                (
                    this.HotFileWindow == input.HotFileWindow ||
                    (this.HotFileWindow != null &&
                    this.HotFileWindow.Equals(input.HotFileWindow))
                ) && 
                (
                    this.NumFileAccess == input.NumFileAccess ||
                    (this.NumFileAccess != null &&
                    this.NumFileAccess.Equals(input.NumFileAccess))
                ) && 
                (
                    this.SourceViewName == input.SourceViewName ||
                    (this.SourceViewName != null &&
                    this.SourceViewName.Equals(input.SourceViewName))
                );
        }

19 Source : FlashBladeNetworkInterface.cs
with Apache License 2.0
from cohesity

public bool Equals(FlashBladeNetworkInterface input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.IpAddress == input.IpAddress ||
                    (this.IpAddress != null &&
                    this.IpAddress.Equals(input.IpAddress))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Vlan == input.Vlan ||
                    (this.Vlan != null &&
                    this.Vlan.Equals(input.Vlan))
                );
        }

19 Source : FreeNodeInformation.cs
with Apache License 2.0
from cohesity

public bool Equals(FreeNodeInformation input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.ChreplacedisSerial == input.ChreplacedisSerial ||
                    (this.ChreplacedisSerial != null &&
                    this.ChreplacedisSerial.Equals(input.ChreplacedisSerial))
                ) && 
                (
                    this.ConnectedTo == input.ConnectedTo ||
                    (this.ConnectedTo != null &&
                    this.ConnectedTo.Equals(input.ConnectedTo))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.Ip == input.Ip ||
                    (this.Ip != null &&
                    this.Ip.Equals(input.Ip))
                ) && 
                (
                    this.IpmiIp == input.IpmiIp ||
                    (this.IpmiIp != null &&
                    this.IpmiIp.Equals(input.IpmiIp))
                ) && 
                (
                    this.NodeSerial == input.NodeSerial ||
                    (this.NodeSerial != null &&
                    this.NodeSerial.Equals(input.NodeSerial))
                ) && 
                (
                    this.NodeUiSlot == input.NodeUiSlot ||
                    (this.NodeUiSlot != null &&
                    this.NodeUiSlot.Equals(input.NodeUiSlot))
                ) && 
                (
                    this.NumSlotsInChreplacedis == input.NumSlotsInChreplacedis ||
                    (this.NumSlotsInChreplacedis != null &&
                    this.NumSlotsInChreplacedis.Equals(input.NumSlotsInChreplacedis))
                ) && 
                (
                    this.ProductModel == input.ProductModel ||
                    (this.ProductModel != null &&
                    this.ProductModel.Equals(input.ProductModel))
                ) && 
                (
                    this.SlotNumber == input.SlotNumber ||
                    (this.SlotNumber != null &&
                    this.SlotNumber.Equals(input.SlotNumber))
                ) && 
                (
                    this.SoftwareVersion == input.SoftwareVersion ||
                    (this.SoftwareVersion != null &&
                    this.SoftwareVersion.Equals(input.SoftwareVersion))
                );
        }

19 Source : GetMapReduceAppRunsParams.cs
with Apache License 2.0
from cohesity

public bool Equals(GetMapReduceAppRunsParams input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AppId == input.AppId ||
                    (this.AppId != null &&
                    this.AppId.Equals(input.AppId))
                ) && 
                (
                    this.AppInstanceId == input.AppInstanceId ||
                    (this.AppInstanceId != null &&
                    this.AppInstanceId.Equals(input.AppInstanceId))
                ) && 
                (
                    this.IncludeDetails == input.IncludeDetails ||
                    (this.IncludeDetails != null &&
                    this.IncludeDetails.Equals(input.IncludeDetails))
                ) && 
                (
                    this.LastNumInstances == input.LastNumInstances ||
                    (this.LastNumInstances != null &&
                    this.LastNumInstances.Equals(input.LastNumInstances))
                ) && 
                (
                    this.MaxRunEndTimeInSecs == input.MaxRunEndTimeInSecs ||
                    (this.MaxRunEndTimeInSecs != null &&
                    this.MaxRunEndTimeInSecs.Equals(input.MaxRunEndTimeInSecs))
                ) && 
                (
                    this.MaxRunStartTimeInSecs == input.MaxRunStartTimeInSecs ||
                    (this.MaxRunStartTimeInSecs != null &&
                    this.MaxRunStartTimeInSecs.Equals(input.MaxRunStartTimeInSecs))
                ) && 
                (
                    this.MinRunEndTimeInSecs == input.MinRunEndTimeInSecs ||
                    (this.MinRunEndTimeInSecs != null &&
                    this.MinRunEndTimeInSecs.Equals(input.MinRunEndTimeInSecs))
                ) && 
                (
                    this.MinRunStartTimeInSecs == input.MinRunStartTimeInSecs ||
                    (this.MinRunStartTimeInSecs != null &&
                    this.MinRunStartTimeInSecs.Equals(input.MinRunStartTimeInSecs))
                ) && 
                (
                    this.PageSize == input.PageSize ||
                    (this.PageSize != null &&
                    this.PageSize.Equals(input.PageSize))
                ) && 
                (
                    this.RunStatus == input.RunStatus ||
                    (this.RunStatus != null &&
                    this.RunStatus.Equals(input.RunStatus))
                ) && 
                (
                    this.StartOffset == input.StartOffset ||
                    (this.StartOffset != null &&
                    this.StartOffset.Equals(input.StartOffset))
                );
        }

19 Source : GpfsCluster.cs
with Apache License 2.0
from cohesity

public bool Equals(GpfsCluster input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.CesAddresses == input.CesAddresses ||
                    this.CesAddresses != null &&
                    input.CesAddresses != null &&
                    this.CesAddresses.SequenceEqual(input.CesAddresses)
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.PrimaryServer == input.PrimaryServer ||
                    (this.PrimaryServer != null &&
                    this.PrimaryServer.Equals(input.PrimaryServer))
                );
        }

19 Source : GpfsFileset.cs
with Apache License 2.0
from cohesity

public bool Equals(GpfsFileset input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Path == input.Path ||
                    (this.Path != null &&
                    this.Path.Equals(input.Path))
                ) && 
                (
                    this.Protocols == input.Protocols ||
                    this.Protocols.SequenceEqual(input.Protocols)
                );
        }

19 Source : GranularityBucket.cs
with Apache License 2.0
from cohesity

public bool Equals(GranularityBucket input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Granularity == input.Granularity ||
                    (this.Granularity != null &&
                    this.Granularity.Equals(input.Granularity))
                ) && 
                (
                    this.Multiplier == input.Multiplier ||
                    (this.Multiplier != null &&
                    this.Multiplier.Equals(input.Multiplier))
                );
        }

19 Source : HdfsConnectParams.cs
with Apache License 2.0
from cohesity

public bool Equals(HdfsConnectParams input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.HadoopDistribution == input.HadoopDistribution ||
                    this.HadoopDistribution.Equals(input.HadoopDistribution)
                ) && 
                (
                    this.HadoopVersion == input.HadoopVersion ||
                    (this.HadoopVersion != null &&
                    this.HadoopVersion.Equals(input.HadoopVersion))
                ) && 
                (
                    this.Namenode == input.Namenode ||
                    (this.Namenode != null &&
                    this.Namenode.Equals(input.Namenode))
                ) && 
                (
                    this.Port == input.Port ||
                    (this.Port != null &&
                    this.Port.Equals(input.Port))
                );
        }

19 Source : InterfaceGroup.cs
with Apache License 2.0
from cohesity

public bool Equals(InterfaceGroup input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.ModelInterfaceLists == input.ModelInterfaceLists ||
                    this.ModelInterfaceLists != null &&
                    input.ModelInterfaceLists != null &&
                    this.ModelInterfaceLists.SequenceEqual(input.ModelInterfaceLists)
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.NetworkParams == input.NetworkParams ||
                    (this.NetworkParams != null &&
                    this.NetworkParams.Equals(input.NetworkParams))
                );
        }

19 Source : IpConfig.cs
with Apache License 2.0
from cohesity

public bool Equals(IpConfig input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.InterfaceName == input.InterfaceName ||
                    (this.InterfaceName != null &&
                    this.InterfaceName.Equals(input.InterfaceName))
                ) && 
                (
                    this.IpFamily == input.IpFamily ||
                    (this.IpFamily != null &&
                    this.IpFamily.Equals(input.IpFamily))
                ) && 
                (
                    this.Ips == input.Ips ||
                    this.Ips != null &&
                    input.Ips != null &&
                    this.Ips.SequenceEqual(input.Ips)
                ) && 
                (
                    this.NodeIds == input.NodeIds ||
                    this.NodeIds != null &&
                    input.NodeIds != null &&
                    this.NodeIds.SequenceEqual(input.NodeIds)
                ) && 
                (
                    this.Role == input.Role ||
                    (this.Role != null &&
                    this.Role.Equals(input.Role))
                ) && 
                (
                    this.SubnetGateway == input.SubnetGateway ||
                    (this.SubnetGateway != null &&
                    this.SubnetGateway.Equals(input.SubnetGateway))
                ) && 
                (
                    this.SubnetMaskBits == input.SubnetMaskBits ||
                    (this.SubnetMaskBits != null &&
                    this.SubnetMaskBits.Equals(input.SubnetMaskBits))
                );
        }

19 Source : IpUnconfig.cs
with Apache License 2.0
from cohesity

public bool Equals(IpUnconfig input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.IpFamily == input.IpFamily ||
                    (this.IpFamily != null &&
                    this.IpFamily.Equals(input.IpFamily))
                ) && 
                (
                    this.InterfaceName == input.InterfaceName ||
                    (this.InterfaceName != null &&
                    this.InterfaceName.Equals(input.InterfaceName))
                ) && 
                (
                    this.NodeIds == input.NodeIds ||
                    this.NodeIds != null &&
                    input.NodeIds != null &&
                    this.NodeIds.SequenceEqual(input.NodeIds)
                );
        }

19 Source : IscsiSanPort.cs
with Apache License 2.0
from cohesity

public bool Equals(IscsiSanPort input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.IpAddress == input.IpAddress ||
                    (this.IpAddress != null &&
                    this.IpAddress.Equals(input.IpAddress))
                ) && 
                (
                    this.Iqn == input.Iqn ||
                    (this.Iqn != null &&
                    this.Iqn.Equals(input.Iqn))
                ) && 
                (
                    this.TcpPort == input.TcpPort ||
                    (this.TcpPort != null &&
                    this.TcpPort.Equals(input.TcpPort))
                );
        }

19 Source : JobRunsTile.cs
with Apache License 2.0
from cohesity

public bool Equals(JobRunsTile input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.LastDayNumJobErrors == input.LastDayNumJobErrors ||
                    (this.LastDayNumJobErrors != null &&
                    this.LastDayNumJobErrors.Equals(input.LastDayNumJobErrors))
                ) && 
                (
                    this.LastDayNumJobRuns == input.LastDayNumJobRuns ||
                    (this.LastDayNumJobRuns != null &&
                    this.LastDayNumJobRuns.Equals(input.LastDayNumJobRuns))
                ) && 
                (
                    this.LastDayNumJobSlaViolations == input.LastDayNumJobSlaViolations ||
                    (this.LastDayNumJobSlaViolations != null &&
                    this.LastDayNumJobSlaViolations.Equals(input.LastDayNumJobSlaViolations))
                ) && 
                (
                    this.NumJobRunning == input.NumJobRunning ||
                    (this.NumJobRunning != null &&
                    this.NumJobRunning.Equals(input.NumJobRunning))
                ) && 
                (
                    this.ObjectsProtectedByPolicy == input.ObjectsProtectedByPolicy ||
                    this.ObjectsProtectedByPolicy != null &&
                    input.ObjectsProtectedByPolicy != null &&
                    this.ObjectsProtectedByPolicy.SequenceEqual(input.ObjectsProtectedByPolicy)
                );
        }

19 Source : HealthTile.cs
with Apache License 2.0
from cohesity

public bool Equals(HealthTile input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.CapacityBytes == input.CapacityBytes ||
                    (this.CapacityBytes != null &&
                    this.CapacityBytes.Equals(input.CapacityBytes))
                ) && 
                (
                    this.ClusterCloudUsageBytes == input.ClusterCloudUsageBytes ||
                    (this.ClusterCloudUsageBytes != null &&
                    this.ClusterCloudUsageBytes.Equals(input.ClusterCloudUsageBytes))
                ) && 
                (
                    this.LastDayAlerts == input.LastDayAlerts ||
                    this.LastDayAlerts != null &&
                    input.LastDayAlerts != null &&
                    this.LastDayAlerts.SequenceEqual(input.LastDayAlerts)
                ) && 
                (
                    this.LastDayNumCriticals == input.LastDayNumCriticals ||
                    (this.LastDayNumCriticals != null &&
                    this.LastDayNumCriticals.Equals(input.LastDayNumCriticals))
                ) && 
                (
                    this.LastDayNumWarnings == input.LastDayNumWarnings ||
                    (this.LastDayNumWarnings != null &&
                    this.LastDayNumWarnings.Equals(input.LastDayNumWarnings))
                ) && 
                (
                    this.NumNodes == input.NumNodes ||
                    (this.NumNodes != null &&
                    this.NumNodes.Equals(input.NumNodes))
                ) && 
                (
                    this.NumNodesWithIssues == input.NumNodesWithIssues ||
                    (this.NumNodesWithIssues != null &&
                    this.NumNodesWithIssues.Equals(input.NumNodesWithIssues))
                ) && 
                (
                    this.PercentFull == input.PercentFull ||
                    (this.PercentFull != null &&
                    this.PercentFull.Equals(input.PercentFull))
                ) && 
                (
                    this.RawUsedBytes == input.RawUsedBytes ||
                    (this.RawUsedBytes != null &&
                    this.RawUsedBytes.Equals(input.RawUsedBytes))
                );
        }

19 Source : HiveConnectParams.cs
with Apache License 2.0
from cohesity

public bool Equals(HiveConnectParams input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Metastore == input.Metastore ||
                    (this.Metastore != null &&
                    this.Metastore.Equals(input.Metastore))
                ) && 
                (
                    this.ThriftPort == input.ThriftPort ||
                    (this.ThriftPort != null &&
                    this.ThriftPort.Equals(input.ThriftPort))
                );
        }

19 Source : HyperVBackupEnvParams.cs
with Apache License 2.0
from cohesity

public bool Equals(HyperVBackupEnvParams input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AllowCrashConsistentSnapshot == input.AllowCrashConsistentSnapshot ||
                    (this.AllowCrashConsistentSnapshot != null &&
                    this.AllowCrashConsistentSnapshot.Equals(input.AllowCrashConsistentSnapshot))
                ) && 
                (
                    this.BackupJobType == input.BackupJobType ||
                    (this.BackupJobType != null &&
                    this.BackupJobType.Equals(input.BackupJobType))
                );
        }

19 Source : KmsConfiguration.cs
with Apache License 2.0
from cohesity

public bool Equals(KmsConfiguration input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.CaCertificate == input.CaCertificate ||
                    (this.CaCertificate != null &&
                    this.CaCertificate.Equals(input.CaCertificate))
                ) && 
                (
                    this.ClientCertificate == input.ClientCertificate ||
                    (this.ClientCertificate != null &&
                    this.ClientCertificate.Equals(input.ClientCertificate))
                ) && 
                (
                    this.ClientKey == input.ClientKey ||
                    (this.ClientKey != null &&
                    this.ClientKey.Equals(input.ClientKey))
                ) && 
                (
                    this.KmipProtocolVersion == input.KmipProtocolVersion ||
                    (this.KmipProtocolVersion != null &&
                    this.KmipProtocolVersion.Equals(input.KmipProtocolVersion))
                ) && 
                (
                    this.ServerIp == input.ServerIp ||
                    (this.ServerIp != null &&
                    this.ServerIp.Equals(input.ServerIp))
                ) && 
                (
                    this.ServerName == input.ServerName ||
                    (this.ServerName != null &&
                    this.ServerName.Equals(input.ServerName))
                ) && 
                (
                    this.ServerPort == input.ServerPort ||
                    (this.ServerPort != null &&
                    this.ServerPort.Equals(input.ServerPort))
                ) && 
                (
                    this.ServerType == input.ServerType ||
                    this.ServerType.Equals(input.ServerType)
                );
        }

19 Source : LatestProtectionRun.cs
with Apache License 2.0
from cohesity

public bool Equals(LatestProtectionRun input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.BackupRun == input.BackupRun ||
                    (this.BackupRun != null &&
                    this.BackupRun.Equals(input.BackupRun))
                ) && 
                (
                    this.ChangeEventId == input.ChangeEventId ||
                    (this.ChangeEventId != null &&
                    this.ChangeEventId.Equals(input.ChangeEventId))
                ) && 
                (
                    this.CopyRun == input.CopyRun ||
                    (this.CopyRun != null &&
                    this.CopyRun.Equals(input.CopyRun))
                ) && 
                (
                    this.JobRunId == input.JobRunId ||
                    (this.JobRunId != null &&
                    this.JobRunId.Equals(input.JobRunId))
                ) && 
                (
                    this.ProtectionJobRunUid == input.ProtectionJobRunUid ||
                    (this.ProtectionJobRunUid != null &&
                    this.ProtectionJobRunUid.Equals(input.ProtectionJobRunUid))
                ) && 
                (
                    this.SnapshotTarget == input.SnapshotTarget ||
                    (this.SnapshotTarget != null &&
                    this.SnapshotTarget.Equals(input.SnapshotTarget))
                ) && 
                (
                    this.SnapshotTargetType == input.SnapshotTargetType ||
                    (this.SnapshotTargetType != null &&
                    this.SnapshotTargetType.Equals(input.SnapshotTargetType))
                ) && 
                (
                    this.TaskStatus == input.TaskStatus ||
                    (this.TaskStatus != null &&
                    this.TaskStatus.Equals(input.TaskStatus))
                ) && 
                (
                    this.Uuid == input.Uuid ||
                    (this.Uuid != null &&
                    this.Uuid.Equals(input.Uuid))
                );
        }

19 Source : LdapProvider.cs
with Apache License 2.0
from cohesity

public bool Equals(LdapProvider input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AdDomainName == input.AdDomainName ||
                    (this.AdDomainName != null &&
                    this.AdDomainName.Equals(input.AdDomainName))
                ) && 
                (
                    this.AuthType == input.AuthType ||
                    this.AuthType.Equals(input.AuthType)
                ) && 
                (
                    this.BaseDistinguishedName == input.BaseDistinguishedName ||
                    (this.BaseDistinguishedName != null &&
                    this.BaseDistinguishedName.Equals(input.BaseDistinguishedName))
                ) && 
                (
                    this.DomainName == input.DomainName ||
                    (this.DomainName != null &&
                    this.DomainName.Equals(input.DomainName))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Port == input.Port ||
                    (this.Port != null &&
                    this.Port.Equals(input.Port))
                ) && 
                (
                    this.PreferredLdapServerList == input.PreferredLdapServerList ||
                    this.PreferredLdapServerList != null &&
                    input.PreferredLdapServerList != null &&
                    this.PreferredLdapServerList.SequenceEqual(input.PreferredLdapServerList)
                ) && 
                (
                    this.TenantId == input.TenantId ||
                    (this.TenantId != null &&
                    this.TenantId.Equals(input.TenantId))
                ) && 
                (
                    this.UseSsl == input.UseSsl ||
                    (this.UseSsl != null &&
                    this.UseSsl.Equals(input.UseSsl))
                ) && 
                (
                    this.UserDistinguishedName == input.UserDistinguishedName ||
                    (this.UserDistinguishedName != null &&
                    this.UserDistinguishedName.Equals(input.UserDistinguishedName))
                ) && 
                (
                    this.UserPreplacedword == input.UserPreplacedword ||
                    (this.UserPreplacedword != null &&
                    this.UserPreplacedword.Equals(input.UserPreplacedword))
                );
        }

19 Source : LdapProviderResponse.cs
with Apache License 2.0
from cohesity

public bool Equals(LdapProviderResponse input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AdDomainName == input.AdDomainName ||
                    (this.AdDomainName != null &&
                    this.AdDomainName.Equals(input.AdDomainName))
                ) && 
                (
                    this.AuthType == input.AuthType ||
                    this.AuthType.Equals(input.AuthType)
                ) && 
                (
                    this.BaseDistinguishedName == input.BaseDistinguishedName ||
                    (this.BaseDistinguishedName != null &&
                    this.BaseDistinguishedName.Equals(input.BaseDistinguishedName))
                ) && 
                (
                    this.DomainName == input.DomainName ||
                    (this.DomainName != null &&
                    this.DomainName.Equals(input.DomainName))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Port == input.Port ||
                    (this.Port != null &&
                    this.Port.Equals(input.Port))
                ) && 
                (
                    this.PreferredLdapServerList == input.PreferredLdapServerList ||
                    this.PreferredLdapServerList != null &&
                    input.PreferredLdapServerList != null &&
                    this.PreferredLdapServerList.SequenceEqual(input.PreferredLdapServerList)
                ) && 
                (
                    this.TenantId == input.TenantId ||
                    (this.TenantId != null &&
                    this.TenantId.Equals(input.TenantId))
                ) && 
                (
                    this.UseSsl == input.UseSsl ||
                    (this.UseSsl != null &&
                    this.UseSsl.Equals(input.UseSsl))
                ) && 
                (
                    this.UserDistinguishedName == input.UserDistinguishedName ||
                    (this.UserDistinguishedName != null &&
                    this.UserDistinguishedName.Equals(input.UserDistinguishedName))
                ) && 
                (
                    this.UserPreplacedword == input.UserPreplacedword ||
                    (this.UserPreplacedword != null &&
                    this.UserPreplacedword.Equals(input.UserPreplacedword))
                );
        }

19 Source : LockFileParams.cs
with Apache License 2.0
from cohesity

public bool Equals(LockFileParams input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.ExpiryTimestampMsecs == input.ExpiryTimestampMsecs ||
                    (this.ExpiryTimestampMsecs != null &&
                    this.ExpiryTimestampMsecs.Equals(input.ExpiryTimestampMsecs))
                ) && 
                (
                    this.Path == input.Path ||
                    (this.Path != null &&
                    this.Path.Equals(input.Path))
                );
        }

19 Source : LockRange.cs
with Apache License 2.0
from cohesity

public bool Equals(LockRange input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.IsExclusive == input.IsExclusive ||
                    (this.IsExclusive != null &&
                    this.IsExclusive.Equals(input.IsExclusive))
                ) && 
                (
                    this.Length == input.Length ||
                    (this.Length != null &&
                    this.Length.Equals(input.Length))
                ) && 
                (
                    this.Offset == input.Offset ||
                    (this.Offset != null &&
                    this.Offset.Equals(input.Offset))
                );
        }

19 Source : MapperInfo.cs
with Apache License 2.0
from cohesity

public bool Equals(MapperInfo input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.Code == input.Code ||
                    (this.Code != null &&
                    this.Code.Equals(input.Code))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.IsSystemDefined == input.IsSystemDefined ||
                    (this.IsSystemDefined != null &&
                    this.IsSystemDefined.Equals(input.IsSystemDefined))
                ) && 
                (
                    this.JarName == input.JarName ||
                    (this.JarName != null &&
                    this.JarName.Equals(input.JarName))
                ) && 
                (
                    this.JarPath == input.JarPath ||
                    (this.JarPath != null &&
                    this.JarPath.Equals(input.JarPath))
                ) && 
                (
                    this.Language == input.Language ||
                    (this.Language != null &&
                    this.Language.Equals(input.Language))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                );
        }

19 Source : MapReduceInstanceRunInfo.cs
with Apache License 2.0
from cohesity

public bool Equals(MapReduceInstanceRunInfo input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.EndTime == input.EndTime ||
                    (this.EndTime != null &&
                    this.EndTime.Equals(input.EndTime))
                ) && 
                (
                    this.ErrorMessage == input.ErrorMessage ||
                    (this.ErrorMessage != null &&
                    this.ErrorMessage.Equals(input.ErrorMessage))
                ) && 
                (
                    this.ExecutionStartTimeUsecs == input.ExecutionStartTimeUsecs ||
                    (this.ExecutionStartTimeUsecs != null &&
                    this.ExecutionStartTimeUsecs.Equals(input.ExecutionStartTimeUsecs))
                ) && 
                (
                    this.FilesProcessed == input.FilesProcessed ||
                    (this.FilesProcessed != null &&
                    this.FilesProcessed.Equals(input.FilesProcessed))
                ) && 
                (
                    this.MapDoneTimeUsecs == input.MapDoneTimeUsecs ||
                    (this.MapDoneTimeUsecs != null &&
                    this.MapDoneTimeUsecs.Equals(input.MapDoneTimeUsecs))
                ) && 
                (
                    this.MapInputBytes == input.MapInputBytes ||
                    (this.MapInputBytes != null &&
                    this.MapInputBytes.Equals(input.MapInputBytes))
                ) && 
                (
                    this.MappersSpawned == input.MappersSpawned ||
                    (this.MappersSpawned != null &&
                    this.MappersSpawned.Equals(input.MappersSpawned))
                ) && 
                (
                    this.NumMapOutputs == input.NumMapOutputs ||
                    (this.NumMapOutputs != null &&
                    this.NumMapOutputs.Equals(input.NumMapOutputs))
                ) && 
                (
                    this.NumReduceOutputs == input.NumReduceOutputs ||
                    (this.NumReduceOutputs != null &&
                    this.NumReduceOutputs.Equals(input.NumReduceOutputs))
                ) && 
                (
                    this.PercentageCompletion == input.PercentageCompletion ||
                    (this.PercentageCompletion != null &&
                    this.PercentageCompletion.Equals(input.PercentageCompletion))
                ) && 
                (
                    this.PercentageMapperCompletion == input.PercentageMapperCompletion ||
                    (this.PercentageMapperCompletion != null &&
                    this.PercentageMapperCompletion.Equals(input.PercentageMapperCompletion))
                ) && 
                (
                    this.PercentageReducerCompletion == input.PercentageReducerCompletion ||
                    (this.PercentageReducerCompletion != null &&
                    this.PercentageReducerCompletion.Equals(input.PercentageReducerCompletion))
                ) && 
                (
                    this.ReducersSpawned == input.ReducersSpawned ||
                    (this.ReducersSpawned != null &&
                    this.ReducersSpawned.Equals(input.ReducersSpawned))
                ) && 
                (
                    this.RemainingTimeMins == input.RemainingTimeMins ||
                    (this.RemainingTimeMins != null &&
                    this.RemainingTimeMins.Equals(input.RemainingTimeMins))
                ) && 
                (
                    this.StartTime == input.StartTime ||
                    (this.StartTime != null &&
                    this.StartTime.Equals(input.StartTime))
                ) && 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                ) && 
                (
                    this.TotalNumMappers == input.TotalNumMappers ||
                    (this.TotalNumMappers != null &&
                    this.TotalNumMappers.Equals(input.TotalNumMappers))
                ) && 
                (
                    this.TotalNumReducers == input.TotalNumReducers ||
                    (this.TotalNumReducers != null &&
                    this.TotalNumReducers.Equals(input.TotalNumReducers))
                );
        }

19 Source : MetricDataBlock.cs
with Apache License 2.0
from cohesity

public bool Equals(MetricDataBlock input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.DataPointVec == input.DataPointVec ||
                    this.DataPointVec != null &&
                    input.DataPointVec != null &&
                    this.DataPointVec.SequenceEqual(input.DataPointVec)
                ) && 
                (
                    this.MetricName == input.MetricName ||
                    (this.MetricName != null &&
                    this.MetricName.Equals(input.MetricName))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                );
        }

See More Examples