bool.Equals(object)

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

1236 Examples 7

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

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

            return 
                (
                    this.AdditionalParams == input.AdditionalParams ||
                    (this.AdditionalParams != null &&
                    this.AdditionalParams.Equals(input.AdditionalParams))
                ) && 
                (
                    this.AgentEndpoint == input.AgentEndpoint ||
                    (this.AgentEndpoint != null &&
                    this.AgentEndpoint.Equals(input.AgentEndpoint))
                ) && 
                (
                    this.AgentPort == input.AgentPort ||
                    (this.AgentPort != null &&
                    this.AgentPort.Equals(input.AgentPort))
                ) && 
                (
                    this.Credentials == input.Credentials ||
                    (this.Credentials != null &&
                    this.Credentials.Equals(input.Credentials))
                ) && 
                (
                    this.Endpoint == input.Endpoint ||
                    (this.Endpoint != null &&
                    this.Endpoint.Equals(input.Endpoint))
                ) && 
                (
                    this.Enreplacedy == input.Enreplacedy ||
                    (this.Enreplacedy != null &&
                    this.Enreplacedy.Equals(input.Enreplacedy))
                ) && 
                (
                    this.HostType == input.HostType ||
                    (this.HostType != null &&
                    this.HostType.Equals(input.HostType))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.PopulateSubnetForAllClusterNodes == input.PopulateSubnetForAllClusterNodes ||
                    (this.PopulateSubnetForAllClusterNodes != null &&
                    this.PopulateSubnetForAllClusterNodes.Equals(input.PopulateSubnetForAllClusterNodes))
                ) && 
                (
                    this.Port == input.Port ||
                    (this.Port != null &&
                    this.Port.Equals(input.Port))
                ) && 
                (
                    this.TenantId == input.TenantId ||
                    (this.TenantId != null &&
                    this.TenantId.Equals(input.TenantId))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                ) && 
                (
                    this.Version == input.Version ||
                    (this.Version != null &&
                    this.Version.Equals(input.Version))
                );
        }

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

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

            return 
                (
                    this.DomainName == input.DomainName ||
                    (this.DomainName != null &&
                    this.DomainName.Equals(input.DomainName))
                ) && 
                (
                    this.FallbackUserIdMappingInfo == input.FallbackUserIdMappingInfo ||
                    (this.FallbackUserIdMappingInfo != null &&
                    this.FallbackUserIdMappingInfo.Equals(input.FallbackUserIdMappingInfo))
                ) && 
                (
                    this.IgnoredTrustedDomains == input.IgnoredTrustedDomains ||
                    this.IgnoredTrustedDomains != null &&
                    input.IgnoredTrustedDomains != null &&
                    this.IgnoredTrustedDomains.SequenceEqual(input.IgnoredTrustedDomains)
                ) && 
                (
                    this.LdapProviderId == input.LdapProviderId ||
                    (this.LdapProviderId != null &&
                    this.LdapProviderId.Equals(input.LdapProviderId))
                ) && 
                (
                    this.MachineAccounts == input.MachineAccounts ||
                    this.MachineAccounts != null &&
                    input.MachineAccounts != null &&
                    this.MachineAccounts.SequenceEqual(input.MachineAccounts)
                ) && 
                (
                    this.OuName == input.OuName ||
                    (this.OuName != null &&
                    this.OuName.Equals(input.OuName))
                ) && 
                (
                    this.OverwriteExistingAccounts == input.OverwriteExistingAccounts ||
                    (this.OverwriteExistingAccounts != null &&
                    this.OverwriteExistingAccounts.Equals(input.OverwriteExistingAccounts))
                ) && 
                (
                    this.Preplacedword == input.Preplacedword ||
                    (this.Preplacedword != null &&
                    this.Preplacedword.Equals(input.Preplacedword))
                ) && 
                (
                    this.PreferredDomainControllers == input.PreferredDomainControllers ||
                    this.PreferredDomainControllers != null &&
                    input.PreferredDomainControllers != null &&
                    this.PreferredDomainControllers.SequenceEqual(input.PreferredDomainControllers)
                ) && 
                (
                    this.TaskPath == input.TaskPath ||
                    (this.TaskPath != null &&
                    this.TaskPath.Equals(input.TaskPath))
                ) && 
                (
                    this.TenantId == input.TenantId ||
                    (this.TenantId != null &&
                    this.TenantId.Equals(input.TenantId))
                ) && 
                (
                    this.TrustedDomains == input.TrustedDomains ||
                    this.TrustedDomains != null &&
                    input.TrustedDomains != null &&
                    this.TrustedDomains.SequenceEqual(input.TrustedDomains)
                ) && 
                (
                    this.TrustedDomainsEnabled == input.TrustedDomainsEnabled ||
                    (this.TrustedDomainsEnabled != null &&
                    this.TrustedDomainsEnabled.Equals(input.TrustedDomainsEnabled))
                ) && 
                (
                    this.UnixRootSid == input.UnixRootSid ||
                    (this.UnixRootSid != null &&
                    this.UnixRootSid.Equals(input.UnixRootSid))
                ) && 
                (
                    this.UserIdMappingInfo == input.UserIdMappingInfo ||
                    (this.UserIdMappingInfo != null &&
                    this.UserIdMappingInfo.Equals(input.UserIdMappingInfo))
                ) && 
                (
                    this.UserName == input.UserName ||
                    (this.UserName != null &&
                    this.UserName.Equals(input.UserName))
                ) && 
                (
                    this.Workgroup == input.Workgroup ||
                    (this.Workgroup != null &&
                    this.Workgroup.Equals(input.Workgroup))
                );
        }

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

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

            return 
                (
                    this.AllowLocalAuthentication == input.AllowLocalAuthentication ||
                    (this.AllowLocalAuthentication != null &&
                    this.AllowLocalAuthentication.Equals(input.AllowLocalAuthentication))
                ) && 
                (
                    this.Certificate == input.Certificate ||
                    (this.Certificate != null &&
                    this.Certificate.Equals(input.Certificate))
                ) && 
                (
                    this.CertificateFilename == input.CertificateFilename ||
                    (this.CertificateFilename != null &&
                    this.CertificateFilename.Equals(input.CertificateFilename))
                ) && 
                (
                    this.Domain == input.Domain ||
                    (this.Domain != null &&
                    this.Domain.Equals(input.Domain))
                ) && 
                (
                    this.Enable == input.Enable ||
                    (this.Enable != null &&
                    this.Enable.Equals(input.Enable))
                ) && 
                (
                    this.IssuerId == input.IssuerId ||
                    (this.IssuerId != null &&
                    this.IssuerId.Equals(input.IssuerId))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Roles == input.Roles ||
                    this.Roles != null &&
                    input.Roles != null &&
                    this.Roles.SequenceEqual(input.Roles)
                ) && 
                (
                    this.SamlAttributeName == input.SamlAttributeName ||
                    (this.SamlAttributeName != null &&
                    this.SamlAttributeName.Equals(input.SamlAttributeName))
                ) && 
                (
                    this.SignRequest == input.SignRequest ||
                    (this.SignRequest != null &&
                    this.SignRequest.Equals(input.SignRequest))
                ) && 
                (
                    this.SsoUrl == input.SsoUrl ||
                    (this.SsoUrl != null &&
                    this.SsoUrl.Equals(input.SsoUrl))
                ) && 
                (
                    this.TenantId == input.TenantId ||
                    (this.TenantId != null &&
                    this.TenantId.Equals(input.TenantId))
                );
        }

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

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

            return 
                (
                    this.AppEnreplacedyIdVec == input.AppEnreplacedyIdVec ||
                    this.AppEnreplacedyIdVec != null &&
                    input.AppEnreplacedyIdVec != null &&
                    this.AppEnreplacedyIdVec.SequenceEqual(input.AppEnreplacedyIdVec)
                ) && 
                (
                    this.OracleParams == input.OracleParams ||
                    (this.OracleParams != null &&
                    this.OracleParams.Equals(input.OracleParams))
                ) && 
                (
                    this.PhysicalParams == input.PhysicalParams ||
                    (this.PhysicalParams != null &&
                    this.PhysicalParams.Equals(input.PhysicalParams))
                ) && 
                (
                    this.SkipIndexing == input.SkipIndexing ||
                    (this.SkipIndexing != null &&
                    this.SkipIndexing.Equals(input.SkipIndexing))
                ) && 
                (
                    this.SourceId == input.SourceId ||
                    (this.SourceId != null &&
                    this.SourceId.Equals(input.SourceId))
                ) && 
                (
                    this.VmwareParams == input.VmwareParams ||
                    (this.VmwareParams != null &&
                    this.VmwareParams.Equals(input.VmwareParams))
                );
        }

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

