public AttributeDefinition(IMetaModel metaModel, XmlElement element) { this.metaModel = metaModel; token = element.GetAttribute("token"); TextBuilder.SplitPrefix(token, '.', out assetTypeToken, out name); displayName = element.GetAttribute("displayname"); attributeType = (AttributeType)Enum.Parse(typeof(AttributeType), element.GetAttribute("attributetype")); isReadonly = bool.Parse(element.GetAttribute("isreadonly")); isRequired = bool.Parse(element.GetAttribute("isrequired")); isMultivalue = bool.Parse(element.GetAttribute("ismultivalue")); var baseelement = element.SelectSingleNode("Base") as XmlElement; if (baseelement != null) { baseToken = baseelement.GetAttribute("tokenref"); } var relatedelement = element.SelectSingleNode("RelatedAsset") as XmlElement; if (relatedelement != null) { relatedAssetToken = relatedelement.GetAttribute("nameref"); } ((AssetType)AssetType).SaveAttributeDefinition(this); }
public FileIO(IGraph g) { try { graph = g; outputnodetype = g.Model.NodeModel.GetType("grIO_OUTPUT"); if (outputnodetype == null) throw new Exception(); createOrOverwriteType = g.Model.EdgeModel.GetType("grIO_CreateOrOverwrite"); if (createOrOverwriteType == null) throw new Exception(); createOrAppendType = g.Model.EdgeModel.GetType("grIO_CreateOrAppend"); if (createOrAppendType == null) throw new Exception(); fileType = g.Model.NodeModel.GetType("grIO_File"); if (fileType == null) throw new Exception(); fileNameAttrType = fileType.GetAttributeType("path"); if (fileNameAttrType == null) throw new Exception(); lineType = g.Model.NodeModel.GetType("grIO_File_Line"); if (lineType == null) throw new Exception(); containsLineType = g.Model.EdgeModel.GetType("grIO_File_ContainsLine"); if (containsLineType == null) throw new Exception(); nextLineType = g.Model.EdgeModel.GetType("grIO_File_NextLine"); if (nextLineType == null) throw new Exception(); lineContentAttrType = lineType.GetAttributeType("content"); if (lineContentAttrType == null) throw new Exception(); } catch (Exception) { throw new Exception("Could not find the required node/edge types. Did you include the GrIO-model?"); } }
/// <summary> /// Factory method to create <see cref="AttributeValueBase"/> based class by specified <see cref="AttributeType"/> value. /// </summary> /// <param name="type">Attribute type</param> /// <returns><see cref="AttributeValueBase"/> based class</returns> public static AttributeValueBase CreateByType(AttributeType type) { switch (type) { case AttributeType.Integer: return new AttributeValueInt32(); case AttributeType.Bigint: return new AttributeValueInt64(); case AttributeType.Ordinal: return new AttributeValueOrdinal(); case AttributeType.Float: return new AttributeValueFloat(); case AttributeType.Timestamp: return new AttributeValueDateTime(); case AttributeType.Boolean: return new AttributeValueBoolean(); case AttributeType.String: return new AttributeValueString(); case AttributeType.MultiInteger: return new AttributeValuesInt32(); case AttributeType.MultiLong: return new AttributeValuesInt64(); } throw new NotSupportedException(String.Format(Messages.Exception_UnsupportedAttributeType, Enum.GetName(typeof(AttributeType), type))); }
public DynamicConfig(string key,string title, AttributeType input, object value = null) { Key = key; Title = title; Type = input; Value = value; }
/// <summary> /// Static method to return generated code for a single JSON schema with no references. /// </summary> /// <param name="schema">Location of schema file.</param> /// <param name="ns">The namespace.</param> /// <param name="type">The attribute type.</param> /// <returns>The generated code.</returns> public static string Generate(string schema, string ns = "generated", AttributeType type = AttributeType.SystemDefault) { var jsonSchemaToCodeUnit = new JsonSchemaToCodeUnit(JsonSchemaResolver.ConvertToWrapper(schema), ns, type); CodeCompileUnit codeUnit = jsonSchemaToCodeUnit.Execute(); var csharpGenerator = new CodeCompileUnitToCSharp(codeUnit); return csharpGenerator.Execute(); }
public NtfsFileStream(NtfsFileSystem fileSystem, DirectoryEntry entry, AttributeType attrType, string attrName, FileAccess access) { _entry = entry; _file = fileSystem.GetFile(entry.Reference); _baseStream = _file.OpenStream(attrType, attrName, access); }
public void TestDefaultValue() { AttributeType type = new AttributeType("test", typeof(string)); AttributeInfo test = new AttributeInfo("test", type); test.DefaultValue = "foo"; Assert.AreEqual(test.DefaultValue, "foo"); test.DefaultValue = null; Assert.AreEqual(test.DefaultValue, type.GetDefault()); Assert.Throws<InvalidOperationException>(delegate { test.DefaultValue = 1; }); AttributeType length2Type = new AttributeType("length2Type", typeof(int[]), 2); AttributeInfo length2Info = new AttributeInfo("length2", length2Type); Assert.AreEqual(length2Info.DefaultValue, length2Type.GetDefault()); Assert.AreEqual(length2Info.DefaultValue, new int[] { default(int), default(int) }); DomNodeType nodeType = new DomNodeType("testNodeType"); nodeType.Define(length2Info); DomNode node = new DomNode(nodeType); Assert.AreEqual(node.GetAttribute(length2Info), length2Info.DefaultValue); node.SetAttribute(length2Info, new int[] { 1, 2 }); Assert.AreEqual(node.GetAttribute(length2Info), new int[] { 1, 2 }); node.SetAttribute(length2Info, new int[] { 1 }); Assert.AreEqual(node.GetAttribute(length2Info), new int[] { 1 }); AttributeType length1Type = new AttributeType("length1Type", typeof(int[]), 1); AttributeInfo length1Info = new AttributeInfo("length1", length1Type); Assert.AreEqual(length1Info.DefaultValue, length1Type.GetDefault()); Assert.AreEqual(length1Info.DefaultValue, new int[] { default(int) }); nodeType = new DomNodeType("testNodeType"); nodeType.Define(length1Info); node = new DomNode(nodeType); Assert.AreEqual(node.GetAttribute(length1Info), length1Info.DefaultValue); node.SetAttribute(length1Info, new int[] { 1 }); Assert.AreEqual(node.GetAttribute(length1Info), new int[] { 1 }); }
public static string Get(AttributeType attr) { string output = ""; switch (attr) { case AttributeType.Title: AssemblyTitleAttribute title = (AssemblyTitleAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyTitleAttribute)); output = title.Title; break; case AttributeType.Product: AssemblyProductAttribute product = (AssemblyProductAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyProductAttribute)); output = product.Product; break; case AttributeType.Description: AssemblyDescriptionAttribute description = (AssemblyDescriptionAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyDescriptionAttribute)); output = description.Description; break; case AttributeType.Copyright: AssemblyCopyrightAttribute copyright = (AssemblyCopyrightAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyCopyrightAttribute)); output = copyright.Copyright; break; case AttributeType.Company: AssemblyCompanyAttribute company = (AssemblyCompanyAttribute)Attribute.GetCustomAttribute(Assembly.GetExecutingAssembly(), typeof(AssemblyCompanyAttribute)); output = company.Company; break; case AttributeType.Version: output = Assembly.GetExecutingAssembly().GetName().Version.ToString(); break; } return output; }
public static AttributeUpdateBase CreateByType(AttributeType type) { switch (type) { case AttributeType.Integer: return new AttributeUpdateInt32(); case AttributeType.Float: return new AttributeUpdateFloat(); case AttributeType.Timestamp: return new AttributeUpdateDateTime(); case AttributeType.Boolean: return new AttributeUpdateBoolean(); case AttributeType.Ordinal: return new AttributeUpdateOrdinal(); case AttributeType.MultiBoolean: return new AttributeUpdateMultiBoolean(); case AttributeType.MultiFloat: return new AttributeUpdateMultiFloat(); case AttributeType.MultiInteger: return new AttributeUpdateMultiInt32(); case AttributeType.MultiOrdinal: return new AttributeUpdateMultiOrdinal(); case AttributeType.MultiTimestamp: return new AttributeUpdateMultiDateTime(); // NOTE: Bigint (64-bit) attribute type currently is not supported by Sphinx server (0.9.9-rc2) } throw new NotSupportedException(String.Format(Messages.Exception_UnsupportedAttributeType, Enum.GetName(typeof(AttributeType), type))); }
public ResidentAttributeRecord(AttributeType type, string name, ushort id, bool indexed, AttributeFlags flags) : base(type, name, id, flags) { _nonResidentFlag = 0; _indexedFlag = (byte)(indexed ? 1 : 0); _memoryBuffer = new SparseMemoryBuffer(1024); }
public void TestConstructor() { AttributeType type = new AttributeType("test", typeof(string)); AttributeInfo test = new AttributeInfo("test", type); Assert.AreEqual(test.Name, "test"); Assert.AreEqual(test.Type, type); Assert.AreEqual(test.DefaultValue, type.GetDefault()); }
/// <summary> /// Sets the attribute definition to have an enumerated value. /// </summary> /// <param name="enumValues">The possible values in the enumeration.</param> /// <param name="type">The type to set the attribute to.</param> /// <exception cref="ArgumentException"> /// If the type parameter is not either <see cref="AttributeType.ENUMERATION" /> or <see cref="AttributeType.NOTATION" />. /// </exception> public void SetEnumeratedType(string[] enumValues, AttributeType type) { if (type != AttributeType.ENUMERATION && type != AttributeType.NOTATION) { throw new ArgumentException(string.Format(CultureInfo.CurrentUICulture, "AttributeType {0} is not valid for an attribute definition with an enumerated value.", type)); } m_enumValues = enumValues; m_type = type; }
public Attribute GetAttribute(AttributeType targetAttribute) { if (!attributes.ContainsKey(targetAttribute)) { Debug.Log("Can't found any attribute of type: " + targetAttribute, this); return null; } return attributes[targetAttribute]; }
public List<OAttribute> ListByType(AttributeType attributeType) { // var res = this._ah.Where (oa => oa.Value.AttributeType == (int)attributeType); // if (res != null) { //// return res.Select(oa=>oa.Value).ToList(); // return new List<OAttribute> (); // } else return new List<OAttribute> (); }
/// <summary>Create a new Attribute.</summary> public Attribute(AttributeType type, MemBlock value) { Type = type; Value = value; byte[] data = new byte[4 + value.Length]; NumberSerializer.WriteUShort((ushort) type, data, 0); NumberSerializer.WriteUShort((ushort) value.Length, data, 2); value.CopyTo(data, 4); Data = MemBlock.Reference(data); }
internal void RegisterAttribute(Type fieldType, string attrName, AttributeType type) { Dictionary<string, AttributeType> fieldsForType; if (!_registry.TryGetValue(fieldType, out fieldsForType)) { fieldsForType = new Dictionary<string, AttributeType>(); _registry.Add(fieldType, fieldsForType); } fieldsForType.Add(attrName, type); }
public string value_string { get; set; } //value of the attribute. only needed if type is string /** * Note: if t = STRING => lb and ub are excluded automatically */ public Attribute(String name, AttributeType t, int lb, int ub) { this.Name = name; this.type = t; if (t != AttributeType.STRING) { this.upperbound = ub; this.lowerbound = lb; } }
internal void Read(byte[] buffer, int offset) { Name = Encoding.Unicode.GetString(buffer, offset + 0, 128).Trim('\0'); Type = (AttributeType)Utilities.ToUInt32LittleEndian(buffer, offset + 0x80); DisplayRule = Utilities.ToUInt32LittleEndian(buffer, offset + 0x84); CollationRule = (AttributeCollationRule)Utilities.ToUInt32LittleEndian(buffer, offset + 0x88); Flags = (AttributeTypeFlags)Utilities.ToUInt32LittleEndian(buffer, offset + 0x8C); MinSize = Utilities.ToInt64LittleEndian(buffer, offset + 0x90); MaxSize = Utilities.ToInt64LittleEndian(buffer, offset + 0x98); }
public void TestEquality() { var attrType1 = new AttributeType("xkcd", typeof(string)); var attrInfo1 = new AttributeInfo("xkcd", attrType1); var domNodeType = new DomNodeType("WebComic", DomNodeType.BaseOfAllTypes); var childInfo1 = new ChildInfo("xkcd", domNodeType); attrInfo1.DefaultValue = "Firefly"; var desc1 = new ChildAttributePropertyDescriptor( "xkcd", attrInfo1, childInfo1, "Category 1", "A commonly used word or phrase in the xkcd comic", true); int originalHashCode = desc1.GetHashCode(); // test if two identically created property descriptors compare as being equal var desc2 = new ChildAttributePropertyDescriptor( "xkcd", attrInfo1, childInfo1, "Category 1", "A commonly used word or phrase in the xkcd comic", true); Assert.AreEqual(desc1, desc2); Assert.AreEqual(desc1.GetHashCode(), desc2.GetHashCode()); // test category being different; oddly, although I think they should not be considered equal, // the .Net PropertyDescriptor ignores the difference in category name. So, I'm guessing that // the AttributePropertyDescriptor should behave the same as PropertyDescriptor. var desc3 = new ChildAttributePropertyDescriptor( "xkcd", attrInfo1, childInfo1, "Category 2", "A commonly used word or phrase in the xkcd comic", true); Assert.AreEqual(desc1, desc3); Assert.AreEqual(desc1.GetHashCode(), desc3.GetHashCode()); // test description being different; similarly here, the .Net PropertyDescriptor doesn't care. var desc4 = new ChildAttributePropertyDescriptor( "xkcd", attrInfo1, childInfo1, "Category 1", "slightly different description", true); Assert.AreEqual(desc1, desc4); Assert.AreEqual(desc1.GetHashCode(), desc4.GetHashCode()); // test readOnly being different; ditto for read-only flag! var desc5 = new ChildAttributePropertyDescriptor( "xkcd", attrInfo1, childInfo1, "Category 1", "A commonly used word or phrase in the xkcd comic", false); Assert.AreEqual(desc1, desc5); Assert.AreEqual(desc1.GetHashCode(), desc5.GetHashCode()); // test that the hash code hasn't changed after using the AttributeInfo var attrInfo2 = new AttributeInfo("xkcd", attrType1); domNodeType.Define(attrInfo2); Assert.AreEqual(desc1.GetHashCode(), originalHashCode); // test that the hash code hasn't changed after creating a derived DomNodeType var derivedDomNodeType = new DomNodeType("ScientificWebComic", domNodeType); var derivedAttrInfo = new AttributeInfo("xkcd", attrType1); var derivedChildInfo = new ChildInfo("xkcd", derivedDomNodeType); derivedDomNodeType.Define(derivedAttrInfo); Assert.AreEqual(desc1.GetHashCode(), originalHashCode); // test that an AttributeInfo used in a derived DomNodeType doesn't change equality or hash code var desc6 = new ChildAttributePropertyDescriptor( "xkcd", derivedAttrInfo, derivedChildInfo, "Category 1", "A commonly used word or phrase in the xkcd comic", true); Assert.AreEqual(desc1, desc6); Assert.AreEqual(desc1.GetHashCode(), desc6.GetHashCode()); }
public void SetUp() { var assemblies = new[] { typeof(Umbraco.Tests.Extensions.TestDynamicExtensions).Assembly }; var supportedDynamicTypes = new[] { typeof(Content), typeof(BendyObject) }; var supportedDynamicFieldTypes = new[] { typeof(Content), typeof(TypedAttribute), typeof(BendyObject) }; var bendyMethods = DynamicExtensionsHelper.GetExtensions(assemblies, supportedDynamicTypes); var subBendyMethods = DynamicExtensionsHelper.GetExtensions<DynamicFieldExtensionAttribute>(assemblies, supportedDynamicFieldTypes); var bendy = new BendyObject(); BendyObjectExtensionsHelper.ApplyDynamicExtensions<Content>(bendy, bendyMethods); var content = new Content(); _bendy = bendy; _bendy["__OriginalItem"] = content; var attrType1 = new AttributeType {RenderTypeProvider = CorePluginConstants.FileUploadPropertyEditorId}; var attrDef1 = new AttributeDefinition {AttributeType = attrType1}; var attr1 = new TypedAttribute(attrDef1); var subBendy1 = new BendyObject(); subBendy1["__OriginalItem"] = attr1; subBendy1.AddLazy("__Parent", () => bendy); subBendy1["__ParentKey"] = "Test"; BendyObjectExtensionsHelper.ApplyDynamicFieldExtensions(content, CorePluginConstants.FileUploadPropertyEditorId, subBendy1, subBendyMethods); _bendy["Test"] = subBendy1; var attrType2 = new AttributeType { RenderTypeProvider = CorePluginConstants.TreeNodePickerPropertyEditorId }; var attrDef2 = new AttributeDefinition { AttributeType = attrType2 }; var attr2 = new TypedAttribute(attrDef2); var subBendy2 = new BendyObject(); subBendy2["__OriginalItem"] = attr2; subBendy2.AddLazy("__Parent", () => bendy); subBendy2["__ParentKey"] = "Test2"; BendyObjectExtensionsHelper.ApplyDynamicFieldExtensions(content, CorePluginConstants.TreeNodePickerPropertyEditorId, subBendy2, subBendyMethods); _bendy["Test2"] = subBendy2; }
public AttributesParser(AttributeType[] attributeTypes) { _attributeTypesMap = new Dictionary<string,AttributeType>(); _parsedAttributesMap = null; if( attributeTypes != null ) { foreach( AttributeType attributeType in attributeTypes ) _attributeTypesMap.Add(attributeType.Name,attributeType); } }
public bool ContainsAttribute(ObjectAttribute attribute, AttributeType attributeType) { try { //return this._attrs.Any(oa => oa.AttributeID == (int)attribute && oa.AttributeType == (int)attributeType); } catch (Exception ex) { throw ex; } return false; }
/// <summary> /// Creates the attribute. /// </summary> /// <param name="name">The name.</param> /// <param name="required">if set to <c>true</c> [required].</param> /// <param name="rule">The rule.</param> /// <param name="type">The type.</param> /// <returns>Attribute instance.</returns> private static Attribute CreateAttribute(string name, bool required, string rule, AttributeType type = AttributeType.String) { var attribute = new Attribute { Name = name, AttributeType = type, Required = required, Rule = rule }; return attribute; }
public JsonSchemaToCodeUnit(JsonSchemaWrapper schema, string requestedNamespace, AttributeType attributeType) { if (schema == null || schema.Schema == null) { throw new ArgumentNullException("schema"); } _schemaWrapper = schema; _schemaDocument = schema.Schema; _codeNamespace = requestedNamespace; _attributeType = attributeType; }
public int MftRecordFreeSpace(AttributeType attrType, string attrName) { foreach(var record in _records) { if(record.GetAttribute(attrType, attrName) != null) { return _mft.RecordSize - record.Size; } } throw new IOException("Attempt to determine free space for non-existent attribute"); }
public Attribute(String id, AttributeType type, String title) { // checkArgument(id != null, "ID cannot be null."); // checkArgument(!id.trim().isEmpty(), "ID cannot be empty or blank."); // checkArgument(title != null, "Title cannot be null."); // checkArgument(!title.trim().isEmpty(), "Title cannot be null or blank."); Id = id; AttributeType = type; this.options = new List<String>(); Title = title; }
//Needed for test. Attribute with fixed value public Attribute(String name, AttributeType t, string value) { this.Name = name; this.type = t; switch (t) { case AttributeType.INT: this.value_int = int.Parse(value); break; case AttributeType.STRING: this.value_string = value; break; } }
public void SetType(string type) { switch (type) { case "CDATA": Type = AttributeType.CDATA; break; case "ENTITY": Type = AttributeType.ENTITY; break; case "ENTITIES": Type = AttributeType.ENTITIES; break; case "ID": Type = AttributeType.ID; break; case "IDREF": Type = AttributeType.IDREF; break; case "IDREFS": Type = AttributeType.IDREFS; break; case "NAME": Type = AttributeType.NAME; break; case "NAMES": Type = AttributeType.NAMES; break; case "NMTOKEN": Type = AttributeType.NMTOKEN; break; case "NMTOKENS": Type = AttributeType.NMTOKENS; break; case "NUMBER": Type = AttributeType.NUMBER; break; case "NUMBERS": Type = AttributeType.NUMBERS; break; case "NUTOKEN": Type = AttributeType.NUTOKEN; break; case "NUTOKENS": Type = AttributeType.NUTOKENS; break; default: throw new Exception("Attribute type '" + type + "' is not supported"); } }
public NonResidentAttributeRecord(AttributeType type, string name, ushort id, AttributeFlags flags, long firstCluster, ulong numClusters, uint bytesPerCluster) : base(type, name, id, flags) { _nonResidentFlag = 1; _dataRuns = new List<DataRun>(); _dataRuns.Add(new DataRun(firstCluster, (long)numClusters, false)); _lastVCN = numClusters - 1; _dataAllocatedSize = bytesPerCluster * numClusters; _dataRealSize = bytesPerCluster * numClusters; _initializedDataSize = bytesPerCluster * numClusters; if ((flags & (AttributeFlags.Compressed | AttributeFlags.Sparse)) != 0) { _compressionUnitSize = DefaultCompressionUnitSize; } }
public void TestValidation() { AttributeType type = new AttributeType("test", typeof(string)); AttributeInfo test = new AttributeInfo("test", type); CollectionAssert.IsEmpty(test.Rules); var rule = new SimpleAttributeRule(); test.AddRule(rule); Utilities.TestSequenceEqual(test.Rules, rule); Assert.True(test.Validate("bar")); Assert.True(rule.Validated); Assert.False(test.Validate(1)); // wrong type }
/// <summary> /// Creates a Version 1.1 Saml Assertion /// </summary> /// <param name="issuer">Issuer</param> /// <param name="subject">Subject</param> /// <param name="attributes">Attributes</param> /// <returns>returns a Version 2.0 Saml Assertion</returns> private static AssertionType CreateSamlAssertion(string issuer, string recipient, string subject, string audience, string nameIdPolicyFormat, Dictionary <string, string> attributes) { // Here we create some SAML assertion with ID and Issuer name. AssertionType assertion = new AssertionType(); assertion.ID = "_" + Guid.NewGuid().ToString(); NameIDType issuerForAssertion = new NameIDType(); issuerForAssertion.Value = issuer.Trim(); assertion.Issuer = issuerForAssertion; assertion.Version = "2.0"; assertion.IssueInstant = System.DateTime.UtcNow; //Not before, not after conditions ConditionsType conditions = new ConditionsType(); conditions.NotBefore = DateTime.UtcNow; conditions.NotBeforeSpecified = true; conditions.NotOnOrAfter = DateTime.UtcNow.AddMinutes(5); conditions.NotOnOrAfterSpecified = true; AudienceRestrictionType audienceRestriction = new AudienceRestrictionType(); audienceRestriction.Audience = new string[] { audience.Trim() }; conditions.Items = new ConditionAbstractType[] { audienceRestriction }; //Name Identifier to be used in Saml Subject NameIDType nameIdentifier = new NameIDType(); //nameIdentifier.NameQualifier = domain.Trim(); nameIdentifier.Format = nameIdPolicyFormat; nameIdentifier.Value = subject.Trim(); SubjectConfirmationType subjectConfirmation = new SubjectConfirmationType(); SubjectConfirmationDataType subjectConfirmationData = new SubjectConfirmationDataType(); subjectConfirmation.Method = "urn:oasis:names:tc:SAML:2.0:cm:bearer"; subjectConfirmation.SubjectConfirmationData = subjectConfirmationData; // // Create some SAML subject. SubjectType samlSubject = new SubjectType(); AttributeStatementType attrStatement = new AttributeStatementType(); AuthnStatementType authStatement = new AuthnStatementType(); authStatement.AuthnInstant = DateTime.UtcNow; AuthnContextType context = new AuthnContextType(); context.ItemsElementName = new ItemsChoiceType5[] { ItemsChoiceType5.AuthnContextClassRef }; context.Items = new object[] { "urn:oasis:names:tc:SAML:2.0:ac:classes:unspecified" }; authStatement.AuthnContext = context; samlSubject.Items = new object[] { nameIdentifier, subjectConfirmation }; assertion.Subject = samlSubject; IPHostEntry ipEntry = Dns.GetHostEntry(System.Environment.MachineName); SubjectLocalityType subjectLocality = new SubjectLocalityType(); subjectLocality.Address = ipEntry.AddressList[0].ToString(); attrStatement.Items = new AttributeType[attributes.Count]; int i = 0; // Create userName SAML attributes. foreach (KeyValuePair <string, string> attribute in attributes) { AttributeType attr = new AttributeType(); attr.Name = attribute.Key; //attr.NameFormat = "urn:oasis:names:tc:SAML:2.0:attrname-format:basic"; attr.AttributeValue = new object[] { attribute.Value }; attrStatement.Items[i] = attr; i++; } assertion.Conditions = conditions; assertion.Items = new StatementAbstractType[] { authStatement, attrStatement }; return(assertion); }
/// <summary> /// Sets up the query object and validates the passed in parameters to ensure they are compatible with each other /// </summary> /// <param name="attributeName">The name of the attribute being queried</param> /// <param name="comparisonOperator">THe value comparison operator to use</param> /// <param name="value">The value to use in the query</param> /// <param name="negate">Indicates if the query should be negated with the not() operator</param> /// <param name="attributeType">The type of the target attribute</param> /// <param name="isMultivalued">The multivalued status of the attribute being queried</param> private void SetupBuilder(string attributeName, ComparisonOperator comparisonOperator, object value, bool negate, AttributeType attributeType, bool isMultivalued) { if (string.IsNullOrWhiteSpace(attributeName)) { throw new ArgumentNullException(attributeName); } ResourceManagementSchema.ValidateAttributeName(attributeName); if (value == null) { if (comparisonOperator != ComparisonOperator.IsNotPresent && comparisonOperator != ComparisonOperator.IsPresent) { throw new InvalidOperationException("An object value is required unless the operator is IsPresent or IsNotPresent"); } } this.AttributeName = attributeName; this.Operator = comparisonOperator; this.Value = value; this.Negate = negate; this.attributeType = attributeType; this.isMultivalued = isMultivalued; this.ThrowOnInvalidTypeOperatorCombination(); this.ThrowOnInvalidNegateCombination(); }
private void onDecAttributePoints(AttributeType attributeType) { changeAttributePoints(attributeType, -1); }
public bool TryGetAttribute(string xaml, string attributeName, AttributeType attributeTypesToCheck, out AttributeType attributeType, out int index, out int length, out string value) { if (attributeTypesToCheck.HasFlag(AttributeType.Inline)) { var searchText = $"{attributeName}=\""; var tbIndex = xaml.IndexOf(searchText, StringComparison.Ordinal); if (tbIndex >= 0) { var tbEnd = xaml.IndexOf("\"", tbIndex + searchText.Length, StringComparison.Ordinal); attributeType = AttributeType.Inline; index = tbIndex; length = tbEnd - tbIndex + 1; value = xaml.Substring(tbIndex + searchText.Length, tbEnd - tbIndex - searchText.Length); return(true); } } var elementName = xaml.Substring(1, xaml.IndexOfAny(new[] { ' ', '>' }) - 1); if (attributeTypesToCheck.HasFlag(AttributeType.Element)) { var searchText = $"<{elementName}.{attributeName}>"; var startIndex = xaml.IndexOf(searchText, StringComparison.Ordinal); if (startIndex > -1) { var closingElement = $"</{elementName}.{attributeName}>"; var endPos = xaml.IndexOf(closingElement, startIndex, StringComparison.Ordinal); if (endPos > -1) { attributeType = AttributeType.Element; index = startIndex; length = endPos - startIndex + closingElement.Length; value = xaml.Substring(startIndex + searchText.Length, endPos - startIndex - searchText.Length); return(true); } } } if (attributeTypesToCheck.HasFlag(AttributeType.DefaultValue)) { var endOfOpening = xaml.IndexOf(">"); var closingTag = $"</{elementName}>"; var startOfClosing = xaml.IndexOf(closingTag, StringComparison.Ordinal); if (startOfClosing > 0 && startOfClosing > endOfOpening) { var defaultValue = xaml.Substring(endOfOpening + 1, startOfClosing - endOfOpening - 1); if (!string.IsNullOrWhiteSpace(defaultValue) && !defaultValue.TrimStart().StartsWith("<")) { attributeType = AttributeType.DefaultValue; index = 0; length = xaml.Length; value = defaultValue; return(true); } } } attributeType = AttributeType.None; index = -1; length = 0; value = string.Empty; return(false); }
public EntityAttribute Get(AttributeType type) { return(_attributes[type]); }
public void Set(AttributeType type, double value) { _attributes[type].Set(value); }
public EdgeType_fluffway() : base((int)EdgeTypes.@fluffway) { AttributeType_numtunnels = new AttributeType("numtunnels", this, AttributeKind.IntegerAttr, null); }
protected void StoreNodes(List <DataSourceNodeBase> nlist, SqlServerDatabaseNode databaseNode) { NodeService nsvc = new NodeService(); TypeService tsvc = new TypeService(); AttributeService attsvc = new AttributeService(); MembershipService msvc = new MembershipService(); foreach (DataSourceNodeBase dbnode in nlist) { string memtypename = null; //if there is a non-zero id value, it's already been stored/pulled. if (dbnode.NodeIdentity == 0) { Node existnode = nsvc.GetByName(dbnode.Name); if (existnode == null) { //hasn't been added yet--create one Type nclasstype = dbnode.GetType(); string ntypename = null; switch (nclasstype.FullName) { case "SystemMap.Models.Transform.db.sqlserver.SqlServerInstanceNode": ntypename = "SQL Server"; memtypename = null; break; case "SystemMap.Models.Transform.db.sqlserver.SqlServerDatabaseNode": ntypename = EnumParser.GetValueName(DbClasses.Database); memtypename = null; break; case "SystemMap.Models.Transform.db.sqlserver.SqlServerTableNode": ntypename = EnumParser.GetValueName(DbClasses.Table); memtypename = ntypename; break; case "SystemMap.Models.Transform.db.sqlserver.SqlServerViewNode": ntypename = EnumParser.GetValueName(DbClasses.View); memtypename = ntypename; break; case "SystemMap.Models.Transform.db.sqlserver.SqlServerProcedureNode": ntypename = EnumParser.GetValueName(DbProcesses.StoredProcedue); memtypename = ntypename; break; case "SystemMap.Models.Transform.db.sqlserver.SqlServerFunctionNode": ntypename = EnumParser.GetValueName(DbProcesses.Function); memtypename = ntypename; break; case "SystemMap.Models.Transform.db.GenericDataSourceNode": ntypename = "External Reference"; memtypename = null; break; default: ntypename = "General"; memtypename = null; break; } NodeType ntype = tsvc.GetNodeType(ntypename, true); existnode = new Node { name = dbnode.Name, description = ntypename, type = ntype }; try { int nid = nsvc.AddNode(existnode); dbnode.NodeIdentity = nid; if (dbnode.Metadata != null) { foreach (NodeAttribute natt in dbnode.Metadata) { try { AttributeType atype = tsvc.GetAttributeType(natt.type.name, true); natt.nodeId = dbnode.NodeIdentity; natt.type = atype; attsvc.AddNodeAttribute(natt); } catch (Exception ex) { Console.WriteLine(ex.StackTrace); } } } } catch (Exception ex) { Console.WriteLine(ex.StackTrace); } } else { dbnode.NodeIdentity = existnode.id; } } if (memtypename != null) { MembershipType mtype = tsvc.GetMembershipType(memtypename, true); if (mtype != null && databaseNode.NodeIdentity != 0 && dbnode.NodeIdentity != 0) { try { msvc.AddNodeMembership(databaseNode.NodeIdentity, dbnode.NodeIdentity, mtype.typeId); } catch (Exception ex) { Console.WriteLine(ex.StackTrace); } } } } }
public long GetAttributeValue(AttributeType at) { return(AttributeManager[at]); }
public Attribute GetAttribute(AttributeType at) { return(_attributes[(int)at]); }
/// <summary> /// Add all comments and attributes. /// </summary> /// <param name="schema">The JsonSchema.</param> /// <param name="type">Annotation type to generate.</param> public void Populate(JsonSchema schema, AttributeType type) { // Add description if (schema.Description != null) { AddComment(schema.Description); } // Add required attribute if (schema.Required != null && schema.Required.Value) { /*switch (type) * { * case AttributeType.SystemDefault: * AddAttribute("Required"); * break; * case AttributeType.JsonDotNet: * AddAttribute("JsonProperty", * new CodeAttributeArgument("Required", new CodeSnippetExpression("Required.Always"))); * break; * }*/ AddAttribute("Required"); } // Number only flags if (JsonSchemaUtils.IsNumber(schema)) { if (schema.Minimum != null) { if (schema.ExclusiveMinimum != null && schema.ExclusiveMinimum.Value) { AddAttribute("MinValue", (int)schema.Minimum.Value + 1); } else { AddAttribute("MinValue", (int)schema.Minimum.Value); } } if (schema.Maximum != null) { if (schema.ExclusiveMaximum != null && schema.ExclusiveMaximum.Value) { AddAttribute("MaxValue", (int)schema.Maximum.Value - 1); } else { AddAttribute("MaxValue", (int)schema.Maximum.Value); } } } // String only flags if (JsonSchemaUtils.IsString(schema)) { var args = new List <CodeAttributeArgument>(); bool flag = false; if (schema.MaximumLength != null) { args.Add(new CodeAttributeArgument(new CodePrimitiveExpression(schema.MaximumLength.Value))); flag = true; } if (schema.MinimumLength != null) { args.Add(new CodeAttributeArgument("MinimumLength", new CodePrimitiveExpression(schema.MinimumLength.Value))); flag = true; } if (flag) { AddAttribute("StringLength", args.ToArray()); } if (!String.IsNullOrEmpty(schema.Pattern)) { AddAttribute("RegularExpression", new CodeAttributeArgument(new CodeSnippetExpression(string.Format(@"@""{0}""", schema.Pattern.SanitizeRegex(true))))); } } // Array only flags if (JsonSchemaUtils.IsArray(schema)) { if (schema.MinimumItems != null) { AddAttribute("MinLength", schema.MinimumItems.Value); } if (schema.MaximumItems != null) { AddAttribute("MaxLength", schema.MaximumItems.Value); } } }
public Float2(AttributeType attribute) : base(attribute) { }
/// <summary> /// Parses attribute from data. /// </summary> /// <param name="data">SIP message data.</param> /// <param name="offset">Offset in data.</param> private void ParseAttribute(byte[] data, ref int offset) { /* RFC 3489 11.2. * Each attribute is TLV encoded, with a 16 bit type, 16 bit length, and variable value: * * 0 1 2 3 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Type | Length | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Value .... +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ // Type AttributeType type = (AttributeType)(data[offset++] << 8 | data[offset++]); // Length int length = (data[offset++] << 8 | data[offset++]); // MAPPED-ADDRESS if (type == AttributeType.MappedAddress) { m_pMappedAddress = ParseEndPoint(data, ref offset); } // RESPONSE-ADDRESS else if (type == AttributeType.ResponseAddress) { m_pResponseAddress = ParseEndPoint(data, ref offset); } // CHANGE-REQUEST else if (type == AttributeType.ChangeRequest) { /* * The CHANGE-REQUEST attribute is used by the client to request that * the server use a different address and/or port when sending the * response. The attribute is 32 bits long, although only two bits (A * and B) are used: * * 0 1 2 3 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 A B 0| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ * * The meaning of the flags is: * * A: This is the "change IP" flag. If true, it requests the server * to send the Binding Response with a different IP address than the * one the Binding Request was received on. * * B: This is the "change port" flag. If true, it requests the * server to send the Binding Response with a different port than the * one the Binding Request was received on. */ // Skip 3 bytes offset += 3; m_pChangeRequest = new STUN_t_ChangeRequest((data[offset] & 4) != 0, (data[offset] & 2) != 0); offset++; } // SOURCE-ADDRESS else if (type == AttributeType.SourceAddress) { m_pSourceAddress = ParseEndPoint(data, ref offset); } // CHANGED-ADDRESS else if (type == AttributeType.ChangedAddress) { m_pChangedAddress = ParseEndPoint(data, ref offset); } // USERNAME else if (type == AttributeType.Username) { m_UserName = Encoding.Default.GetString(data, offset, length); offset += length; } // PASSWORD else if (type == AttributeType.Password) { m_Password = Encoding.Default.GetString(data, offset, length); offset += length; } // MESSAGE-INTEGRITY else if (type == AttributeType.MessageIntegrity) { offset += length; } // ERROR-CODE else if (type == AttributeType.ErrorCode) { /* 3489 11.2.9. * 0 1 2 3 * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | 0 |Class| Number | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ | Reason Phrase (variable) .. +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */ int errorCode = (data[offset + 2] & 0x7) * 100 + (data[offset + 3] & 0xFF); m_pErrorCode = new STUN_t_ErrorCode(errorCode, Encoding.Default.GetString(data, offset + 4, length - 4)); offset += length; } // UNKNOWN-ATTRIBUTES else if (type == AttributeType.UnknownAttribute) { offset += length; } // REFLECTED-FROM else if (type == AttributeType.ReflectedFrom) { m_pReflectedFrom = ParseEndPoint(data, ref offset); } // XorMappedAddress // XorOnly // ServerName else if (type == AttributeType.ServerName) { m_ServerName = Encoding.Default.GetString(data, offset, length); offset += length; } // Unknown else { offset += length; } }
public EdgeType_connection() : base((int)EdgeTypes.@connection) { AttributeType_bandwidth = new AttributeType("bandwidth", this, AttributeKind.IntegerAttr, null); }
public int Add(string name, AttributeType type, int precision, int width) { return(_table.EditAddField(name, (FieldType)type, precision, width)); }
private bool HasAttribute(string xaml, string attribute, AttributeType attributeType = AttributeType.Any) { var xep = new TestableXamlElementProcessor(ProjectType.Any, new DefaultTestLogger()); return(xep.TryGetAttribute(xaml, attribute, attributeType, out _, out _, out _, out _)); }
public NodeType_Process() : base((int)NodeTypes.@Process) { AttributeType_name = new AttributeType("name", this, AttributeKind.StringAttr, null); AttributeType_val = new AttributeType("val", this, AttributeKind.IntegerAttr, null); }
/// <summary> /// Initializes a new instance of the <see cref="PartitionKey"/> class. /// </summary> /// <param name="keyName">The name of the key of a table or index.</param> /// <param name="keyType">The data type of the key of a table or index.</param> public PartitionKey(string keyName, AttributeType keyType = AttributeType.String) : base(keyName, keyType) { }
private void changeAttributePoints(AttributeType attributeType, int factor) { if ((_currentAvaliableAttributePoints - factor) > _originalAvaliableAttributePoints) { return; } if ((_currentAvaliableAttributePoints - factor) < 0) { return; } switch (attributeType) { case AttributeType.Air: if ((_currentAttributePoints.Air + factor) < _originalAttributePoints.Air) { return; } _currentAttributePoints.Air += factor; AirPanel.UpdateText(_currentAttributePoints.Air); break; case AttributeType.Earth: if ((_currentAttributePoints.Earth + factor) < _originalAttributePoints.Earth) { return; } _currentAttributePoints.Earth += factor; EarthPanel.UpdateText(_currentAttributePoints.Earth); break; case AttributeType.Fire: if ((_currentAttributePoints.Fire + factor) < _originalAttributePoints.Fire) { return; } _currentAttributePoints.Fire += factor; FirePanel.UpdateText(_currentAttributePoints.Fire); break; case AttributeType.Water: if ((_currentAttributePoints.Water + factor) < _originalAttributePoints.Water) { return; } _currentAttributePoints.Water += factor; WaterPanel.UpdateText(_currentAttributePoints.Water); break; case AttributeType.Light: if ((_currentAttributePoints.Light + factor) < _originalAttributePoints.Light) { return; } _currentAttributePoints.Light += factor; LightPanel.UpdateText(_currentAttributePoints.Light); break; case AttributeType.Health: if ((_currentAttributePoints.Health + factor) < _originalAttributePoints.Health) { return; } _currentAttributePoints.Health += factor; HealthPanel.UpdateText(_currentAttributePoints.Health); break; default: break; } _currentAvaliableAttributePoints -= factor; AvaliableAttributePoints.text = _currentAvaliableAttributePoints.ToString(); }
/// <summary> /// Initializes a new instance of the XPathQuery class /// </summary> /// <param name="attributeName">The name of the attribute to compare against</param> /// <param name="comparisonOperator">The value comparison operator to use</param> /// <param name="value">The value to compare against</param> /// <param name="negate">Indicates if this query should be negated with the not() operator</param> /// <param name="attributeType">The data type of the attribute being queried</param> /// <param name="isMultivalued">The multivalued status of the attribute being queried</param> /// <remarks> /// This constructor can be used when a connection to the resource management service not available. The attribute type and multivalued status are not validated against the schema /// </remarks> public XPathQuery(string attributeName, ComparisonOperator comparisonOperator, object value, bool negate, AttributeType attributeType, bool isMultivalued) { this.SetupBuilder(attributeName, comparisonOperator, value, negate, attributeType, isMultivalued); }
protected void CheckForHardCodedAttribute(string elementName, string attributeName, AttributeType types, string descriptionFormat, string xamlElement, ITextSnapshot snapshot, int offset, bool uidExists, string uidValue, Guid elementIdentifier, List <IRapidXamlAdornmentTag> tags) { if (this.TryGetAttribute(xamlElement, attributeName, types, out AttributeType foundAttributeType, out int tbIndex, out int length, out string value)) { if (!string.IsNullOrWhiteSpace(value) && char.IsLetterOrDigit(value[0])) { var line = snapshot.GetLineFromPosition(offset + tbIndex); var col = offset + tbIndex - line.Start.Position; tags.Add(new HardCodedStringTag(new Span(offset + tbIndex, length), snapshot, line.LineNumber, col, elementName, attributeName) { AttributeType = foundAttributeType, Value = value, Description = descriptionFormat.WithParams(value), UidExists = uidExists, UidValue = uidValue, ElementGuid = elementIdentifier, }); } } }
public float this[AttributeType type] => sumAttributes[type];
public bool FetchObjectToBeShownAsGraph(Sequence seq, out object toBeShownAsGraph, out AttributeType attrType) { do { Console.WriteLine("Enter name of variable or attribute access to show as graph (just enter for abort): "); Console.WriteLine("Examples: \"v\", \"v.a\", \"@(\"$0\").a\" "); String str = Console.ReadLine(); if (str.Length == 0) { toBeShownAsGraph = null; attrType = null; return(true); } if (str.StartsWith("@")) { // graph element by name string attributeName; IGraphElement elem = ParseAccessByName(str, out attributeName); if (elem == null) { Console.WriteLine("Can't parse graph access / unknown graph element: " + str); continue; } if (attributeName == null) { Console.WriteLine("The result of a graph access is a node or edge, you must access an attribute: " + str); continue; } attrType = elem.Type.GetAttributeType(attributeName); if (attrType == null) { Console.WriteLine("Unknown attribute: " + attributeName); continue; } object attribute = elem.GetAttribute(attributeName); if (attribute == null) { Console.WriteLine("Null-valued attribute: " + attributeName); continue; } toBeShownAsGraph = attribute; return(false); } else { // variable string attributeName; object value = ParseVariable(str, seq, out attributeName); if (value == null) { Console.WriteLine("Can't parse variable / unknown variable / null-valued variable: " + str); continue; } if (attributeName != null) { if (!(value is IGraphElement)) { Console.WriteLine("Can't access attribute, the variable value is not a graph element: " + str); continue; } IGraphElement elem = (IGraphElement)value; attrType = elem.Type.GetAttributeType(attributeName); if (attrType == null) { Console.WriteLine("Unknown attribute: " + attributeName); continue; } object attribute = elem.GetAttribute(attributeName); if (attribute == null) { Console.WriteLine("Null-valued attribute: " + attributeName); continue; } toBeShownAsGraph = attribute; return(false); } else { attrType = null; toBeShownAsGraph = value; return(false); } } }while(true); }
public EdgeType_slowway() : base((int)EdgeTypes.@slowway) { AttributeType_slowspeed = new AttributeType("slowspeed", this, AttributeKind.IntegerAttr, null); }
private void onIncAttributePoints(AttributeType attributeType) { changeAttributePoints(attributeType, +1); }
public EdgeType_speedcon() : base((int)EdgeTypes.@speedcon) { AttributeType_classkind = new AttributeType("classkind", this, AttributeKind.StringAttr, null); }
public override ICriterion VisitFieldPredicate(FieldPredicateExpression node) { var fieldName = node.SelectorExpression.FieldName; var valueKey = node.SelectorExpression.ValueKey; var fieldValue = node.ValueExpression.Value; var fieldValueType = fieldValue != null?fieldValue.GetType() : typeof(string); switch (fieldName.ToLowerInvariant()) { case "id": Guid idValue = GetIdValue(node); switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: _discoveredRequiredNodeIds.Add(idValue); return(Restrictions.Eq(Projections.Property(() => version.Node.Id), idValue)); case ValuePredicateType.NotEqual: _negatingNodeIdsExist = true; return(!Restrictions.Eq(Projections.Property(() => version.Node.Id), idValue)); default: throw new InvalidOperationException( "Cannot query an item by id by any other operator than == or !="); } case "system-internal-selected-template": //TODO Pending property editors getting involved in query modification prior to being passed to hive provider, //manually check for queries against a template here if (valueKey == "TemplateId" && fieldValue != null) { var tryParseResult = HiveId.TryParse(fieldValue.ToString()); if (!tryParseResult.Success || tryParseResult.Result.ProviderGroupRoot == null || tryParseResult.Result.ProviderId == null || (tryParseResult.Result.ProviderGroupRoot.AbsoluteUri != "storage://" && tryParseResult.Result.ProviderId != "templates")) { var normalisedFieldValue = "/" + fieldValue.ToString().TrimStart("/").TrimEnd(".") + "."; // Need to convert the value into the serialized form that a HiveId would use var newValue = new HiveId("storage", "templates", new HiveIdValue(normalisedFieldValue)).ToString(HiveIdFormatStyle.UriSafe); fieldValue = newValue; } else { fieldValue = tryParseResult.Result.ToString(HiveIdFormatStyle.UriSafe); } } break; } // First look up the types of the main field AttributeDefinition defAlias = null; AttributeType typeAlias = null; var attributeType = _activeSession.NhSession.QueryOver <AttributeDefinition>(() => defAlias) .JoinAlias(() => defAlias.AttributeType, () => typeAlias) .Where(() => defAlias.Alias == fieldName) .Select(x => typeAlias.PersistenceTypeProvider) .List <string>(); foreach (var type in attributeType) { var typeName = type; if (_typesAlreadyEstablished.Contains(typeName)) { continue; } try { _typesAlreadyEstablished.Add(typeName); var persisterType = Type.GetType(typeName, false); if (persisterType != null) { var persisterInstance = Activator.CreateInstance(persisterType) as IAttributeSerializationDefinition; if (persisterInstance != null && !_typesToQuery.Contains(persisterInstance.DataSerializationType)) { _typesToQuery.Add(persisterInstance.DataSerializationType); } } } catch (Exception ex) { LogHelper.Error <NhCriteriaVisitor>("Error while trying to decide which value-tables to join & query", ex); throw; } } // U5-789 // Workaround pending a better check of what data is actually saved // An issue arose because previous data had been saved in long-string, // but the datatype changed to be just string, therefore only string was // being queried despite all the data residing still in long-string if (_typesToQuery.Contains(DataSerializationTypes.String) && !_typesToQuery.Contains(DataSerializationTypes.LongString)) { _typesToQuery.Add(DataSerializationTypes.LongString); } //NodeVersion aliasNodeVersion = null; //Attribute aliasAttribute = null; //AttributeDefinition aliasAttributeDefinition = null; //AttributeStringValue aliasStringValue = null; //AttributeLongStringValue aliasLongStringValue = null; //AttributeIntegerValue aliasIntegerValue = null; //AttributeDecimalValue aliasDecimalValue = null; //NodeRelation aliasNodeRelation = null; //AttributeDateValue aliasDateValue = null; //QueryOver<NodeVersion, AttributeDefinition> queryExtender = QueryOver.Of<NodeVersion>(() => aliasNodeVersion) // .JoinQueryOver<Attribute>(() => aliasNodeVersion.Attributes, () => aliasAttribute) // .JoinQueryOver<AttributeDefinition>(() => aliasAttribute.AttributeDefinition, () => aliasAttributeDefinition); int numberOfMatchesEvaluated = 0; AbstractCriterion restrictionBuilder = null; foreach (var dataSerializationTypese in _typesToQuery.Distinct()) { AbstractCriterion restriction = null; Expression <Func <object> > propertyExpression = null; Expression <Func <object> > subkeyExpression = null; List <ValuePredicateType> validClauseTypes = null; var useLikeMatchForStrings = false; switch (dataSerializationTypese) { case DataSerializationTypes.SmallInt: case DataSerializationTypes.LargeInt: case DataSerializationTypes.Boolean: propertyExpression = () => integerVal.Value; subkeyExpression = () => integerVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual }; break; case DataSerializationTypes.Decimal: propertyExpression = () => decimalVal.Value; subkeyExpression = () => decimalVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual }; break; case DataSerializationTypes.String: propertyExpression = () => stringVal.Value; subkeyExpression = () => stringVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.NotEqual, ValuePredicateType.Contains, ValuePredicateType.StartsWith, ValuePredicateType.EndsWith, ValuePredicateType.MatchesWildcard }; break; case DataSerializationTypes.LongString: propertyExpression = () => longStrVal.Value; subkeyExpression = () => longStrVal.ValueKey; useLikeMatchForStrings = true; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.NotEqual, ValuePredicateType.Contains, ValuePredicateType.StartsWith, ValuePredicateType.EndsWith, ValuePredicateType.MatchesWildcard }; break; case DataSerializationTypes.Date: propertyExpression = () => dateVal.Value; subkeyExpression = () => dateVal.ValueKey; validClauseTypes = new List <ValuePredicateType>() { ValuePredicateType.Equal, ValuePredicateType.GreaterThan, ValuePredicateType.GreaterThanOrEqual, ValuePredicateType.LessThan, ValuePredicateType.LessThanOrEqual, ValuePredicateType.NotEqual, ValuePredicateType.Empty }; break; } if (!validClauseTypes.Contains(node.ValueExpression.ClauseType)) { throw new InvalidOperationException("A field of type {0} cannot be queried with operator {1}".InvariantFormat(dataSerializationTypese.ToString(), node.ValueExpression.ClauseType.ToString())); } switch (node.ValueExpression.ClauseType) { case ValuePredicateType.Equal: restriction = GetRestrictionEq(fieldValue, useLikeMatchForStrings, propertyExpression, subkeyExpression, valueKey); break; case ValuePredicateType.NotEqual: restriction = !GetRestrictionEq(fieldValue, useLikeMatchForStrings, propertyExpression); break; case ValuePredicateType.LessThan: restriction = GetRestrictionLt(fieldValue, propertyExpression); break; case ValuePredicateType.LessThanOrEqual: restriction = GetRestrictionLtEq(fieldValue, propertyExpression); break; case ValuePredicateType.GreaterThan: restriction = GetRestrictionGt(fieldValue, propertyExpression); break; case ValuePredicateType.GreaterThanOrEqual: restriction = GetRestrictionGtEq(fieldValue, propertyExpression); break; case ValuePredicateType.Contains: restriction = GetRestrictionContains(fieldValue, propertyExpression); break; case ValuePredicateType.StartsWith: restriction = GetRestrictionStarts(fieldValue, propertyExpression); break; case ValuePredicateType.EndsWith: restriction = GetRestrictionEnds(fieldValue, propertyExpression); break; } if (restriction != null) { if (numberOfMatchesEvaluated == 0) { restrictionBuilder = restriction; numberOfMatchesEvaluated++; } else { restrictionBuilder = Restrictions.Or(restriction, restrictionBuilder); } } } var fieldNameRestriction = Restrictions.Eq(Projections.Property(() => def.Alias), fieldName); if (restrictionBuilder != null) { restrictionBuilder = Restrictions.And(restrictionBuilder, fieldNameRestriction); } else { restrictionBuilder = fieldNameRestriction; } return(restrictionBuilder); }
public TextAttribute(AttributeType attributeType, string value) : base(attributeType, value) { }
public SpecialAttribute(AttributeType type, int value) { this.attributeType = type; this.attributeValue = value; }
public AttributeSelect(string name, AttributeType attributeType, AttributeDataType dataType) : base(name, attributeType, dataType) { }