static int internal_index(System.Globalization.CompareInfo _this, string source, int sIndex, int count, char value, System.Globalization.CompareOptions options, bool first) { // if first == true find first incidence, else find last if (first) { for (int i = sIndex; i < (sIndex + count); i++) { if (source[i] == value) { return(i); } } } else { for (int i = (sIndex + count - 1); i >= sIndex; i--) { if (source[i] == value) { return(i); } } } return(-1); }
/// <summary> /// The Virtual Payment Client need to use an Ordinal comparison to Sort on /// the field names to create the SHA256 Signature for validation of the message. /// This class provides a Compare method that is used to allow the sorted list /// to be ordered using an Ordinal comparison. /// </summary> /// <param name="a">The first string in the comparison.</param> /// <param name = "b" > The second string in the comparison.</param> /// <returns>An int containing the result of the comparison.</returns> public int Compare(string a, string b) { // Return if we are comparing the same object or one of the // objects is null, since we don't need to go any further. if (a == b) { return(0); } if (a == null) { return(-1); } if (b == null) { return(1); } // Ensure we have string to compare string sa = a as string; string sb = b as string; // Get the CompareInfo object to use for comparing System.Globalization.CompareInfo myComparer = System.Globalization.CompareInfo.GetCompareInfo("en-US"); if (sa != null && sb != null) { // Compare using an Ordinal Comparison. return(myComparer.Compare(sa, sb, System.Globalization.CompareOptions.Ordinal)); } throw new ArgumentException("a and b should be strings."); }
/// <summary> Returns a comparator for sorting hits according to a field containing strings.</summary> /// <param name="reader"> Index to use. /// </param> /// <param name="fieldname"> Fieldable containg string values. /// </param> /// <returns> Comparator for sorting hits. /// </returns> /// <throws> IOException If an error occurs reading the index. </throws> internal static ScoreDocComparator ComparatorStringLocale(IndexReader reader, System.String fieldname, System.Globalization.CultureInfo locale) { System.Globalization.CompareInfo collator = locale.CompareInfo; System.String field = String.Intern(fieldname); System.String[] index = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetStrings(reader, field); return(new AnonymousClassScoreDocComparator5(index, collator)); }
/// <summary> Enumerates all terms greater/equal than <code>lowerTerm</code> /// but less/equal than <code>upperTerm</code>. /// /// If an endpoint is null, it is said to be "open". Either or both /// endpoints may be open. Open endpoints may not be exclusive /// (you can't select all but the first or last term without /// explicitly specifying the term to exclude.) /// /// </summary> /// <param name="reader"> /// </param> /// <param name="field">An interned field that holds both lower and upper terms. /// </param> /// <param name="lowerTermText">The term text at the lower end of the range /// </param> /// <param name="upperTermText">The term text at the upper end of the range /// </param> /// <param name="includeLower">If true, the <code>lowerTerm</code> is included in the range. /// </param> /// <param name="includeUpper">If true, the <code>upperTerm</code> is included in the range. /// </param> /// <param name="collator">The collator to use to collate index Terms, to determine their /// membership in the range bounded by <code>lowerTerm</code> and /// <code>upperTerm</code>. /// /// </param> /// <throws> IOException </throws> public TermRangeTermEnum(IndexReader reader, System.String field, System.String lowerTermText, System.String upperTermText, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator) { this.collator = collator; this.upperTermText = upperTermText; this.lowerTermText = lowerTermText; this.includeLower = includeLower; this.includeUpper = includeUpper; this.field = StringHelper.Intern(field); // do a little bit of normalization... // open ended range queries should always be inclusive. if (this.lowerTermText == null) { this.lowerTermText = ""; this.includeLower = true; } if (this.upperTermText == null) { this.includeUpper = true; } System.String startTermText = collator == null?this.lowerTermText:""; SetEnum(reader.Terms(new Term(this.field, startTermText))); }
/// <summary> Enumerates all terms greater/equal than <c>lowerTerm</c> /// but less/equal than <c>upperTerm</c>. /// /// If an endpoint is null, it is said to be "open". Either or both /// endpoints may be open. Open endpoints may not be exclusive /// (you can't select all but the first or last term without /// explicitly specifying the term to exclude.) /// /// </summary> /// <param name="reader"> /// </param> /// <param name="field">An interned field that holds both lower and upper terms. /// </param> /// <param name="lowerTermText">The term text at the lower end of the range /// </param> /// <param name="upperTermText">The term text at the upper end of the range /// </param> /// <param name="includeLower">If true, the <c>lowerTerm</c> is included in the range. /// </param> /// <param name="includeUpper">If true, the <c>upperTerm</c> is included in the range. /// </param> /// <param name="collator">The collator to use to collate index Terms, to determine their /// membership in the range bounded by <c>lowerTerm</c> and /// <c>upperTerm</c>. /// /// </param> /// <throws> IOException </throws> public TermRangeTermEnum(IndexReader reader, System.String field, System.String lowerTermText, System.String upperTermText, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator) { this.collator = collator; this.upperTermText = upperTermText; this.lowerTermText = lowerTermText; this.includeLower = includeLower; this.includeUpper = includeUpper; this.field = StringHelper.Intern(field); // do a little bit of normalization... // open ended range queries should always be inclusive. if (this.lowerTermText == null) { this.lowerTermText = ""; this.includeLower = true; } if (this.upperTermText == null) { this.includeUpper = true; } System.String startTermText = collator == null?this.lowerTermText:""; SetEnum(reader.Terms(new Term(this.field, startTermText))); }
static int CompareInfo_internal_compare(System.Globalization.CompareInfo ci, string str1, int offset1, int length1, string str2, int offset2, int length2, System.Globalization.CompareOptions options) { /* Based off the mono implementation */ int length = length1; if (length2 > length) { length = length2; } if ((offset1 + length) > str1.Length) { throw new Exception("Trying to compare more characters than exist in str1"); } if ((offset2 + length) > str2.Length) { throw new Exception("Trying to compare more characters than exist in str2"); } for (int i = 0; i < length; i++) { int cc = compare_char(str1[offset1 + i], str2[offset2 + i], options); if (cc != 0) { return(cc); } } return(0); }
public int Compare(String a, String b) { if (a == b) { return(0); } if (a == null) { return(-1); } if (b == null) { return(1); } string sa = a as string; string sb = b as string; System.Globalization.CompareInfo myComparer = System.Globalization.CompareInfo.GetCompareInfo("en-US"); if (sa != null && sb != null) { return(myComparer.Compare(sa, sb, System.Globalization.CompareOptions.Ordinal)); } throw new ArgumentException("a and b should be strings."); }
/// <summary> Compares the the attributes of the first LdapEntry to the second. /// Only the values of the attributes named at the construction of this /// object will be compared. Multi-valued attributes compare on the first /// value only. /// /// </summary> /// <param name="object1"> Target entry for comparison. /// /// </param> /// <param name="object2"> Entry to be compared to. /// /// </param> /// <returns> Negative value if the first entry is less than the second and /// positive if the first is greater than the second. Zero is returned if all /// attributes to be compared are the same. /// </returns> public virtual int Compare(object object1, object object2) { LdapEntry entry1 = (LdapEntry)object1; LdapEntry entry2 = (LdapEntry)object2; LdapAttribute one, two; string[] first; //multivalued attributes are ignored. string[] second; //we just use the first element int compare, i = 0; if (collator == null) { //using default locale collator = System.Globalization.CultureInfo.CurrentCulture.CompareInfo; } do { //while first and second are equal one = entry1.getAttribute(sortByNames[i]); two = entry2.getAttribute(sortByNames[i]); if ((one != null) && (two != null)) { first = one.StringValueArray; second = two.StringValueArray; compare = collator.Compare(first[0], second[0]); } //We could also use the other multivalued attributes to break ties. //one of the entries was null else { if (one != null) { compare = -1; } //one is greater than two else if (two != null) { compare = 1; } //one is lesser than two else { compare = 0; //tie - break it with the next attribute name } } i++; }while ((compare == 0) && (i < sortByNames.Length)); if (sortAscending[i - 1]) { // return the normal ascending comparison. return(compare); } // negate the comparison for a descending comparison. return(-compare); }
/// <summary>Constructs a query selecting all terms greater/equal than /// <code>lowerTerm</code> but less/equal than <code>upperTerm</code>. /// <p/> /// If an endpoint is null, it is said /// to be "open". Either or both endpoints may be open. Open endpoints may not /// be exclusive (you can't select all but the first or last term without /// explicitly specifying the term to exclude.) /// <p/> /// If <code>collator</code> is not null, it will be used to decide whether /// index terms are within the given range, rather than using the Unicode code /// point order in which index terms are stored. /// <p/> /// <strong>WARNING:</strong> Using this constructor and supplying a non-null /// value in the <code>collator</code> parameter will cause every single /// index Term in the Field referenced by lowerTerm and/or upperTerm to be /// examined. Depending on the number of index Terms in this Field, the /// operation could be very slow. /// /// </summary> /// <param name="lowerTerm">The Term text at the lower end of the range /// </param> /// <param name="upperTerm">The Term text at the upper end of the range /// </param> /// <param name="includeLower">If true, the <code>lowerTerm</code> is /// included in the range. /// </param> /// <param name="includeUpper">If true, the <code>upperTerm</code> is /// included in the range. /// </param> /// <param name="collator">The collator to use to collate index Terms, to determine /// their membership in the range bounded by <code>lowerTerm</code> and /// <code>upperTerm</code>. /// </param> public TermRangeQuery(System.String field, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator) { this.field = field; this.lowerTerm = lowerTerm; this.upperTerm = upperTerm; this.includeLower = includeLower; this.includeUpper = includeUpper; this.collator = collator; }
// Fetch the HTML Title from remote page public void GetTitle() { // Check Prefix System.Globalization.CompareInfo cmpUrl = System.Globalization.CultureInfo.InvariantCulture.CompareInfo; if (cmpUrl.IsPrefix(this.tb_LinkUrl.Text, "http") == false) { this.tb_LinkUrl.Text = "http://" + this.tb_LinkUrl.Text; } }
/// <summary> /// 指定した文字列内の指定した文字列を別の文字列に置換する。 /// </summary> /// <param name="input">置換する文字列のある文字列。</param> /// <param name="oldValue">検索文字列。</param> /// <param name="newValue">置換文字列。</param> /// <param name="count">置換する回数。負の数が指定されたときは、すべて置換する。</param> /// <param name="compInfo">文字列の検索に使用するCompareInfo。</param> /// <param name="compOptions">文字列の検索に使用するCompareOptions。</param> /// <returns>置換された結果の文字列。</returns> private static string StringReplace( string input, string oldValue, string newValue, int count, System.Globalization.CompareInfo compInfo, System.Globalization.CompareOptions compOptions) { if (input == null || input.Length == 0 || oldValue == null || oldValue.Length == 0 || count == 0) { return(input); } if (compInfo == null) { compInfo = System.Globalization.CultureInfo.InvariantCulture.CompareInfo; compOptions = System.Globalization.CompareOptions.Ordinal; } int inputLen = input.Length; int oldValueLen = oldValue.Length; System.Text.StringBuilder buf = new System.Text.StringBuilder(inputLen); int currentPoint = 0; int foundPoint = -1; int currentCount = 0; do { //文字列を検索する foundPoint = compInfo.IndexOf(input, oldValue, currentPoint, compOptions); if (foundPoint < 0) { buf.Append(input.Substring(currentPoint)); break; } //見つかった文字列を新しい文字列に換える buf.Append(input.Substring(currentPoint, foundPoint - currentPoint)); buf.Append(newValue); //次の検索開始位置を取得 currentPoint = foundPoint + oldValueLen; //指定回数置換したか調べる currentCount++; if (currentCount == count) { buf.Append(input.Substring(currentPoint)); break; } }while (currentPoint < inputLen); return(buf.ToString()); }
static private void getBoneOrder(ref int order, ref BoneCategory category, string source, string query, BoneCategory setCategory = BoneCategory.Other) { System.Globalization.CompareInfo ci = System.Globalization.CultureInfo.CurrentCulture.CompareInfo; //source内にqueryが含まれていた場合、序数とカテゴリを代入 if (0 <= ci.IndexOf(source, query, System.Globalization.CompareOptions.IgnoreWidth)) { order = orderCount; category = setCategory; } orderCount++; }
/// <summary> /// ReSort elements in the parent of <c>node</c> /// </summary> /// <remarks> /// Get the parent of this node and resort this node in the /// collection of nodes. We only operate on this node and we /// assume all nodes are already sorted except for this node /// </remarks> /// <param name="node">The node to sort</param> private void ReSortNodes(TreeNode node) { // We need to sort the node and rename it TreeNode parent = node.Parent; if (parent != null) { int newindex = -1; int curindex = -1; System.Globalization.CompareInfo comp = System.Globalization.CultureInfo.CurrentCulture.CompareInfo; for (int i = 0; i < parent.Nodes.Count; i++) { TreeNode tnode = parent.Nodes[i]; // We assume that the collection is already sorted if (newindex == -1 && comp.Compare(node.Text, tnode.Text) < 0) { newindex = i; } if (node == tnode) { curindex = i; } } if (curindex != -1) { // We found the node we're editing. if (newindex == -1) { // This node is to be put at the end newindex = parent.Nodes.Count - 1; } if (curindex < newindex) { --newindex; } SelectedNode = null; BeginUpdate(); parent.Nodes.RemoveAt(curindex); parent.Nodes.Insert(newindex, node); EndUpdate(); } } }
/// <summary>Constructs a query selecting all terms greater than /// <code>lowerTerm</code> but less than <code>upperTerm</code>. /// There must be at least one term and either term may be null, /// in which case there is no bound on that side, but if there are /// two terms, both terms <b>must</b> be for the same field. /// <p/> /// If <code>collator</code> is not null, it will be used to decide whether /// index terms are within the given range, rather than using the Unicode code /// point order in which index terms are stored. /// <p/> /// <strong>WARNING:</strong> Using this constructor and supplying a non-null /// value in the <code>collator</code> parameter will cause every single /// index Term in the Field referenced by lowerTerm and/or upperTerm to be /// examined. Depending on the number of index Terms in this Field, the /// operation could be very slow. /// /// </summary> /// <param name="lowerTerm">The Term at the lower end of the range /// </param> /// <param name="upperTerm">The Term at the upper end of the range /// </param> /// <param name="inclusive">If true, both <code>lowerTerm</code> and /// <code>upperTerm</code> will themselves be included in the range. /// </param> /// <param name="collator">The collator to use to collate index Terms, to determine /// their membership in the range bounded by <code>lowerTerm</code> and /// <code>upperTerm</code>. /// </param> public RangeQuery(Term lowerTerm, Term upperTerm, bool inclusive, System.Globalization.CompareInfo collator) { if (lowerTerm == null && upperTerm == null) { throw new System.ArgumentException("At least one term must be non-null"); } if (lowerTerm != null && upperTerm != null && (System.Object)lowerTerm.Field() != (System.Object)upperTerm.Field()) { throw new System.ArgumentException("Both terms must have the same field"); } delegate_Renamed = new TermRangeQuery((lowerTerm == null)?upperTerm.Field():lowerTerm.Field(), (lowerTerm == null)?null:lowerTerm.Text(), (upperTerm == null)?null:upperTerm.Text(), inclusive, inclusive, collator); delegate_Renamed.SetRewriteMethod(TermRangeQuery.SCORING_BOOLEAN_QUERY_REWRITE); }
internal CultureInfo(string cultureName, string textAndCompareCultureName) { if (cultureName == null) { throw new ArgumentNullException("cultureName", Environment.GetResourceString("ArgumentNull_String")); } this.m_cultureTableRecord = CultureTableRecord.GetCultureTableRecord(cultureName, false); this.cultureID = this.m_cultureTableRecord.ActualCultureID; this.m_name = this.m_cultureTableRecord.ActualName; CultureInfo cultureInfo = GetCultureInfo(textAndCompareCultureName); this.compareInfo = cultureInfo.CompareInfo; this.textInfo = cultureInfo.TextInfo; }
public BplusTreeLong(System.IO.Stream fromfile, int NodeSize, int KeyLength, long StartSeek, int CultureId) { this.cultureContext = new System.Globalization.CultureInfo(CultureId); this.cmp = this.cultureContext.CompareInfo; this.fromfile = fromfile; this.NodeSize = NodeSize; this.seekStart = StartSeek; // add in key prefix overhead this.KeyLength = KeyLength + BufferFile.SHORTSTORAGE; this.rootSeek = NULLBUFFERNUMBER; this.root = null; this.freeHeadSeek = NULLBUFFERNUMBER; this.SanityCheck(); }
/// <summary>Returns an array of collators, possibly <code>null</code>. The collators /// correspond to any SortFields which were given a specific locale. /// </summary> /// <param name="fields">Array of sort fields. /// </param> /// <returns> Array, possibly <code>null</code>. /// </returns> private System.Globalization.CompareInfo[] HasCollators(SortField[] fields) { if (fields == null) { return(null); } System.Globalization.CompareInfo[] ret = new System.Globalization.CompareInfo[fields.Length]; for (int i = 0; i < fields.Length; ++i) { System.Globalization.CultureInfo locale = fields[i].GetLocale(); if (locale != null) { ret[i] = locale.CompareInfo; } } return(ret); }
/// <summary>Returns an array of collators, possibly <c>null</c>. The collators /// correspond to any SortFields which were given a specific locale. /// </summary> /// <param name="fields">Array of sort fields.</param> /// <returns> Array, possibly <c>null</c>.</returns> private System.Globalization.CompareInfo[] HasCollators(ArraySegment <SortField> fields) { if (fields == null) { return(null); } System.Globalization.CompareInfo[] ret = new System.Globalization.CompareInfo[fields.Count]; for (int i = 0; i < fields.Count; ++i) { System.Globalization.CultureInfo locale = fields.Array[i + fields.Offset].Locale; if (locale != null) { ret[i] = locale.CompareInfo; } } return(ret); }
internal CultureInfo(string cultureName, string textAndCompareCultureName) { this.cultureID = 0x7f; if (cultureName == null) { throw new ArgumentNullException("cultureName", Environment.GetResourceString("ArgumentNull_String")); } this.m_cultureData = CultureData.GetCultureData(cultureName, false); if (this.m_cultureData == null) { throw new CultureNotFoundException("cultureName", cultureName, Environment.GetResourceString("Argument_CultureNotSupported")); } this.m_name = this.m_cultureData.CultureName; CultureInfo cultureInfo = GetCultureInfo(textAndCompareCultureName); this.compareInfo = cultureInfo.CompareInfo; this.textInfo = cultureInfo.TextInfo; }
public static bool IsValidUrl(string url) { if (string.IsNullOrEmpty(url)) { return(false); } System.Globalization.CompareInfo cmpUrl = System.Globalization.CultureInfo.InvariantCulture.CompareInfo; if (cmpUrl.IsPrefix(url, "http://") == false && cmpUrl.IsPrefix(url, "https://") == false) { url = "http://" + url; } //Regex urlRegex = new Regex("(^|[^\\w'\"]|\\G)(?<uri>(?:https?|ftp)://(?:[^./\\s'\"<)\\]]+\\.)+[^./\\s'\"<)\\]]+(?:/.*?)?)(\\.[\\s<'\"]|[\\s,<'\"]|$)", RegexOptions.Compiled | RegexOptions.IgnoreCase); // Regex("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(/?([^#]*))?(#(.*))?"); //^((https?|ftp)://|(www|ftp)\.)[a-z0-9-]+(\.[a-z0-9-]+)+([/?].*)?$ Regex urlRegex = new Regex("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(/?([^#]*))?(#(.*))?"); return(urlRegex.IsMatch(url)); }
static int internal_index(System.Globalization.CompareInfo _this, string source, int sIndex, int count, string value, System.Globalization.CompareOptions options, bool first) { // if first == true find first incidence, else find last if (first) { for (int i = sIndex; i < (sIndex + count); i++) { bool found = true; for (int j = 0; j < value.Length; j++) { if (source[j + i] != value[j]) { found = false; break; } } if (found) { return(i); } } } else { for (int i = (sIndex + count - 1); i >= sIndex; i--) { bool found = true; for (int j = 0; j < value.Length; j++) { if (source[j + i] != value[j]) { found = false; break; } } if (found) { return(i); } } } return(-1); }
public static bool IsValidUrl(string url) { bool bResponse = false; System.Globalization.CompareInfo cmpUrl = System.Globalization.CultureInfo.InvariantCulture.CompareInfo; if (cmpUrl.IsPrefix(url, @"http://", System.Globalization.CompareOptions.IgnoreCase) == false) { url = @"http://" + url; } Regex RgxUrl = new Regex(@"^(http|https|ftp)\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(:[a-zA-Z0-9]*)?/?([a-zA-Z0-9\-\._\?\,\'/\\\+&%\$#\=~])*[^\.\,\)\(\s]$", RegexOptions.Compiled | RegexOptions.IgnoreCase); if (RgxUrl.IsMatch(url)) { bResponse = true; } else { bResponse = false; } return(bResponse); }
/* * <summary>Customised Compare Class</summary> * <remarks> * <para> * The Virtual Payment Client need to use an Ordinal comparison to Sort on * the field names to create the SHA256 Signature for validation of the message. * This class provides a Compare method that is used to allow the sorted list * to be ordered using an Ordinal comparison. * </para> * </remarks> */ public int Compare(String a, String b) { /* * <summary>Compare method using Ordinal comparison</summary> * <param name="a">The first string in the comparison.</param> * <param name="b">The second string in the comparison.</param> * <returns>An int containing the result of the comparison.</returns> */ // Return if we are comparing the same object or one of the // objects is null, since we don't need to go any further. if (a == b) { return(0); } if (a == null) { return(-1); } if (b == null) { return(1); } // Ensure we have string to compare string sa = a as string; string sb = b as string; // Get the CompareInfo object to use for comparing System.Globalization.CompareInfo myComparer = System.Globalization.CompareInfo.GetCompareInfo("en-US"); if (sa != null && sb != null) { // Compare using an Ordinal Comparison. return(myComparer.Compare(sa, sb, System.Globalization.CompareOptions.Ordinal)); } throw new ArgumentException("a and b should be strings."); }
static StackObject *Compare_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj) { ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain; StackObject *ptr_of_this_method; StackObject *__ret = ILIntepreter.Minus(__esp, 3); ptr_of_this_method = ILIntepreter.Minus(__esp, 1); System.String @string2 = (System.String) typeof(System.String).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 2); System.String @string1 = (System.String) typeof(System.String).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); ptr_of_this_method = ILIntepreter.Minus(__esp, 3); System.Globalization.CompareInfo instance_of_this_method = (System.Globalization.CompareInfo) typeof(System.Globalization.CompareInfo).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack)); __intp.Free(ptr_of_this_method); var result_of_this_method = instance_of_this_method.Compare(@string1, @string2); __ret->ObjectType = ObjectTypes.Integer; __ret->Value = result_of_this_method; return(__ret + 1); }
internal StringComparatorLocale(int numHits, System.String field, System.Globalization.CultureInfo locale) { values = new System.String[numHits]; this.field = field; collator = locale.CompareInfo; }
private void InitBlock(System.String[] index, System.Globalization.CompareInfo collator) { this.index = index; this.collator = collator; }
public AnonymousClassScoreDocComparator3(System.Globalization.CompareInfo collator, System.String[] index) { InitBlock(collator, index); }
private void InitBlock() { // location = Locale.getDefault(); location=System.Globalization.CultureInfo.CurrentCulture; collator = System.Globalization.CultureInfo.CurrentCulture.CompareInfo; }
/// <summary> Compares the the attributes of the first LdapEntry to the second. /// Only the values of the attributes named at the construction of this /// object will be compared. Multi-valued attributes compare on the first /// value only. /// /// </summary> /// <param name="object1"> Target entry for comparison. /// /// </param> /// <param name="object2"> Entry to be compared to. /// /// </param> /// <returns> Negative value if the first entry is less than the second and /// positive if the first is greater than the second. Zero is returned if all /// attributes to be compared are the same. /// </returns> public virtual int Compare(System.Object object1, System.Object object2) { LdapEntry entry1 = (LdapEntry) object1; LdapEntry entry2 = (LdapEntry) object2; LdapAttribute one, two; System.String[] first; //multivalued attributes are ignored. System.String[] second; //we just use the first element int compare, i = 0; if (collator == null) { //using default locale collator = System.Globalization.CultureInfo.CurrentCulture.CompareInfo; } do { //while first and second are equal one = entry1.getAttribute(sortByNames[i]); two = entry2.getAttribute(sortByNames[i]); if ((one != null) && (two != null)) { first = one.StringValueArray; second = two.StringValueArray; compare = collator.Compare(first[0], second[0]); } //We could also use the other multivalued attributes to break ties. //one of the entries was null else { if (one != null) compare = - 1; //one is greater than two else if (two != null) compare = 1; //one is lesser than two else compare = 0; //tie - break it with the next attribute name } i++; } while ((compare == 0) && (i < sortByNames.Length)); if (sortAscending[i - 1]) { // return the normal ascending comparison. return compare; } else { // negate the comparison for a descending comparison. return - compare; } }
public RangeQuery(Term lowerTerm, Term upperTerm, bool inclusive, CompareInfo collator) : this(lowerTerm, upperTerm, inclusive) { this.collator = collator; }
/// <summary> <strong>WARNING:</strong> Using this constructor and supplying a non-null /// value in the <code>collator</code> parameter will cause every single /// index Term in the Field referenced by lowerTerm and/or upperTerm to be /// examined. Depending on the number of index Terms in this Field, the /// operation could be very slow. /// /// </summary> /// <param name="lowerTerm">The lower bound on this range /// </param> /// <param name="upperTerm">The upper bound on this range /// </param> /// <param name="includeLower">Does this range include the lower bound? /// </param> /// <param name="includeUpper">Does this range include the upper bound? /// </param> /// <param name="collator">The collator to use when determining range inclusion; set /// to null to use Unicode code point ordering instead of collation. /// </param> /// <throws> IllegalArgumentException if both terms are null or if </throws> /// <summary> lowerTerm is null and includeLower is true (similar for upperTerm /// and includeUpper) /// </summary> public RangeFilter(System.String fieldName, System.String lowerTerm, System.String upperTerm, bool includeLower, bool includeUpper, System.Globalization.CompareInfo collator) : base(new TermRangeQuery(fieldName, lowerTerm, upperTerm, includeLower, includeUpper, collator)) { }
/// <summary> /// WARNING: Using this constructor and supplying a non-null /// value in the collator paramter will cause every single /// index Term in the Field referenced by lowerTerm and/or upperTerm /// to be examined. Depending on the number of index Terms in this /// Field, the operation could be very slow. /// </summary> /// <param name="fieldName"></param> /// <param name="lowerTerm">lower bound</param> /// <param name="upperTerm">upper bound</param> /// <param name="includeLower">is lower bound inclusive</param> /// <param name="includeUpper">is upper bound inclusive</param> /// <param name="collator">the collator that determines range inclusion; when set to null Unicode code point ordering is used</param> public RangeFilter(string fieldName, string lowerTerm, string upperTerm, bool includeLower, bool includeUpper, CompareInfo collator) : this(fieldName, lowerTerm, upperTerm, includeLower, includeUpper) { this.collator = collator; }
/// <summary> Sets the collator used to determine index term inclusion in ranges /// for RangeQuerys. /// <p/> /// <strong>WARNING:</strong> Setting the rangeCollator to a non-null /// collator using this method will cause every single index Term in the /// Field referenced by lowerTerm and/or upperTerm to be examined. /// Depending on the number of index Terms in this Field, the operation could /// be very slow. /// /// </summary> /// <param name="rc"> the collator to use when constructing RangeQuerys /// </param> public virtual void SetRangeCollator(System.Globalization.CompareInfo rc) { rangeCollator = rc; }
public int Compare(string left, string right, bool caseSensitive) { if (!caseSensitive) { left = left.ToLower(); right = right.ToLower(); } //System.Globalization.CompareInfo cmp = this.cultureContext.CompareInfo; if (this.cultureContext==null || this.DontUseCulture) { // no culture context: use miscellaneous total ordering on unicode strings int i = 0; while (i<left.Length && i<right.Length) { int leftOrd = Convert.ToInt32(left[i]); int rightOrd = Convert.ToInt32(right[i]); if (leftOrd<rightOrd) { return -1; } if (leftOrd>rightOrd) { return 1; } i++; } if (left.Length<right.Length) { return -1; } if (left.Length>right.Length) { return 1; } return 0; } if (this.cmp==null) { this.cmp = this.cultureContext.CompareInfo; } return this.cmp.Compare(left, right); }
static string InternalReplace(string str, string old_value, string new_value, System.Globalization.CompareInfo ci) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < str.Length; i++) { bool found = true; for (int j = 0; j < old_value.Length; j++) { if (((i + j) >= str.Length) || (str[i + j] != old_value[j])) { found = false; break; } } if (found) { sb.Append(new_value); i += old_value.Length; i--; // the for loop adds a 1 for us } else { sb.Append(str[i]); } } return(sb.ToString()); }
public ConstantScoreRangeQuery(string fieldName, string lowerVal, string upperVal, bool includeLower, bool includeUpper, CompareInfo collator) : this(fieldName, lowerVal, upperVal, includeLower, includeUpper) { this.collator = collator; }
public AnonymousClassScoreDocComparator5(System.String[] index, System.Globalization.CompareInfo collator) { InitBlock(index, collator); }
/// <summary>Returns an array of collators, possibly <code>null</code>. The collators /// correspond to any SortFields which were given a specific locale. /// </summary> /// <param name="fields">Array of sort fields. /// </param> /// <returns> Array, possibly <code>null</code>. /// </returns> private System.Globalization.CompareInfo[] HasCollators(SortField[] fields) { if (fields == null) return null; System.Globalization.CompareInfo[] ret = new System.Globalization.CompareInfo[fields.Length]; for (int i = 0; i < fields.Length; ++i) { System.Globalization.CultureInfo locale = fields[i].GetLocale(); if (locale != null) ret[i] = locale.CompareInfo; } return ret; }
/// <summary>macro for readability </summary> public static Query Csrq(System.String f, System.String l, System.String h, bool il, bool ih, System.Globalization.CompareInfo c) { TermRangeQuery query = new TermRangeQuery(f, l, h, il, ih, c); query.SetRewriteMethod(MultiTermQuery.CONSTANT_SCORE_FILTER_REWRITE); return(query); }