public override int GetHashCode()
{
unchecked
{
return(((FeatureName?.GetHashCode() ?? 0) * 397) ^ EqualityComparer <TValue> .Default.GetHashCode(FeatureValue));
}
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (FeatureName != null)
{
hashCode = hashCode * 59 + FeatureName.GetHashCode();
}
if (FeatureDescription != null)
{
hashCode = hashCode * 59 + FeatureDescription.GetHashCode();
}
if (ActivePercentage != null)
{
hashCode = hashCode * 59 + ActivePercentage.GetHashCode();
}
if (CookieName != null)
{
hashCode = hashCode * 59 + CookieName.GetHashCode();
}
if (CookieMaxAge != null)
{
hashCode = hashCode * 59 + CookieMaxAge.GetHashCode();
}
return(hashCode);
}
}
public void EqualsReturnFalseWhenCallsWithOtherValueObject()
{
FeatureName otherValue = new FeatureName(Exp.Namespace + "OtherName");
Assert.False(basicValue == otherValue);
Assert.False(basicValue.Equals(otherValue));
}
public void EqualsReturnTrueWhenCallsWithSameValueObject()
{
FeatureName sameValue = new FeatureName(Exp.Namespace + "SomeName");
Assert.True(basicValue == sameValue);
Assert.True(basicValue.Equals(sameValue));
}
public override int GetHashCode()
{
unchecked
{
return(((FeatureName?.GetHashCode() ?? 0) * 397) ^ ErrorGain.GetHashCode());
}
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (FeatureName != null)
{
hashCode = hashCode * 59 + FeatureName.GetHashCode();
}
if (FeatureDescription != null)
{
hashCode = hashCode * 59 + FeatureDescription.GetHashCode();
}
if (HttpHeaderName != null)
{
hashCode = hashCode * 59 + HttpHeaderName.GetHashCode();
}
if (HttpHeaderValuepattern != null)
{
hashCode = hashCode * 59 + HttpHeaderValuepattern.GetHashCode();
}
return(hashCode);
}
}
public override int GetHashCode()
{
unchecked
{
return(((FeatureName != null ? FeatureName.GetHashCode() : 0) * 397) ^ Value.GetHashCode());
}
}
/// <summary>
/// Returns true if ComAdobeGraniteFragsImplCheckHttpHeaderFlagProperties instances are equal
/// </summary>
/// <param name="other">Instance of ComAdobeGraniteFragsImplCheckHttpHeaderFlagProperties to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ComAdobeGraniteFragsImplCheckHttpHeaderFlagProperties other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
FeatureName == other.FeatureName ||
FeatureName != null &&
FeatureName.Equals(other.FeatureName)
) &&
(
FeatureDescription == other.FeatureDescription ||
FeatureDescription != null &&
FeatureDescription.Equals(other.FeatureDescription)
) &&
(
HttpHeaderName == other.HttpHeaderName ||
HttpHeaderName != null &&
HttpHeaderName.Equals(other.HttpHeaderName)
) &&
(
HttpHeaderValuepattern == other.HttpHeaderValuepattern ||
HttpHeaderValuepattern != null &&
HttpHeaderValuepattern.Equals(other.HttpHeaderValuepattern)
));
}
public void EqualsReturnTrueWhenCallsWithSameReference()
{
FeatureName sameReference = basicValue;
Assert.True(basicValue == sameReference);
Assert.True(basicValue.Equals(sameReference));
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>A hash code for the current <see cref="T:System.Object" />.</returns>
public override int GetHashCode()
{
return(CustomProperties.GetHashCode()
^ (string.IsNullOrWhiteSpace(Description) ? 0 : Description.GetHashCode())
^ (string.IsNullOrWhiteSpace(DisplayName) ? 0 : DisplayName.GetHashCode())
^ (string.IsNullOrWhiteSpace(FeatureName) ? 0 : FeatureName.GetHashCode())
^ FeatureState.GetHashCode()
^ RestartRequired.GetHashCode());
}
public void EqualsReturnFalseWhenCallsWithNullReference()
{
FeatureName nullReference = null;
Assert.False(basicValue == nullReference);
Assert.False(basicValue.Equals(nullReference));
Assert.True(nullReference == null);
}
/// <summary>
/// Finds the matching nodes of a <see cref="IClassConstantExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedResult">The expression result types upon return.</param>
/// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
/// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
/// <param name="expressionConstant">The expression constant upon return.</param>
/// <param name="resolvedFinalFeature">The feature if the end of the path is a feature.</param>
/// <param name="resolvedFinalDiscrete">The discrete if the end of the path is a discrete.</param>
/// <param name="resolvedClassTypeName">The class type name upon return.</param>
/// <param name="resolvedClassType">The class name upon return.</param>
public static bool ResolveCompilerReferences(IClassConstantExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant, out IConstantFeature resolvedFinalFeature, out IDiscrete resolvedFinalDiscrete, out ITypeName resolvedClassTypeName, out IClassType resolvedClassType)
{
resolvedResult = null;
resolvedException = null;
constantSourceList = new SealableList <IExpression>();
expressionConstant = NeutralLanguageConstant.NotConstant;
resolvedFinalFeature = null;
resolvedFinalDiscrete = null;
resolvedClassTypeName = null;
resolvedClassType = null;
IIdentifier ClassIdentifier = (IIdentifier)node.ClassIdentifier;
IIdentifier ConstantIdentifier = (IIdentifier)node.ConstantIdentifier;
IClass EmbeddingClass = node.EmbeddingClass;
string ValidClassText = ClassIdentifier.ValidText.Item;
string ValidConstantText = ConstantIdentifier.ValidText.Item;
ISealableDictionary <string, IImportedClass> ClassTable = EmbeddingClass.ImportedClassTable;
if (!ClassTable.ContainsKey(ValidClassText))
{
errorList.AddError(new ErrorUnknownIdentifier(ClassIdentifier, ValidClassText));
return(false);
}
IClass BaseClass = ClassTable[ValidClassText].Item;
resolvedClassTypeName = BaseClass.ResolvedClassTypeName.Item;
resolvedClassType = BaseClass.ResolvedClassType.Item;
ITypeName ConstantTypeName;
ICompiledType ConstantType;
ISealableDictionary <IFeatureName, IDiscrete> DiscreteTable = BaseClass.DiscreteTable;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = BaseClass.FeatureTable;
if (FeatureName.TableContain(DiscreteTable, ValidConstantText, out IFeatureName Key, out IDiscrete Discrete))
{
if (!Expression.IsLanguageTypeAvailable(LanguageClasses.Number.Guid, node, out ITypeName NumberTypeName, out ICompiledType NumberType))
{
errorList.AddError(new ErrorNumberTypeMissing(node));
return(false);
}
if (Discrete.NumericValue.IsAssigned)
{
constantSourceList.Add((IExpression)Discrete.NumericValue.Item);
}
else
{
expressionConstant = new DiscreteLanguageConstant(Discrete);
}
resolvedFinalDiscrete = Discrete;
ConstantTypeName = NumberTypeName;
ConstantType = NumberType;
}
private static bool CheckAssignemntIdentifier(IErrorList errorList, ISealableDictionary <IFeatureName, IFeatureInstance> featureTable, ISealableDictionary <string, ICompiledFeature> assignedFeatureTable, IIdentifier identifierItem)
{
bool Success = true;
string ValidIdentifierText = identifierItem.ValidText.Item;
if (assignedFeatureTable.ContainsKey(ValidIdentifierText))
{
errorList.AddError(new ErrorIdentifierAlreadyListed(identifierItem, ValidIdentifierText));
Success = false;
}
else
{
if (FeatureName.TableContain(featureTable, ValidIdentifierText, out IFeatureName Key, out IFeatureInstance FeatureItem))
{
bool ValidFeature = false;
if (FeatureItem.Feature is AttributeFeature AsAttributeFeature)
{
ValidFeature = true;
}
else if (FeatureItem.Feature is IPropertyFeature AsPropertyFeature)
{
bool IsHandled = false;
switch (AsPropertyFeature.PropertyKind)
{
case BaseNode.UtilityType.ReadOnly:
ValidFeature = !AsPropertyFeature.GetterBody.IsAssigned;
IsHandled = true;
break;
case BaseNode.UtilityType.ReadWrite:
ValidFeature = !(AsPropertyFeature.GetterBody.IsAssigned && !AsPropertyFeature.SetterBody.IsAssigned);
IsHandled = true;
break;
case BaseNode.UtilityType.WriteOnly:
ValidFeature = true;
IsHandled = true;
break;
}
Debug.Assert(IsHandled);
}
if (ValidFeature)
{
assignedFeatureTable.Add(ValidIdentifierText, FeatureItem.Feature);
}
else
{
errorList.AddError(new ErrorAttributeOrPropertyRequired(identifierItem, ValidIdentifierText));
Success = false;
}
}
protected override void OnAppearing()
{
base.OnAppearing();
if (Item.Owner == null)
{
Item.Owner = App.User;
}
BindingContext = Item;
FeatureName.SetBinding(Entry.TextProperty, "Name");
FeatureDescription.SetBinding(Entry.TextProperty, "Description");
}
public async stt::Task GetFeatureResourceNamesAsync()
{
moq::Mock <GkeHub.GkeHubClient> mockGrpcClient = new moq::Mock <GkeHub.GkeHubClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetFeatureRequest request = new GetFeatureRequest
{
FeatureName = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]"),
};
Feature expectedResponse = new Feature
{
FeatureName = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]"),
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
ResourceState = new FeatureResourceState(),
Spec = new CommonFeatureSpec(),
MembershipSpecs =
{
{
"key8a0b6e3c",
new MembershipFeatureSpec()
},
},
State = new CommonFeatureState(),
MembershipStates =
{
{
"key8a0b6e3c",
new MembershipFeatureState()
},
},
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
DeleteTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.GetFeatureAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Feature>(stt::Task.FromResult(expectedResponse), null, null, null, null));
GkeHubClient client = new GkeHubClientImpl(mockGrpcClient.Object, null);
Feature responseCallSettings = await client.GetFeatureAsync(request.FeatureName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Feature responseCancellationToken = await client.GetFeatureAsync(request.FeatureName, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public void GetFeatureResourceNames()
{
moq::Mock <GkeHub.GkeHubClient> mockGrpcClient = new moq::Mock <GkeHub.GkeHubClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetFeatureRequest request = new GetFeatureRequest
{
FeatureName = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]"),
};
Feature expectedResponse = new Feature
{
FeatureName = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]"),
Labels =
{
{
"key8a0b6e3c",
"value60c16320"
},
},
ResourceState = new FeatureResourceState(),
Spec = new CommonFeatureSpec(),
MembershipSpecs =
{
{
"key8a0b6e3c",
new MembershipFeatureSpec()
},
},
State = new CommonFeatureState(),
MembershipStates =
{
{
"key8a0b6e3c",
new MembershipFeatureState()
},
},
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
DeleteTime = new wkt::Timestamp(),
};
mockGrpcClient.Setup(x => x.GetFeature(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
GkeHubClient client = new GkeHubClientImpl(mockGrpcClient.Object, null);
Feature response = client.GetFeature(request.FeatureName);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Gets the object a path is refering to.
/// </summary>
/// <param name="baseClass">The class where the path is used.</param>
/// <param name="baseType">The type at the start of the path.</param>
/// <param name="localScope">The local scope.</param>
/// <param name="validPath">The path.</param>
/// <param name="index">Index of the current identifier in the path.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="finalFeature">The feature at the end of the path, if any, upon return.</param>
/// <param name="finalDiscrete">The discrete at the end of the path, if any, upon return.</param>
/// <param name="finalTypeName">The type name of the result.</param>
/// <param name="finalType">The type of the result.</param>
/// <param name="inheritBySideAttribute">Inherited from an effective body.</param>
public static bool GetQualifiedPathFinalType(IClass baseClass, ICompiledType baseType, ISealableDictionary <string, IScopeAttributeFeature> localScope, IList <IIdentifier> validPath, int index, IErrorList errorList, out ICompiledFeature finalFeature, out IDiscrete finalDiscrete, out ITypeName finalTypeName, out ICompiledType finalType, out bool inheritBySideAttribute)
{
finalFeature = null;
finalDiscrete = null;
finalTypeName = null;
finalType = null;
inheritBySideAttribute = false;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = baseType.FeatureTable;
IIdentifier ValidIdentifier = validPath[index];
string ValidText = ValidIdentifier.ValidText.Item;
if (index == 0 && localScope.ContainsKey(ValidText))
{
return(GetQualifiedPathFinalTypeFromLocal(baseClass, baseType, localScope, validPath, index, errorList, out finalFeature, out finalDiscrete, out finalTypeName, out finalType, out inheritBySideAttribute));
}
else if (FeatureName.TableContain(FeatureTable, ValidText, out IFeatureName Key, out IFeatureInstance Instance))
{
return(GetQualifiedPathFinalTypeAsFeature(baseClass, baseType, localScope, validPath, index, errorList, Instance, out finalFeature, out finalDiscrete, out finalTypeName, out finalType, out inheritBySideAttribute));
}
/// <summary>
/// Apply changes in this instance to arguments.
/// </summary>
/// <param name="importedClassTable">The table of imported classes</param>
/// <param name="exportTable">The list of exports to change.</param>
/// <param name="errorList">The list of errors found.</param>
public virtual bool ApplyChange(ISealableDictionary <string, IImportedClass> importedClassTable, ISealableDictionary <IFeatureName, ISealableDictionary <string, IClass> > exportTable, IErrorList errorList)
{
if (!ExportIdentifierExists(exportTable, errorList, out IFeatureName CurrentExportName, out ISealableDictionary <string, IClass> CurrentClassTable))
{
return(false);
}
ISealableDictionary <string, ISealableDictionary <string, IClass> > ListedExportTable = new SealableDictionary <string, ISealableDictionary <string, IClass> >(); // string (export name) -> hashtable // string (class name) -> Class
ISealableDictionary <string, IClass> ListedClassTable = new SealableDictionary <string, IClass>(); // string (class name) -> Class
bool InvalidExportChange = false;
foreach (IIdentifier IdentifierItem in IdentifierList)
{
Debug.Assert(IdentifierItem.ValidText.IsAssigned);
string ValidIdentifier = IdentifierItem.ValidText.Item;
if (FeatureName.TableContain(exportTable, ValidIdentifier, out IFeatureName EntryName, out ISealableDictionary <string, IClass> ListedExport))
{
Debug.Assert(!ListedExportTable.ContainsKey(ValidIdentifier));
ListedExportTable.Add(ValidIdentifier, ListedExport);
}
public override int GetHashCode()
{
int hash = 1;
if (FeatureName.Length != 0)
{
hash ^= FeatureName.GetHashCode();
}
if (FeatureType != global::Asgt.Type.FeatureStat.Types.Type.Int)
{
hash ^= FeatureType.GetHashCode();
}
if (InformationGain != 0F)
{
hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(InformationGain);
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
/// <summary>
/// Returns true if ComAdobeGraniteFragsImplRandomFeatureProperties instances are equal
/// </summary>
/// <param name="other">Instance of ComAdobeGraniteFragsImplRandomFeatureProperties to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(ComAdobeGraniteFragsImplRandomFeatureProperties other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
FeatureName == other.FeatureName ||
FeatureName != null &&
FeatureName.Equals(other.FeatureName)
) &&
(
FeatureDescription == other.FeatureDescription ||
FeatureDescription != null &&
FeatureDescription.Equals(other.FeatureDescription)
) &&
(
ActivePercentage == other.ActivePercentage ||
ActivePercentage != null &&
ActivePercentage.Equals(other.ActivePercentage)
) &&
(
CookieName == other.CookieName ||
CookieName != null &&
CookieName.Equals(other.CookieName)
) &&
(
CookieMaxAge == other.CookieMaxAge ||
CookieMaxAge != null &&
CookieMaxAge.Equals(other.CookieMaxAge)
));
}
///--------------------------------------------------------------------------------
/// <summary>This method determines whether or not any metadata is
/// different between the input instance and the current instance.</summary>
///
/// <param name="inputFeature">The feature to compare metadata.</param>
///--------------------------------------------------------------------------------
public bool IsIdenticalMetadata(Feature inputFeature)
{
if (FeatureName.GetString() != inputFeature.FeatureName.GetString())
{
return(false);
}
if (SolutionID.GetGuid() != inputFeature.SolutionID.GetGuid())
{
return(false);
}
if (IsAutoUpdated.GetBool() != inputFeature.IsAutoUpdated.GetBool())
{
return(false);
}
if (Description.GetString() != inputFeature.Description.GetString())
{
return(false);
}
#region protected
#endregion protected
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="mgr"></param>
/// <returns></returns>
public override IFeature FromXml(XmlNode node, XmlNamespaceManager mgr)
{
if (node != null && node.HasChildNodes)
{
if (node.FirstChild.Attributes.Count > 0)
{
Id = node.FirstChild.Attributes["gml:id"].InnerText;
}
}
var periodicDateRangeNodes = node.FirstChild.SelectNodes("periodicDateRange", mgr);
if (periodicDateRangeNodes != null && periodicDateRangeNodes.Count > 0)
{
var dateRanges = new List <DateRange>();
foreach (XmlNode periodicDateRangeNode in periodicDateRangeNodes)
{
var newDateRange = new DateRange();
newDateRange.FromXml(periodicDateRangeNode, mgr);
dateRanges.Add(newDateRange);
}
PeriodicDateRange = dateRanges.ToArray();
}
var fixedDateRangeNode = node.FirstChild.SelectSingleNode("fixedDateRange", mgr);
if (fixedDateRangeNode != null && fixedDateRangeNode.HasChildNodes)
{
FixedDateRange = new DateRange();
FixedDateRange.FromXml(fixedDateRangeNode, mgr);
}
var featureNameNodes = node.FirstChild.SelectNodes("featureName", mgr);
if (featureNameNodes != null && featureNameNodes.Count > 0)
{
var featureNames = new List <FeatureName>();
foreach (XmlNode featureNameNode in featureNameNodes)
{
var newFeatureName = new FeatureName();
newFeatureName.FromXml(featureNameNode, mgr);
featureNames.Add(newFeatureName);
}
FeatureName = featureNames.ToArray();
}
var sourceIndication = node.FirstChild.SelectSingleNode("sourceIndication", mgr);
if (sourceIndication != null && sourceIndication.HasChildNodes)
{
SourceIndication = new SourceIndication();
SourceIndication.FromXml(sourceIndication, mgr);
}
var textContentNodes = node.FirstChild.SelectNodes("textContent", mgr);
if (textContentNodes != null && textContentNodes.Count > 0)
{
var textContents = new List <TextContent>();
foreach (XmlNode textContentNode in textContentNodes)
{
if (textContentNode != null && textContentNode.HasChildNodes)
{
var content = new TextContent();
content.FromXml(textContentNode, mgr);
textContents.Add(content);
}
}
TextContent = textContents.ToArray();
}
var classificationNode = node.FirstChild.SelectSingleNode("classification", mgr);
if (classificationNode != null && classificationNode.HasChildNodes)
{
Classification = classificationNode.FirstChild.InnerText;
}
var copyrightNode = node.FirstChild.SelectSingleNode("copyright");
if (copyrightNode != null && copyrightNode.HasChildNodes)
{
Copyright = copyrightNode.FirstChild.InnerText;
}
var maximumDisplayScaleNode = node.FirstChild.SelectSingleNode("maximumDisplayScale", mgr);
if (maximumDisplayScaleNode != null && maximumDisplayScaleNode.HasChildNodes)
{
MaximumDisplayScale = maximumDisplayScaleNode.FirstChild.InnerText;
}
var horizontalDatumReferenceNode = node.FirstChild.SelectSingleNode("horizontalDatumReference", mgr);
if (horizontalDatumReferenceNode != null && horizontalDatumReferenceNode.HasChildNodes)
{
HorizontalDatumReference = horizontalDatumReferenceNode.FirstChild.InnerText;
}
var horizontalDatumValueNode = node.FirstChild.SelectSingleNode("horizontalDatumValue", mgr);
if (horizontalDatumValueNode != null && horizontalDatumValueNode.HasChildNodes)
{
HorizontalDatumValue = horizontalDatumValueNode.FirstChild.InnerText;
}
var verticalDatumNode = node.FirstChild.SelectSingleNode("verticalDatum", mgr);
if (verticalDatumNode != null && verticalDatumNode.HasChildNodes)
{
VerticalDatum = verticalDatumNode.FirstChild.InnerText;
}
var soundingDatumNode = node.FirstChild.SelectSingleNode("soundingDatum", mgr);
if (soundingDatumNode != null && soundingDatumNode.HasChildNodes)
{
SoundingDatum = soundingDatumNode.FirstChild.InnerText;
}
var productTypeNode = node.FirstChild.SelectSingleNode("productType", mgr);
if (productTypeNode != null && productTypeNode.HasChildNodes)
{
ProductType = productTypeNode.FirstChild.InnerText;
}
var minimumDisplayScaleNode = node.FirstChild.SelectSingleNode("minimumDisplayScale", mgr);
if (minimumDisplayScaleNode != null && minimumDisplayScaleNode.HasChildNodes)
{
MinimumDisplayScale = minimumDisplayScaleNode.FirstChild.InnerText;
}
var issueDateNode = node.FirstChild.SelectSingleNode("issueDate", mgr);
if (issueDateNode != null && issueDateNode.HasChildNodes)
{
IssueDate = issueDateNode.FirstChild.InnerText;
}
var purposeNode = node.FirstChild.SelectSingleNode("purpose", mgr);
if (purposeNode != null && purposeNode.HasChildNodes)
{
Purpose = purposeNode.FirstChild.InnerText;
}
var informationNodes = node.FirstChild.SelectNodes("information", mgr);
if (informationNodes != null && informationNodes.Count > 0)
{
var informations = new List <Information>();
foreach (XmlNode informationNode in informationNodes)
{
if (informationNode != null && informationNode.HasChildNodes)
{
var newInformation = new Information();
newInformation.FromXml(informationNode, mgr);
informations.Add(newInformation);
}
}
Information = informations.ToArray();
}
var priceNodes = node.FirstChild.SelectNodes("price", mgr);
if (priceNodes != null && priceNodes.Count > 0)
{
var prices = new List <Price>();
foreach (XmlNode priceNode in priceNodes)
{
if (priceNode != null && priceNode.HasChildNodes)
{
var newPrice = new Price();
newPrice.FromXml(priceNode, mgr);
prices.Add(newPrice);
}
}
Price = prices.ToArray();
}
var producingAgencyNode = node.FirstChild.SelectSingleNode("producingAgency", mgr);
if (producingAgencyNode != null && producingAgencyNode.HasChildNodes)
{
ProducingAgency = new ProducingAgency();
ProducingAgency.FromXml(producingAgencyNode, mgr);
}
var chartNumberNode = node.FirstChild.SelectSingleNode("chartNumber", mgr);
if (chartNumberNode != null && chartNumberNode.HasChildNodes)
{
ChartNumber = chartNumberNode.FirstChild.InnerText;
}
var distributionStatusNode = node.FirstChild.SelectSingleNode("distributionStatus", mgr);
if (distributionStatusNode != null && distributionStatusNode.HasChildNodes)
{
DistributionStatus = distributionStatusNode.FirstChild.InnerText;
}
var compilationScaleNode = node.FirstChild.SelectSingleNode("compilationScale", mgr);
if (compilationScaleNode != null && compilationScaleNode.HasChildNodes)
{
CompilationScale = compilationScaleNode.FirstChild.InnerText;
}
var editionNumberNode = node.FirstChild.SelectSingleNode("editionNumber", mgr);
if (editionNumberNode != null && editionNumberNode.HasChildNodes)
{
EditionNumber = editionNumberNode.FirstChild.InnerText;
}
var specificUsageNode = node.FirstChild.SelectSingleNode("specificUsage", mgr);
if (specificUsageNode != null && specificUsageNode.HasChildNodes)
{
SpecificUsage = specificUsageNode.FirstChild.InnerText;
}
var producerCodeNode = node.FirstChild.SelectSingleNode("producerCode", mgr);
if (producerCodeNode != null && producerCodeNode.HasChildNodes)
{
ProducerCode = producerCodeNode.FirstChild.InnerText;
}
var producerNationNode = node.FirstChild.SelectSingleNode("producerNation", mgr);
if (producerNationNode != null && producerNationNode.HasChildNodes)
{
ProducerNation = producerNationNode.FirstChild.InnerText;
}
var datasetNameNodes = node.FirstChild.SelectNodes("datasetName", mgr);
if (datasetNameNodes != null && datasetNameNodes.Count > 0)
{
var datasets = new List <string>();
foreach (XmlNode datasetNameNode in datasetNameNodes)
{
if (datasetNameNode != null && datasetNameNode.HasChildNodes)
{
datasets.Add(datasetNameNode.FirstChild.InnerText);
}
}
DatasetName = datasets.ToArray();
}
var updateDateNode = node.FirstChild.SelectSingleNode("updateDate", mgr);
if (updateDateNode != null && updateDateNode.HasChildNodes)
{
UpdateDate = updateDateNode.FirstChild.InnerText;
}
var updateNumberNode = node.FirstChild.SelectSingleNode("updateNumber", mgr);
if (updateNumberNode != null && updateNumberNode.HasChildNodes)
{
UpdateNumber = updateNumberNode.FirstChild.InnerText;
}
var productSpecificationNode = node.FirstChild.SelectSingleNode("productSpecification", mgr);
if (productSpecificationNode != null && productSpecificationNode.HasChildNodes)
{
ProductSpecification = new ReferenceSpecification();
ProductSpecification.FromXml(productSpecificationNode, mgr);
}
var linkNodes = node.FirstChild.SelectNodes("*[boolean(@xlink:href)]", mgr);
if (linkNodes != null && linkNodes.Count > 0)
{
var links = new List <Link>();
foreach (XmlNode linkNode in linkNodes)
{
var newLink = new Link();
newLink.FromXml(linkNode, mgr);
links.Add(newLink);
}
Links = links.ToArray();
}
return(this);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="mgr"></param>
/// <returns></returns>
public override IFeature FromXml(XmlNode node, XmlNamespaceManager mgr)
{
if (node != null && node.HasChildNodes)
{
if (node.FirstChild.Attributes.Count > 0)
{
Id = node.FirstChild.Attributes["gml:id"].InnerText;
}
}
var featureObjectIdentifierNode = node.FirstChild.SelectSingleNode("s100:featureObjectIdentifier", mgr);
if (featureObjectIdentifierNode != null && featureObjectIdentifierNode.HasChildNodes)
{
FeatureObjectIdentifier = new FeatureObjectIdentifier();
FeatureObjectIdentifier.FromXml(featureObjectIdentifierNode, mgr);
}
var periodicDateRangeNodes = node.FirstChild.SelectNodes("periodicDateRange", mgr);
if (periodicDateRangeNodes != null && periodicDateRangeNodes.Count > 0)
{
var dateRanges = new List <DateRange>();
foreach (XmlNode periodicDateRangeNode in periodicDateRangeNodes)
{
var newDateRange = new DateRange();
newDateRange.FromXml(periodicDateRangeNode, mgr);
dateRanges.Add(newDateRange);
}
PeriodicDateRange = dateRanges.ToArray();
}
var fixedDateRangeNode = node.FirstChild.SelectSingleNode("fixedDateRange", mgr);
if (fixedDateRangeNode != null && fixedDateRangeNode.HasChildNodes)
{
FixedDateRange = new DateRange();
FixedDateRange.FromXml(fixedDateRangeNode, mgr);
}
var featureNameNodes = node.FirstChild.SelectNodes("featureName", mgr);
if (featureNameNodes != null && featureNameNodes.Count > 0)
{
var featureNames = new List <FeatureName>();
foreach (XmlNode featureNameNode in featureNameNodes)
{
var newFeatureName = new FeatureName();
newFeatureName.FromXml(featureNameNode, mgr);
featureNames.Add(newFeatureName);
}
FeatureName = featureNames.ToArray();
}
var sourceIndication = node.FirstChild.SelectSingleNode("sourceIndication", mgr);
if (sourceIndication != null && sourceIndication.HasChildNodes)
{
SourceIndication = new SourceIndication();
SourceIndication.FromXml(sourceIndication, mgr);
}
var textContentNodes = node.FirstChild.SelectNodes("textContent", mgr);
if (textContentNodes != null && textContentNodes.Count > 0)
{
var textContents = new List <TextContent>();
foreach (XmlNode textContentNode in textContentNodes)
{
if (textContentNode != null && textContentNode.HasChildNodes)
{
var content = new TextContent();
content.FromXml(textContentNode, mgr);
textContents.Add(content);
}
}
TextContent = textContents.ToArray();
}
var categoryOfFrctAndWarningAreaNode = node.FirstChild.SelectSingleNode("categoryOfFrcstAndWarningArea", mgr);
if (categoryOfFrctAndWarningAreaNode != null && categoryOfFrctAndWarningAreaNode.HasChildNodes)
{
CategoryOfFrctAndWarningArea = categoryOfFrctAndWarningAreaNode.FirstChild.InnerText;
}
var nationalityNode = node.FirstChild.SelectSingleNode("nationality", mgr);
if (nationalityNode != null && nationalityNode.HasChildNodes)
{
Nationality = nationalityNode.FirstChild.InnerText;
}
var statusNode = node.FirstChild.SelectSingleNode("status", mgr);
if (statusNode != null && statusNode.HasChildNodes)
{
Status = statusNode.FirstChild.InnerText;
}
var linkNodes = node.FirstChild.SelectNodes("*[boolean(@xlink:href)]", mgr);
if (linkNodes != null && linkNodes.Count > 0)
{
var links = new List <Link>();
foreach (XmlNode linkNode in linkNodes)
{
var newLink = new Link();
newLink.FromXml(linkNode, mgr);
links.Add(newLink);
}
Links = links.ToArray();
}
return(this);
}
public void EqualsReturnFalseWhenCallsWithOtherValueObject()
{
FeatureName otherValue = new FeatureName(Exp.Namespace + "OtherName");
Assert.False(basicValue == otherValue);
Assert.False(basicValue.Equals(otherValue));
}
public void EqualsReturnTrueWhenCallsWithSameValueObject()
{
FeatureName sameValue = new FeatureName(Exp.Namespace + "SomeName");
Assert.True(basicValue == sameValue);
Assert.True(basicValue.Equals(sameValue));
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="mgr"></param>
/// <returns></returns>
public override IFeature FromXml(XmlNode node, XmlNamespaceManager mgr)
{
if (node != null && node.HasChildNodes)
{
if (node.FirstChild.Attributes.Count > 0)
{
Id = node.FirstChild.Attributes["gml:id"].InnerText;
}
}
var periodicDateRangeNodes = node.FirstChild.SelectNodes("periodicDateRange", mgr);
if (periodicDateRangeNodes != null && periodicDateRangeNodes.Count > 0)
{
var dateRanges = new List <DateRange>();
foreach (XmlNode periodicDateRangeNode in periodicDateRangeNodes)
{
var newDateRange = new DateRange();
newDateRange.FromXml(periodicDateRangeNode, mgr);
dateRanges.Add(newDateRange);
}
PeriodicDateRange = dateRanges.ToArray();
}
var fixedDateRangeNode = node.FirstChild.SelectSingleNode("fixedDateRange", mgr);
if (fixedDateRangeNode != null && fixedDateRangeNode.HasChildNodes)
{
FixedDateRange = new DateRange();
FixedDateRange.FromXml(fixedDateRangeNode, mgr);
}
var featureNameNodes = node.FirstChild.SelectNodes("featureName", mgr);
if (featureNameNodes != null && featureNameNodes.Count > 0)
{
var featureNames = new List <FeatureName>();
foreach (XmlNode featureNameNode in featureNameNodes)
{
var newFeatureName = new FeatureName();
newFeatureName.FromXml(featureNameNode, mgr);
featureNames.Add(newFeatureName);
}
FeatureName = featureNames.ToArray();
}
var sourceIndication = node.FirstChild.SelectSingleNode("sourceIndication", mgr);
if (sourceIndication != null && sourceIndication.HasChildNodes)
{
SourceIndication = new SourceIndication();
SourceIndication.FromXml(sourceIndication, mgr);
}
var textContentNodes = node.FirstChild.SelectNodes("textContent", mgr);
if (textContentNodes != null && textContentNodes.Count > 0)
{
var textContents = new List <TextContent>();
foreach (XmlNode textContentNode in textContentNodes)
{
if (textContentNode != null && textContentNode.HasChildNodes)
{
var content = new TextContent();
content.FromXml(textContentNode, mgr);
textContents.Add(content);
}
}
TextContent = textContents.ToArray();
}
var categoryOfPilotNodes = node.FirstChild.SelectNodes("categoryOfPilot", mgr);
if (categoryOfPilotNodes != null && categoryOfPilotNodes.Count > 0)
{
var categories = new List <string>();
foreach (XmlNode categoryOfPilotNode in categoryOfPilotNodes)
{
var category = categoryOfPilotNode.FirstChild.InnerText;
categories.Add(category);
}
CategoryOfPilot = categories.ToArray();
}
var pilotQualificationNode = node.FirstChild.SelectSingleNode("pilotQualification", mgr);
if (pilotQualificationNode != null && pilotQualificationNode.HasChildNodes)
{
PilotQualification = pilotQualificationNode.FirstChild.InnerText;
}
var pilotRequestNode = node.FirstChild.SelectSingleNode("pilotRequest", mgr);
if (pilotRequestNode != null && pilotRequestNode.HasChildNodes)
{
PilotRequest = pilotRequestNode.FirstChild.InnerText;
}
var remotePilotNode = node.FirstChild.SelectSingleNode("remotePilot", mgr);
if (remotePilotNode != null && remotePilotNode.HasChildNodes)
{
RemotePilot = remotePilotNode.FirstChild.InnerText;
}
var noticeTimeNode = node.FirstChild.SelectSingleNode("noticeTime", mgr);
if (noticeTimeNode != null && noticeTimeNode.HasChildNodes)
{
NoticeTime = new NoticeTime();
NoticeTime.FromXml(noticeTimeNode, mgr);
}
var linkNodes = node.FirstChild.SelectNodes("*[boolean(@xlink:href)]", mgr);
if (linkNodes != null && linkNodes.Count > 0)
{
var links = new List <Link>();
foreach (XmlNode linkNode in linkNodes)
{
var newLink = new Link();
newLink.FromXml(linkNode, mgr);
links.Add(newLink);
}
Links = links.ToArray();
}
return(this);
}
/// <summary>
/// Finds the matching nodes of a <see cref="IAgentExpression"/>.
/// </summary>
/// <param name="node">The agent expression to check.</param>
/// <param name="errorList">The list of errors found.</param>
/// <param name="resolvedResult">The expression result types upon return.</param>
/// <param name="resolvedException">Exceptions the expression can throw upon return.</param>
/// <param name="constantSourceList">Sources of the constant expression upon return, if any.</param>
/// <param name="expressionConstant">The constant value upon return, if any.</param>
/// <param name="resolvedFeature">The feature found upon return.</param>
public static bool ResolveCompilerReferences(IAgentExpression node, IErrorList errorList, out IResultType resolvedResult, out IResultException resolvedException, out ISealableList <IExpression> constantSourceList, out ILanguageConstant expressionConstant, out ICompiledFeature resolvedFeature)
{
resolvedResult = null;
resolvedException = null;
constantSourceList = new SealableList <IExpression>();
expressionConstant = NeutralLanguageConstant.NotConstant;
resolvedFeature = null;
IIdentifier Delegated = (IIdentifier)node.Delegated;
Debug.Assert(Delegated.ValidText.IsAssigned);
string ValidText = Delegated.ValidText.Item;
IFeatureInstance FeatureInstance;
if (node.BaseType.IsAssigned)
{
IObjectType BaseType = (IObjectType)node.BaseType.Item;
ICompiledType ResolvedBaseType = BaseType.ResolvedType.Item;
ISealableDictionary <IFeatureName, IFeatureInstance> FeatureTable = null;
switch (ResolvedBaseType)
{
case IClassType AsClassType:
FeatureTable = AsClassType.FeatureTable;
break;
case IFormalGenericType AsFormalGenericType:
foreach (IConstraint Item in AsFormalGenericType.FormalGeneric.ConstraintList)
{
if (Item.ResolvedTypeWithRename.Item is IClassType Parent)
{
FeatureTable = Parent.FeatureTable;
if (FeatureName.TableContain(FeatureTable, ValidText, out IFeatureName ParentKey, out IFeatureInstance ParentFeatureInstance))
{
break;
}
}
}
break;
}
if (FeatureTable == null)
{
errorList.AddError(new ErrorClassTypeRequired(node));
return(false);
}
if (!FeatureName.TableContain(FeatureTable, ValidText, out IFeatureName Key, out FeatureInstance))
{
errorList.AddError(new ErrorUnknownIdentifier(node, ValidText));
return(false);
}
}
else
{
IClass EmbeddingClass = node.EmbeddingClass;
if (!FeatureName.TableContain(EmbeddingClass.FeatureTable, ValidText, out IFeatureName Key, out FeatureInstance))
{
errorList.AddError(new ErrorUnknownIdentifier(node, ValidText));
return(false);
}
}
Debug.Assert(FeatureInstance.Feature != null);
resolvedFeature = FeatureInstance.Feature;
resolvedResult = new ResultType(resolvedFeature.ResolvedAgentTypeName.Item, resolvedFeature.ResolvedAgentType.Item, string.Empty);
resolvedException = new ResultException();
expressionConstant = new AgentLanguageConstant(resolvedFeature);
#if COVERAGE
Debug.Assert(!node.IsComplex);
#endif
return(true);
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>A hash code for the current <see cref="T:System.Object" />.</returns>
public override int GetHashCode()
{
return((string.IsNullOrWhiteSpace(FeatureName) ? 0 : FeatureName.GetHashCode()) ^ State.GetHashCode());
}
public PrintSchemaFeature(FeatureName name)
{
_name = name;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="mgr"></param>
/// <returns></returns>
public override IFeature FromXml(XmlNode node, XmlNamespaceManager mgr)
{
if (node != null && node.HasChildNodes)
{
if (node.FirstChild.Attributes.Count > 0)
{
Id = node.FirstChild.Attributes["gml:id"].InnerText;
}
}
var fixedDateRangeNode = node.FirstChild.SelectSingleNode("fixedDateRange", mgr);
if (fixedDateRangeNode != null && fixedDateRangeNode.HasChildNodes)
{
FixedDateRange = new DateRange();
FixedDateRange.FromXml(fixedDateRangeNode, mgr);
}
var periodicDateRangeNodes = node.FirstChild.SelectNodes("periodicDateRange", mgr);
if (periodicDateRangeNodes != null && periodicDateRangeNodes.Count > 0)
{
var dateRanges = new List <DateRange>();
foreach (XmlNode periodicDateRangeNode in periodicDateRangeNodes)
{
var newDateRange = new DateRange();
newDateRange.FromXml(periodicDateRangeNode, mgr);
dateRanges.Add(newDateRange);
}
PeriodicDateRange = dateRanges.ToArray();
}
var featureNameNodes = node.FirstChild.SelectNodes("featureName", mgr);
if (featureNameNodes != null && featureNameNodes.Count > 0)
{
var featureNames = new List <FeatureName>();
foreach (XmlNode featureNameNode in featureNameNodes)
{
var newFeatureName = new FeatureName();
newFeatureName.FromXml(featureNameNode, mgr);
featureNames.Add(newFeatureName);
}
FeatureName = featureNames.ToArray();
}
var sourceIndicationNodes = node.FirstChild.SelectNodes("sourceIndication", mgr);
if (sourceIndicationNodes != null && sourceIndicationNodes.Count > 0)
{
var sourceIndications = new List <SourceIndication>();
foreach (XmlNode sourceIndicationNode in sourceIndicationNodes)
{
if (sourceIndicationNode != null && sourceIndicationNode.HasChildNodes)
{
var sourceIndication = new SourceIndication();
sourceIndication.FromXml(sourceIndicationNode, mgr);
sourceIndications.Add(sourceIndication);
}
}
SourceIndication = sourceIndications.ToArray();
}
var categoryOfAuthorityNode = node.FirstChild.SelectSingleNode("categoryOfAuthority", mgr);
if (categoryOfAuthorityNode != null && categoryOfAuthorityNode.HasChildNodes)
{
CategoryOfAuthority = categoryOfAuthorityNode.FirstChild.InnerText;
}
var linkNodes = node.FirstChild.SelectNodes("*[boolean(@xlink:href)]", mgr);
if (linkNodes != null && linkNodes.Count > 0)
{
var links = new List <Link>();
foreach (XmlNode linkNode in linkNodes)
{
var newLink = new Link();
newLink.FromXml(linkNode, mgr);
links.Add(newLink);
}
Links = links.ToArray();
}
return(this);
}
/// <summary>
/// Initializes a new instance of <see cref="FeatureDefinition"/>
/// </summary>
/// <param name="name"><see cref="FeatureName">Name</see> of the featurew</param>
/// <param name="subFeatures">Key/Value pairs of features and their definitions for any sub-features</param>
public FeatureDefinition(FeatureName name, IDictionary <Feature, FeatureDefinition> subFeatures)
{
Name = name;
SubFeatures = new ReadOnlyDictionary <Feature, FeatureDefinition>(subFeatures);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="mgr"></param>
/// <returns></returns>
public override IFeature FromXml(XmlNode node, XmlNamespaceManager mgr)
{
if (node != null && node.HasChildNodes)
{
if (node.FirstChild.Attributes.Count > 0)
{
Id = node.FirstChild.Attributes["gml:id"].InnerText;
}
}
var periodicDateRangeNodes = node.FirstChild.SelectNodes("periodicDateRange", mgr);
if (periodicDateRangeNodes != null && periodicDateRangeNodes.Count > 0)
{
var dateRanges = new List <DateRange>();
foreach (XmlNode periodicDateRangeNode in periodicDateRangeNodes)
{
var newDateRange = new DateRange();
newDateRange.FromXml(periodicDateRangeNode, mgr);
dateRanges.Add(newDateRange);
}
PeriodicDateRange = dateRanges.ToArray();
}
var fixedDateRangeNode = node.FirstChild.SelectSingleNode("fixedDateRange", mgr);
if (fixedDateRangeNode != null && fixedDateRangeNode.HasChildNodes)
{
FixedDateRange = new DateRange();
FixedDateRange.FromXml(fixedDateRangeNode, mgr);
}
var featureNameNodes = node.FirstChild.SelectNodes("featureName", mgr);
if (featureNameNodes != null && featureNameNodes.Count > 0)
{
var featureNames = new List <FeatureName>();
foreach (XmlNode featureNameNode in featureNameNodes)
{
var newFeatureName = new FeatureName();
newFeatureName.FromXml(featureNameNode, mgr);
featureNames.Add(newFeatureName);
}
FeatureName = featureNames.ToArray();
}
var sourceIndication = node.FirstChild.SelectSingleNode("sourceIndication", mgr);
if (sourceIndication != null && sourceIndication.HasChildNodes)
{
SourceIndication = new SourceIndication();
SourceIndication.FromXml(sourceIndication, mgr);
}
var textContentNodes = node.FirstChild.SelectNodes("textContent", mgr);
if (textContentNodes != null && textContentNodes.Count > 0)
{
var textContents = new List <TextContent>();
foreach (XmlNode textContentNode in textContentNodes)
{
if (textContentNode != null && textContentNode.HasChildNodes)
{
var content = new TextContent();
content.FromXml(textContentNode, mgr);
textContents.Add(content);
}
}
TextContent = textContents.ToArray();
}
var restrictionNodes = node.FirstChild.SelectNodes("restriction", mgr);
if (restrictionNodes != null && restrictionNodes.Count > 0)
{
var restrictions = new List <string>();
foreach (XmlNode restrictionNode in restrictionNodes)
{
if (restrictionNode != null && restrictionNode.HasChildNodes)
{
restrictions.Add(restrictionNode.FirstChild.InnerText);
}
}
Restriction = restrictions.ToArray();
}
var statusNodes = node.FirstChild.SelectNodes("status", mgr);
if (statusNodes != null && statusNodes.Count > 0)
{
var statuses = new List <string>();
foreach (XmlNode statusNode in statusNodes)
{
if (statusNode != null && statusNode.HasChildNodes)
{
statuses.Add(statusNode.FirstChild.InnerText);
}
}
Status = statuses.ToArray();
}
var linkNodes = node.FirstChild.SelectNodes("*[boolean(@xlink:href)]", mgr);
if (linkNodes != null && linkNodes.Count > 0)
{
var links = new List <Link>();
foreach (XmlNode linkNode in linkNodes)
{
var newLink = new Link();
newLink.FromXml(linkNode, mgr);
links.Add(newLink);
}
Links = links.ToArray();
}
return(this);
}
public virtual bool TryProvide(FeatureName name)
{
return(ImplementationNameTest(name) || FeaturePatternTest(name));
}