public bool Equals(ClusterAuditLogConfiguration 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 : ClusterConfigProtoStoragePolicyOverride.cs
with Apache License 2.0
from cohesity

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

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

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

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

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

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

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

            return 
                (
                    this.DeleteAll == input.DeleteAll ||
                    (this.DeleteAll != null &&
                    this.DeleteAll.Equals(input.DeleteAll))
                ) && 
                (
                    this.UserIds == input.UserIds ||
                    this.UserIds != null &&
                    input.UserIds != null &&
                    this.UserIds.SequenceEqual(input.UserIds)
                ) && 
                (
                    this.ViewName == input.ViewName ||
                    (this.ViewName != null &&
                    this.ViewName.Equals(input.ViewName))
                );
        }

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

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

            return 
                (
                    this.EmailAddress == input.EmailAddress ||
                    (this.EmailAddress != null &&
                    this.EmailAddress.Equals(input.EmailAddress))
                ) && 
                (
                    this.ExternalApiCurlOptions == input.ExternalApiCurlOptions ||
                    (this.ExternalApiCurlOptions != null &&
                    this.ExternalApiCurlOptions.Equals(input.ExternalApiCurlOptions))
                ) && 
                (
                    this.ExternalApiUrl == input.ExternalApiUrl ||
                    (this.ExternalApiUrl != null &&
                    this.ExternalApiUrl.Equals(input.ExternalApiUrl))
                ) && 
                (
                    this.Locale == input.Locale ||
                    (this.Locale != null &&
                    this.Locale.Equals(input.Locale))
                ) && 
                (
                    this.SnmpNotification == input.SnmpNotification ||
                    (this.SnmpNotification != null &&
                    this.SnmpNotification.Equals(input.SnmpNotification))
                ) && 
                (
                    this.SyslogNotification == input.SyslogNotification ||
                    (this.SyslogNotification != null &&
                    this.SyslogNotification.Equals(input.SyslogNotification))
                ) && 
                (
                    this.TenantId == input.TenantId ||
                    (this.TenantId != null &&
                    this.TenantId.Equals(input.TenantId))
                );
        }

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

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

            return 
                (
                    this.AutoMinorVersionUpgrade == input.AutoMinorVersionUpgrade ||
                    (this.AutoMinorVersionUpgrade != null &&
                    this.AutoMinorVersionUpgrade.Equals(input.AutoMinorVersionUpgrade))
                ) && 
                (
                    this.AvailabilityZone == input.AvailabilityZone ||
                    (this.AvailabilityZone != null &&
                    this.AvailabilityZone.Equals(input.AvailabilityZone))
                ) && 
                (
                    this.CopyTagsToSnapshots == input.CopyTagsToSnapshots ||
                    (this.CopyTagsToSnapshots != null &&
                    this.CopyTagsToSnapshots.Equals(input.CopyTagsToSnapshots))
                ) && 
                (
                    this.DbInstanceId == input.DbInstanceId ||
                    (this.DbInstanceId != null &&
                    this.DbInstanceId.Equals(input.DbInstanceId))
                ) && 
                (
                    this.DbOptionGroup == input.DbOptionGroup ||
                    (this.DbOptionGroup != null &&
                    this.DbOptionGroup.Equals(input.DbOptionGroup))
                ) && 
                (
                    this.DbParameterGroup == input.DbParameterGroup ||
                    (this.DbParameterGroup != null &&
                    this.DbParameterGroup.Equals(input.DbParameterGroup))
                ) && 
                (
                    this.DbPort == input.DbPort ||
                    (this.DbPort != null &&
                    this.DbPort.Equals(input.DbPort))
                ) && 
                (
                    this.IamDbAuthentication == input.IamDbAuthentication ||
                    (this.IamDbAuthentication != null &&
                    this.IamDbAuthentication.Equals(input.IamDbAuthentication))
                ) && 
                (
                    this.MultiAzDeployment == input.MultiAzDeployment ||
                    (this.MultiAzDeployment != null &&
                    this.MultiAzDeployment.Equals(input.MultiAzDeployment))
                ) && 
                (
                    this.PointInTimeParams == input.PointInTimeParams ||
                    (this.PointInTimeParams != null &&
                    this.PointInTimeParams.Equals(input.PointInTimeParams))
                ) && 
                (
                    this.PublicAccessibility == input.PublicAccessibility ||
                    (this.PublicAccessibility != null &&
                    this.PublicAccessibility.Equals(input.PublicAccessibility))
                );
        }

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

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

            return 
                (
                    this.AppEnv == input.AppEnv ||
                    (this.AppEnv != null &&
                    this.AppEnv.Equals(input.AppEnv))
                ) && 
                (
                    this.Error == input.Error ||
                    (this.Error != null &&
                    this.Error.Equals(input.Error))
                ) && 
                (
                    this.Finished == input.Finished ||
                    (this.Finished != null &&
                    this.Finished.Equals(input.Finished))
                ) && 
                (
                    this.TargetEnreplacedy == input.TargetEnreplacedy ||
                    (this.TargetEnreplacedy != null &&
                    this.TargetEnreplacedy.Equals(input.TargetEnreplacedy))
                ) && 
                (
                    this.TargetEnreplacedyCredentials == input.TargetEnreplacedyCredentials ||
                    (this.TargetEnreplacedyCredentials != null &&
                    this.TargetEnreplacedyCredentials.Equals(input.TargetEnreplacedyCredentials))
                );
        }

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

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

            return 
                (
                    this.ActionExecutorTargetType == input.ActionExecutorTargetType ||
                    (this.ActionExecutorTargetType != null &&
                    this.ActionExecutorTargetType.Equals(input.ActionExecutorTargetType))
                ) && 
                (
                    this.CloneTaskName == input.CloneTaskName ||
                    (this.CloneTaskName != null &&
                    this.CloneTaskName.Equals(input.CloneTaskName))
                ) && 
                (
                    this.DatastoreEnreplacedy == input.DatastoreEnreplacedy ||
                    (this.DatastoreEnreplacedy != null &&
                    this.DatastoreEnreplacedy.Equals(input.DatastoreEnreplacedy))
                ) && 
                (
                    this.DeployVmsToCloudTaskState == input.DeployVmsToCloudTaskState ||
                    (this.DeployVmsToCloudTaskState != null &&
                    this.DeployVmsToCloudTaskState.Equals(input.DeployVmsToCloudTaskState))
                ) && 
                (
                    this.DestroyCloneAppTaskInfo == input.DestroyCloneAppTaskInfo ||
                    (this.DestroyCloneAppTaskInfo != null &&
                    this.DestroyCloneAppTaskInfo.Equals(input.DestroyCloneAppTaskInfo))
                ) && 
                (
                    this.DestroyCloneVmTaskInfo == input.DestroyCloneVmTaskInfo ||
                    (this.DestroyCloneVmTaskInfo != null &&
                    this.DestroyCloneVmTaskInfo.Equals(input.DestroyCloneVmTaskInfo))
                ) && 
                (
                    this.DestroyMountVolumesTaskInfo == input.DestroyMountVolumesTaskInfo ||
                    (this.DestroyMountVolumesTaskInfo != null &&
                    this.DestroyMountVolumesTaskInfo.Equals(input.DestroyMountVolumesTaskInfo))
                ) && 
                (
                    this.EndTimeUsecs == input.EndTimeUsecs ||
                    (this.EndTimeUsecs != null &&
                    this.EndTimeUsecs.Equals(input.EndTimeUsecs))
                ) && 
                (
                    this.Error == input.Error ||
                    (this.Error != null &&
                    this.Error.Equals(input.Error))
                ) && 
                (
                    this.FolderEnreplacedy == input.FolderEnreplacedy ||
                    (this.FolderEnreplacedy != null &&
                    this.FolderEnreplacedy.Equals(input.FolderEnreplacedy))
                ) && 
                (
                    this.ForceDelete == input.ForceDelete ||
                    (this.ForceDelete != null &&
                    this.ForceDelete.Equals(input.ForceDelete))
                ) && 
                (
                    this.FullViewName == input.FullViewName ||
                    (this.FullViewName != null &&
                    this.FullViewName.Equals(input.FullViewName))
                ) && 
                (
                    this.ParentSourceConnectionParams == input.ParentSourceConnectionParams ||
                    (this.ParentSourceConnectionParams != null &&
                    this.ParentSourceConnectionParams.Equals(input.ParentSourceConnectionParams))
                ) && 
                (
                    this.ParentTaskId == input.ParentTaskId ||
                    (this.ParentTaskId != null &&
                    this.ParentTaskId.Equals(input.ParentTaskId))
                ) && 
                (
                    this.PerformCloneTaskId == input.PerformCloneTaskId ||
                    (this.PerformCloneTaskId != null &&
                    this.PerformCloneTaskId.Equals(input.PerformCloneTaskId))
                ) && 
                (
                    this.RestoreType == input.RestoreType ||
                    (this.RestoreType != null &&
                    this.RestoreType.Equals(input.RestoreType))
                ) && 
                (
                    this.ScheduledConsreplaceduentId == input.ScheduledConsreplaceduentId ||
                    (this.ScheduledConsreplaceduentId != null &&
                    this.ScheduledConsreplaceduentId.Equals(input.ScheduledConsreplaceduentId))
                ) && 
                (
                    this.ScheduledGandalfSessionId == input.ScheduledGandalfSessionId ||
                    (this.ScheduledGandalfSessionId != null &&
                    this.ScheduledGandalfSessionId.Equals(input.ScheduledGandalfSessionId))
                ) && 
                (
                    this.StartTimeUsecs == input.StartTimeUsecs ||
                    (this.StartTimeUsecs != null &&
                    this.StartTimeUsecs.Equals(input.StartTimeUsecs))
                ) && 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                ) && 
                (
                    this.TaskId == input.TaskId ||
                    (this.TaskId != null &&
                    this.TaskId.Equals(input.TaskId))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                ) && 
                (
                    this.User == input.User ||
                    (this.User != null &&
                    this.User.Equals(input.User))
                ) && 
                (
                    this.UserInfo == input.UserInfo ||
                    (this.UserInfo != null &&
                    this.UserInfo.Equals(input.UserInfo))
                ) && 
                (
                    this.VcdConfig == input.VcdConfig ||
                    (this.VcdConfig != null &&
                    this.VcdConfig.Equals(input.VcdConfig))
                ) && 
                (
                    this.ViewBoxId == input.ViewBoxId ||
                    (this.ViewBoxId != null &&
                    this.ViewBoxId.Equals(input.ViewBoxId))
                ) && 
                (
                    this.ViewNameDEPRECATED == input.ViewNameDEPRECATED ||
                    (this.ViewNameDEPRECATED != null &&
                    this.ViewNameDEPRECATED.Equals(input.ViewNameDEPRECATED))
                );
        }

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

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

            return 
                (
                    this.ClusterId == input.ClusterId ||
                    (this.ClusterId != null &&
                    this.ClusterId.Equals(input.ClusterId))
                ) && 
                (
                    this.ClusterIncarnationId == input.ClusterIncarnationId ||
                    (this.ClusterIncarnationId != null &&
                    this.ClusterIncarnationId.Equals(input.ClusterIncarnationId))
                ) && 
                (
                    this.CurrentOperation == input.CurrentOperation ||
                    this.CurrentOperation.Equals(input.CurrentOperation)
                ) && 
                (
                    this.Message == input.Message ||
                    (this.Message != null &&
                    this.Message.Equals(input.Message))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.NodeStatuses == input.NodeStatuses ||
                    this.NodeStatuses != null &&
                    input.NodeStatuses != null &&
                    this.NodeStatuses.SequenceEqual(input.NodeStatuses)
                ) && 
                (
                    this.RemovalState == input.RemovalState ||
                    this.RemovalState.Equals(input.RemovalState)
                ) && 
                (
                    this.ServicesSynced == input.ServicesSynced ||
                    (this.ServicesSynced != null &&
                    this.ServicesSynced.Equals(input.ServicesSynced))
                ) && 
                (
                    this.SoftwareVersion == input.SoftwareVersion ||
                    (this.SoftwareVersion != null &&
                    this.SoftwareVersion.Equals(input.SoftwareVersion))
                ) && 
                (
                    this.StoppedServices == input.StoppedServices ||
                    this.StoppedServices.SequenceEqual(input.StoppedServices)
                );
        }

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

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

            return 
                (
                    this.CarrierDirectPort == input.CarrierDirectPort ||
                    (this.CarrierDirectPort != null &&
                    this.CarrierDirectPort.Equals(input.CarrierDirectPort))
                ) && 
                (
                    this.HttpDirectPort == input.HttpDirectPort ||
                    (this.HttpDirectPort != null &&
                    this.HttpDirectPort.Equals(input.HttpDirectPort))
                ) && 
                (
                    this.RequiresSsl == input.RequiresSsl ||
                    (this.RequiresSsl != null &&
                    this.RequiresSsl.Equals(input.RequiresSsl))
                ) && 
                (
                    this.Seeds == input.Seeds ||
                    this.Seeds != null &&
                    input.Seeds != null &&
                    this.Seeds.SequenceEqual(input.Seeds)
                );
        }

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 : DestroyMountVolumesTaskInfoProto.cs
with Apache License 2.0
from cohesity

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

            return 
                (
                    this.Error == input.Error ||
                    (this.Error != null &&
                    this.Error.Equals(input.Error))
                ) && 
                (
                    this.Finished == input.Finished ||
                    (this.Finished != null &&
                    this.Finished.Equals(input.Finished))
                ) && 
                (
                    this.HostName == input.HostName ||
                    (this.HostName != null &&
                    this.HostName.Equals(input.HostName))
                ) && 
                (
                    this.MountVolumesInfoProto == input.MountVolumesInfoProto ||
                    (this.MountVolumesInfoProto != null &&
                    this.MountVolumesInfoProto.Equals(input.MountVolumesInfoProto))
                ) && 
                (
                    this.SlaveTaskStartTimeUsecs == input.SlaveTaskStartTimeUsecs ||
                    (this.SlaveTaskStartTimeUsecs != null &&
                    this.SlaveTaskStartTimeUsecs.Equals(input.SlaveTaskStartTimeUsecs))
                ) && 
                (
                    this.TargetEnreplacedy == input.TargetEnreplacedy ||
                    (this.TargetEnreplacedy != null &&
                    this.TargetEnreplacedy.Equals(input.TargetEnreplacedy))
                ) && 
                (
                    this.UseExistingAgent == input.UseExistingAgent ||
                    (this.UseExistingAgent != null &&
                    this.UseExistingAgent.Equals(input.UseExistingAgent))
                );
        }

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

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

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

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

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

            return 
                (
                    this.DirPath == input.DirPath ||
                    (this.DirPath != null &&
                    this.DirPath.Equals(input.DirPath))
                ) && 
                (
                    this.DirWalkPending == input.DirWalkPending ||
                    (this.DirWalkPending != null &&
                    this.DirWalkPending.Equals(input.DirWalkPending))
                ) && 
                (
                    this.Policy == input.Policy ||
                    (this.Policy != null &&
                    this.Policy.Equals(input.Policy))
                ) && 
                (
                    this.UsageBytes == input.UsageBytes ||
                    (this.UsageBytes != null &&
                    this.UsageBytes.Equals(input.UsageBytes))
                );
        }

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 : EmailMetaData.cs
with Apache License 2.0
from cohesity

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

            return 
                (
                    this.AllUnderHierarchy == input.AllUnderHierarchy ||
                    (this.AllUnderHierarchy != null &&
                    this.AllUnderHierarchy.Equals(input.AllUnderHierarchy))
                ) && 
                (
                    this.BccRecipientAddresses == input.BccRecipientAddresses ||
                    this.BccRecipientAddresses != null &&
                    input.BccRecipientAddresses != null &&
                    this.BccRecipientAddresses.SequenceEqual(input.BccRecipientAddresses)
                ) && 
                (
                    this.CcRecipientAddresses == input.CcRecipientAddresses ||
                    this.CcRecipientAddresses != null &&
                    input.CcRecipientAddresses != null &&
                    this.CcRecipientAddresses.SequenceEqual(input.CcRecipientAddresses)
                ) && 
                (
                    this.DomainIds == input.DomainIds ||
                    this.DomainIds != null &&
                    input.DomainIds != null &&
                    this.DomainIds.SequenceEqual(input.DomainIds)
                ) && 
                (
                    this.EmailSubject == input.EmailSubject ||
                    (this.EmailSubject != null &&
                    this.EmailSubject.Equals(input.EmailSubject))
                ) && 
                (
                    this.FolderKey == input.FolderKey ||
                    (this.FolderKey != null &&
                    this.FolderKey.Equals(input.FolderKey))
                ) && 
                (
                    this.FolderName == input.FolderName ||
                    (this.FolderName != null &&
                    this.FolderName.Equals(input.FolderName))
                ) && 
                (
                    this.HasAttachments == input.HasAttachments ||
                    (this.HasAttachments != null &&
                    this.HasAttachments.Equals(input.HasAttachments))
                ) && 
                (
                    this.ItemKey == input.ItemKey ||
                    (this.ItemKey != null &&
                    this.ItemKey.Equals(input.ItemKey))
                ) && 
                (
                    this.MailboxIds == input.MailboxIds ||
                    this.MailboxIds != null &&
                    input.MailboxIds != null &&
                    this.MailboxIds.SequenceEqual(input.MailboxIds)
                ) && 
                (
                    this.ProtectionJobIds == input.ProtectionJobIds ||
                    this.ProtectionJobIds != null &&
                    input.ProtectionJobIds != null &&
                    this.ProtectionJobIds.SequenceEqual(input.ProtectionJobIds)
                ) && 
                (
                    this.ReceivedEndTime == input.ReceivedEndTime ||
                    (this.ReceivedEndTime != null &&
                    this.ReceivedEndTime.Equals(input.ReceivedEndTime))
                ) && 
                (
                    this.ReceivedStartTime == input.ReceivedStartTime ||
                    (this.ReceivedStartTime != null &&
                    this.ReceivedStartTime.Equals(input.ReceivedStartTime))
                ) && 
                (
                    this.ReceivedTimeSeconds == input.ReceivedTimeSeconds ||
                    (this.ReceivedTimeSeconds != null &&
                    this.ReceivedTimeSeconds.Equals(input.ReceivedTimeSeconds))
                ) && 
                (
                    this.RecipientAddresses == input.RecipientAddresses ||
                    this.RecipientAddresses != null &&
                    input.RecipientAddresses != null &&
                    this.RecipientAddresses.SequenceEqual(input.RecipientAddresses)
                ) && 
                (
                    this.SenderAddress == input.SenderAddress ||
                    (this.SenderAddress != null &&
                    this.SenderAddress.Equals(input.SenderAddress))
                ) && 
                (
                    this.SentTimeSeconds == input.SentTimeSeconds ||
                    (this.SentTimeSeconds != null &&
                    this.SentTimeSeconds.Equals(input.SentTimeSeconds))
                ) && 
                (
                    this.ShowOnlyEmailFolders == input.ShowOnlyEmailFolders ||
                    (this.ShowOnlyEmailFolders != null &&
                    this.ShowOnlyEmailFolders.Equals(input.ShowOnlyEmailFolders))
                ) && 
                (
                    this.TenantId == input.TenantId ||
                    (this.TenantId != null &&
                    this.TenantId.Equals(input.TenantId))
                );
        }

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

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

            return 
                (
                    this.AppServerId == input.AppServerId ||
                    (this.AppServerId != null &&
                    this.AppServerId.Equals(input.AppServerId))
                ) && 
                (
                    this.BackupSupported == input.BackupSupported ||
                    (this.BackupSupported != null &&
                    this.BackupSupported.Equals(input.BackupSupported))
                ) && 
                (
                    this.BackupUnsupportedReasons == input.BackupUnsupportedReasons ||
                    this.BackupUnsupportedReasons != null &&
                    input.BackupUnsupportedReasons != null &&
                    this.BackupUnsupportedReasons.SequenceEqual(input.BackupUnsupportedReasons)
                ) && 
                (
                    this.CreatedTimeMsecs == input.CreatedTimeMsecs ||
                    (this.CreatedTimeMsecs != null &&
                    this.CreatedTimeMsecs.Equals(input.CreatedTimeMsecs))
                ) && 
                (
                    this.DatabaseState == input.DatabaseState ||
                    this.DatabaseState.Equals(input.DatabaseState)
                ) && 
                (
                    this.DbSizeBytes == input.DbSizeBytes ||
                    (this.DbSizeBytes != null &&
                    this.DbSizeBytes.Equals(input.DbSizeBytes))
                ) && 
                (
                    this.Dbguid == input.Dbguid ||
                    (this.Dbguid != null &&
                    this.Dbguid.Equals(input.Dbguid))
                ) && 
                (
                    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.UtcOffsetMin == input.UtcOffsetMin ||
                    (this.UtcOffsetMin != null &&
                    this.UtcOffsetMin.Equals(input.UtcOffsetMin))
                );
        }

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

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

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

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

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

            return 
                (
                    this.Endpoint == input.Endpoint ||
                    (this.Endpoint != null &&
                    this.Endpoint.Equals(input.Endpoint))
                ) && 
                (
                    this.MountPoint == input.MountPoint ||
                    (this.MountPoint != null &&
                    this.MountPoint.Equals(input.MountPoint))
                ) && 
                (
                    this.ViewName == input.ViewName ||
                    (this.ViewName != null &&
                    this.ViewName.Equals(input.ViewName))
                );
        }

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 : 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 : ExtractFileRangeResult.cs
with Apache License 2.0
from cohesity

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

            return 
                (
                    this.Data == input.Data ||
                    this.Data != null &&
                    input.Data != null &&
                    this.Data.SequenceEqual(input.Data)
                ) && 
                (
                    this.Eof == input.Eof ||
                    (this.Eof != null &&
                    this.Eof.Equals(input.Eof))
                ) && 
                (
                    this.Error == input.Error ||
                    (this.Error != null &&
                    this.Error.Equals(input.Error))
                ) && 
                (
                    this.FileLength == input.FileLength ||
                    (this.FileLength != null &&
                    this.FileLength.Equals(input.FileLength))
                ) && 
                (
                    this.StartOffset == input.StartOffset ||
                    (this.StartOffset != null &&
                    this.StartOffset.Equals(input.StartOffset))
                );
        }

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

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

            return 
                (
                    this.FileExtensionsList == input.FileExtensionsList ||
                    this.FileExtensionsList != null &&
                    input.FileExtensionsList != null &&
                    this.FileExtensionsList.SequenceEqual(input.FileExtensionsList)
                ) && 
                (
                    this.IsEnabled == input.IsEnabled ||
                    (this.IsEnabled != null &&
                    this.IsEnabled.Equals(input.IsEnabled))
                ) && 
                (
                    this.Mode == input.Mode ||
                    this.Mode.Equals(input.Mode)
                );
        }

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

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

            return 
                (
                    this.BackupFilePath == input.BackupFilePath ||
                    (this.BackupFilePath != null &&
                    this.BackupFilePath.Equals(input.BackupFilePath))
                ) && 
                (
                    this.ExcludedFilePaths == input.ExcludedFilePaths ||
                    this.ExcludedFilePaths != null &&
                    input.ExcludedFilePaths != null &&
                    this.ExcludedFilePaths.SequenceEqual(input.ExcludedFilePaths)
                ) && 
                (
                    this.SkipNestedVolumes == input.SkipNestedVolumes ||
                    (this.SkipNestedVolumes != null &&
                    this.SkipNestedVolumes.Equals(input.SkipNestedVolumes))
                );
        }

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 : FileRestoreInfo.cs
with Apache License 2.0
from cohesity

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

            return 
                (
                    this.Error == input.Error ||
                    (this.Error != null &&
                    this.Error.Equals(input.Error))
                ) && 
                (
                    this.Filename == input.Filename ||
                    (this.Filename != null &&
                    this.Filename.Equals(input.Filename))
                ) && 
                (
                    this.FilesystemVolume == input.FilesystemVolume ||
                    (this.FilesystemVolume != null &&
                    this.FilesystemVolume.Equals(input.FilesystemVolume))
                ) && 
                (
                    this.IsFolder == input.IsFolder ||
                    (this.IsFolder != null &&
                    this.IsFolder.Equals(input.IsFolder))
                );
        }

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

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

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

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

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

            return 
                (
                    this.AdObjectMetaData == input.AdObjectMetaData ||
                    (this.AdObjectMetaData != null &&
                    this.AdObjectMetaData.Equals(input.AdObjectMetaData))
                ) && 
                (
                    this.DoreplacedentType == input.DoreplacedentType ||
                    (this.DoreplacedentType != null &&
                    this.DoreplacedentType.Equals(input.DoreplacedentType))
                ) && 
                (
                    this.EmailMetaData == input.EmailMetaData ||
                    (this.EmailMetaData != null &&
                    this.EmailMetaData.Equals(input.EmailMetaData))
                ) && 
                (
                    this.FileVersions == input.FileVersions ||
                    this.FileVersions != null &&
                    input.FileVersions != null &&
                    this.FileVersions.SequenceEqual(input.FileVersions)
                ) && 
                (
                    this.Filename == input.Filename ||
                    (this.Filename != null &&
                    this.Filename.Equals(input.Filename))
                ) && 
                (
                    this.IsFolder == input.IsFolder ||
                    (this.IsFolder != null &&
                    this.IsFolder.Equals(input.IsFolder))
                ) && 
                (
                    this.JobId == input.JobId ||
                    (this.JobId != null &&
                    this.JobId.Equals(input.JobId))
                ) && 
                (
                    this.JobUid == input.JobUid ||
                    (this.JobUid != null &&
                    this.JobUid.Equals(input.JobUid))
                ) && 
                (
                    this.OneDriveDoreplacedentMetadata == input.OneDriveDoreplacedentMetadata ||
                    (this.OneDriveDoreplacedentMetadata != null &&
                    this.OneDriveDoreplacedentMetadata.Equals(input.OneDriveDoreplacedentMetadata))
                ) && 
                (
                    this.ProtectionSource == input.ProtectionSource ||
                    (this.ProtectionSource != null &&
                    this.ProtectionSource.Equals(input.ProtectionSource))
                ) && 
                (
                    this.RegisteredSourceId == input.RegisteredSourceId ||
                    (this.RegisteredSourceId != null &&
                    this.RegisteredSourceId.Equals(input.RegisteredSourceId))
                ) && 
                (
                    this.SnapshotTags == input.SnapshotTags ||
                    this.SnapshotTags != null &&
                    input.SnapshotTags != null &&
                    this.SnapshotTags.SequenceEqual(input.SnapshotTags)
                ) && 
                (
                    this.SourceId == input.SourceId ||
                    (this.SourceId != null &&
                    this.SourceId.Equals(input.SourceId))
                ) && 
                (
                    this.Tags == input.Tags ||
                    this.Tags != null &&
                    input.Tags != null &&
                    this.Tags.SequenceEqual(input.Tags)
                ) && 
                (
                    this.TagsToSnapshotsMap == input.TagsToSnapshotsMap ||
                    this.TagsToSnapshotsMap != null &&
                    input.TagsToSnapshotsMap != null &&
                    this.TagsToSnapshotsMap.SequenceEqual(input.TagsToSnapshotsMap)
                ) && 
                (
                    this.Type == input.Type ||
                    this.Type.Equals(input.Type)
                ) && 
                (
                    this.ViewBoxId == input.ViewBoxId ||
                    (this.ViewBoxId != null &&
                    this.ViewBoxId.Equals(input.ViewBoxId))
                );
        }

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

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

            return 
                (
                    this.HasArchivalCopy == input.HasArchivalCopy ||
                    (this.HasArchivalCopy != null &&
                    this.HasArchivalCopy.Equals(input.HasArchivalCopy))
                ) && 
                (
                    this.HasLocalCopy == input.HasLocalCopy ||
                    (this.HasLocalCopy != null &&
                    this.HasLocalCopy.Equals(input.HasLocalCopy))
                ) && 
                (
                    this.HasRemoteCopy == input.HasRemoteCopy ||
                    (this.HasRemoteCopy != null &&
                    this.HasRemoteCopy.Equals(input.HasRemoteCopy))
                ) && 
                (
                    this.ModifiedTimeUsecs == input.ModifiedTimeUsecs ||
                    (this.ModifiedTimeUsecs != null &&
                    this.ModifiedTimeUsecs.Equals(input.ModifiedTimeUsecs))
                ) && 
                (
                    this.SizeBytes == input.SizeBytes ||
                    (this.SizeBytes != null &&
                    this.SizeBytes.Equals(input.SizeBytes))
                ) && 
                (
                    this.Snapshot == input.Snapshot ||
                    (this.Snapshot != null &&
                    this.Snapshot.Equals(input.Snapshot))
                );
        }

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 : FilesystemVolume.cs
with Apache License 2.0
from cohesity

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

            return 
                (
                    this.Disks == input.Disks ||
                    this.Disks != null &&
                    input.Disks != null &&
                    this.Disks.SequenceEqual(input.Disks)
                ) && 
                (
                    this.DisplayName == input.DisplayName ||
                    (this.DisplayName != null &&
                    this.DisplayName.Equals(input.DisplayName))
                ) && 
                (
                    this.FilesystemType == input.FilesystemType ||
                    (this.FilesystemType != null &&
                    this.FilesystemType.Equals(input.FilesystemType))
                ) && 
                (
                    this.FilesystemUuid == input.FilesystemUuid ||
                    (this.FilesystemUuid != null &&
                    this.FilesystemUuid.Equals(input.FilesystemUuid))
                ) && 
                (
                    this.IsSupported == input.IsSupported ||
                    (this.IsSupported != null &&
                    this.IsSupported.Equals(input.IsSupported))
                ) && 
                (
                    this.LogicalVolume == input.LogicalVolume ||
                    (this.LogicalVolume != null &&
                    this.LogicalVolume.Equals(input.LogicalVolume))
                ) && 
                (
                    this.LogicalVolumeType == input.LogicalVolumeType ||
                    this.LogicalVolumeType.Equals(input.LogicalVolumeType)
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.VolumeGuid == input.VolumeGuid ||
                    (this.VolumeGuid != null &&
                    this.VolumeGuid.Equals(input.VolumeGuid))
                );
        }

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

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

            return 
                (
                    this.BackupEnabled == input.BackupEnabled ||
                    (this.BackupEnabled != null &&
                    this.BackupEnabled.Equals(input.BackupEnabled))
                ) && 
                (
                    this.CreatedTimeMsecs == input.CreatedTimeMsecs ||
                    (this.CreatedTimeMsecs != null &&
                    this.CreatedTimeMsecs.Equals(input.CreatedTimeMsecs))
                ) && 
                (
                    this.LogicalCapacityBytes == input.LogicalCapacityBytes ||
                    (this.LogicalCapacityBytes != null &&
                    this.LogicalCapacityBytes.Equals(input.LogicalCapacityBytes))
                ) && 
                (
                    this.LogicalUsedBytes == input.LogicalUsedBytes ||
                    (this.LogicalUsedBytes != null &&
                    this.LogicalUsedBytes.Equals(input.LogicalUsedBytes))
                ) && 
                (
                    this.NfsInfo == input.NfsInfo ||
                    (this.NfsInfo != null &&
                    this.NfsInfo.Equals(input.NfsInfo))
                ) && 
                (
                    this.PhysicalUsedBytes == input.PhysicalUsedBytes ||
                    (this.PhysicalUsedBytes != null &&
                    this.PhysicalUsedBytes.Equals(input.PhysicalUsedBytes))
                ) && 
                (
                    this.Protocols == input.Protocols ||
                    this.Protocols.SequenceEqual(input.Protocols)
                ) && 
                (
                    this.SmbInfo == input.SmbInfo ||
                    (this.SmbInfo != null &&
                    this.SmbInfo.Equals(input.SmbInfo))
                ) && 
                (
                    this.UniqueUsedBytes == input.UniqueUsedBytes ||
                    (this.UniqueUsedBytes != null &&
                    this.UniqueUsedBytes.Equals(input.UniqueUsedBytes))
                );
        }

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 : GetJobRunInfoResult.cs
with Apache License 2.0
from cohesity

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

            return 
                (
                    this.BytesTransferred == input.BytesTransferred ||
                    (this.BytesTransferred != null &&
                    this.BytesTransferred.Equals(input.BytesTransferred))
                ) && 
                (
                    this.EndTimeUsecs == input.EndTimeUsecs ||
                    (this.EndTimeUsecs != null &&
                    this.EndTimeUsecs.Equals(input.EndTimeUsecs))
                ) && 
                (
                    this.FailureEnreplacedies == input.FailureEnreplacedies ||
                    (this.FailureEnreplacedies != null &&
                    this.FailureEnreplacedies.Equals(input.FailureEnreplacedies))
                ) && 
                (
                    this.JobId == input.JobId ||
                    (this.JobId != null &&
                    this.JobId.Equals(input.JobId))
                ) && 
                (
                    this.JobRunId == input.JobRunId ||
                    (this.JobRunId != null &&
                    this.JobRunId.Equals(input.JobRunId))
                ) && 
                (
                    this.JobType == input.JobType ||
                    (this.JobType != null &&
                    this.JobType.Equals(input.JobType))
                ) && 
                (
                    this.SlaViolated == input.SlaViolated ||
                    (this.SlaViolated != null &&
                    this.SlaViolated.Equals(input.SlaViolated))
                ) && 
                (
                    this.StartTimeUsecs == input.StartTimeUsecs ||
                    (this.StartTimeUsecs != null &&
                    this.StartTimeUsecs.Equals(input.StartTimeUsecs))
                ) && 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                ) && 
                (
                    this.SuccessEnreplacedies == input.SuccessEnreplacedies ||
                    (this.SuccessEnreplacedies != null &&
                    this.SuccessEnreplacedies.Equals(input.SuccessEnreplacedies))
                ) && 
                (
                    this.TotalEnreplacedies == input.TotalEnreplacedies ||
                    (this.TotalEnreplacedies != null &&
                    this.TotalEnreplacedies.Equals(input.TotalEnreplacedies))
                );
        }

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 : GetViewsResult.cs
with Apache License 2.0
from cohesity

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

            return 
                (
                    this.LastResult == input.LastResult ||
                    (this.LastResult != null &&
                    this.LastResult.Equals(input.LastResult))
                ) && 
                (
                    this.Views == input.Views ||
                    this.Views != null &&
                    input.Views != null &&
                    this.Views.SequenceEqual(input.Views)
                );
        }

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

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

            return 
                (
                    this.CreatedTimeMsecs == input.CreatedTimeMsecs ||
                    (this.CreatedTimeMsecs != null &&
                    this.CreatedTimeMsecs.Equals(input.CreatedTimeMsecs))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.Domain == input.Domain ||
                    (this.Domain != null &&
                    this.Domain.Equals(input.Domain))
                ) && 
                (
                    this.LastUpdatedTimeMsecs == input.LastUpdatedTimeMsecs ||
                    (this.LastUpdatedTimeMsecs != null &&
                    this.LastUpdatedTimeMsecs.Equals(input.LastUpdatedTimeMsecs))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Restricted == input.Restricted ||
                    (this.Restricted != null &&
                    this.Restricted.Equals(input.Restricted))
                ) && 
                (
                    this.Roles == input.Roles ||
                    this.Roles != null &&
                    input.Roles != null &&
                    this.Roles.SequenceEqual(input.Roles)
                ) && 
                (
                    this.Sid == input.Sid ||
                    (this.Sid != null &&
                    this.Sid.Equals(input.Sid))
                ) && 
                (
                    this.SmbPrincipals == input.SmbPrincipals ||
                    this.SmbPrincipals != null &&
                    input.SmbPrincipals != null &&
                    this.SmbPrincipals.SequenceEqual(input.SmbPrincipals)
                ) && 
                (
                    this.TenantIds == input.TenantIds ||
                    this.TenantIds != null &&
                    input.TenantIds != null &&
                    this.TenantIds.SequenceEqual(input.TenantIds)
                ) && 
                (
                    this.Usernames == input.Usernames ||
                    this.Usernames != null &&
                    input.Usernames != null &&
                    this.Usernames.SequenceEqual(input.Usernames)
                ) && 
                (
                    this.Users == input.Users ||
                    this.Users != null &&
                    input.Users != null &&
                    this.Users.SequenceEqual(input.Users)
                );
        }

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

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

            return 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.Domain == input.Domain ||
                    (this.Domain != null &&
                    this.Domain.Equals(input.Domain))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Restricted == input.Restricted ||
                    (this.Restricted != null &&
                    this.Restricted.Equals(input.Restricted))
                ) && 
                (
                    this.Roles == input.Roles ||
                    this.Roles != null &&
                    input.Roles != null &&
                    this.Roles.SequenceEqual(input.Roles)
                ) && 
                (
                    this.SmbPrincipals == input.SmbPrincipals ||
                    this.SmbPrincipals != null &&
                    input.SmbPrincipals != null &&
                    this.SmbPrincipals.SequenceEqual(input.SmbPrincipals)
                ) && 
                (
                    this.TenantIds == input.TenantIds ||
                    this.TenantIds != null &&
                    input.TenantIds != null &&
                    this.TenantIds.SequenceEqual(input.TenantIds)
                ) && 
                (
                    this.Users == input.Users ||
                    this.Users != null &&
                    input.Users != null &&
                    this.Users.SequenceEqual(input.Users)
                );
        }

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

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

            return 
                (
                    this.ApproxSizeBytes == input.ApproxSizeBytes ||
                    (this.ApproxSizeBytes != null &&
                    this.ApproxSizeBytes.Equals(input.ApproxSizeBytes))
                ) && 
                (
                    this.CreatedOn == input.CreatedOn ||
                    (this.CreatedOn != null &&
                    this.CreatedOn.Equals(input.CreatedOn))
                ) && 
                (
                    this.IsTransactionalTable == input.IsTransactionalTable ||
                    (this.IsTransactionalTable != null &&
                    this.IsTransactionalTable.Equals(input.IsTransactionalTable))
                ) && 
                (
                    this.Owner == input.Owner ||
                    (this.Owner != null &&
                    this.Owner.Equals(input.Owner))
                ) && 
                (
                    this.TableType == input.TableType ||
                    this.TableType.Equals(input.TableType)
                );
        }

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 : HypervCloneParameters.cs
with Apache License 2.0
from cohesity

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

            return 
                (
                    this.DisableNetwork == input.DisableNetwork ||
                    (this.DisableNetwork != null &&
                    this.DisableNetwork.Equals(input.DisableNetwork))
                ) && 
                (
                    this.NetworkId == input.NetworkId ||
                    (this.NetworkId != null &&
                    this.NetworkId.Equals(input.NetworkId))
                ) && 
                (
                    this.PoweredOn == input.PoweredOn ||
                    (this.PoweredOn != null &&
                    this.PoweredOn.Equals(input.PoweredOn))
                ) && 
                (
                    this.Prefix == input.Prefix ||
                    (this.Prefix != null &&
                    this.Prefix.Equals(input.Prefix))
                ) && 
                (
                    this.PreserveTags == input.PreserveTags ||
                    (this.PreserveTags != null &&
                    this.PreserveTags.Equals(input.PreserveTags))
                ) && 
                (
                    this.ResourceId == input.ResourceId ||
                    (this.ResourceId != null &&
                    this.ResourceId.Equals(input.ResourceId))
                ) && 
                (
                    this.Suffix == input.Suffix ||
                    (this.Suffix != null &&
                    this.Suffix.Equals(input.Suffix))
                );
        }

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

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

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

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

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

            return 
                (
                    this.DatastoreId == input.DatastoreId ||
                    (this.DatastoreId != null &&
                    this.DatastoreId.Equals(input.DatastoreId))
                ) && 
                (
                    this.DisableNetwork == input.DisableNetwork ||
                    (this.DisableNetwork != null &&
                    this.DisableNetwork.Equals(input.DisableNetwork))
                ) && 
                (
                    this.NetworkId == input.NetworkId ||
                    (this.NetworkId != null &&
                    this.NetworkId.Equals(input.NetworkId))
                ) && 
                (
                    this.PoweredOn == input.PoweredOn ||
                    (this.PoweredOn != null &&
                    this.PoweredOn.Equals(input.PoweredOn))
                ) && 
                (
                    this.Prefix == input.Prefix ||
                    (this.Prefix != null &&
                    this.Prefix.Equals(input.Prefix))
                ) && 
                (
                    this.PreserveTags == input.PreserveTags ||
                    (this.PreserveTags != null &&
                    this.PreserveTags.Equals(input.PreserveTags))
                ) && 
                (
                    this.ResourceId == input.ResourceId ||
                    (this.ResourceId != null &&
                    this.ResourceId.Equals(input.ResourceId))
                ) && 
                (
                    this.Suffix == input.Suffix ||
                    (this.Suffix != null &&
                    this.Suffix.Equals(input.Suffix))
                );
        }

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

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

            return 
                (
                    this.IsHighlyAvailable == input.IsHighlyAvailable ||
                    (this.IsHighlyAvailable != null &&
                    this.IsHighlyAvailable.Equals(input.IsHighlyAvailable))
                ) && 
                (
                    this.Version == input.Version ||
                    (this.Version != null &&
                    this.Version.Equals(input.Version))
                ) && 
                (
                    this.VmBackupStatus == input.VmBackupStatus ||
                    this.VmBackupStatus.Equals(input.VmBackupStatus)
                ) && 
                (
                    this.VmBackupType == input.VmBackupType ||
                    this.VmBackupType.Equals(input.VmBackupType)
                );
        }

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

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

            return 
                (
                    this.AwsKms == input.AwsKms ||
                    (this.AwsKms != null &&
                    this.AwsKms.Equals(input.AwsKms))
                ) && 
                (
                    this.ConnectionStatus == input.ConnectionStatus ||
                    (this.ConnectionStatus != null &&
                    this.ConnectionStatus.Equals(input.ConnectionStatus))
                ) && 
                (
                    this.CryptsoftKms == input.CryptsoftKms ||
                    (this.CryptsoftKms != null &&
                    this.CryptsoftKms.Equals(input.CryptsoftKms))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.ServerName == input.ServerName ||
                    (this.ServerName != null &&
                    this.ServerName.Equals(input.ServerName))
                ) && 
                (
                    this.ServerType == input.ServerType ||
                    this.ServerType.Equals(input.ServerType)
                );
        }

See More Examples