Merge pull request #28 from alesha1488/master

Fix compilation under FreeBSD

Author: Alan Wright

src/core/document/NumberTools.cpp

@@ -50,7 +50,7 @@ namespace Lucene
 
     String NumberTools::longToString(int64_t l)
     {
-        if (l == LLONG_MIN)
+        if (l == std::numeric_limits<int64_t>::min())
         {
             // special case, because long is not symmetric around zero
             return MIN_STRING_VALUE();
@@ -62,7 +62,7 @@ namespace Lucene
         if (l < 0)
         {
             buf += NEGATIVE_PREFIX;
-            l = LLONG_MAX + l + 1;
+            l = std::numeric_limits<int64_t>::max() + l + 1;
         }
             buf += POSITIVE_PREFIX;
 
@@ -81,7 +81,7 @@ namespace Lucene
             boost::throw_exception(NumberFormatException(L"string is the wrong size"));
 
         if (str == MIN_STRING_VALUE())
-            return LLONG_MIN;
+            return std::numeric_limits<int64_t>::min();
 
         wchar_t prefix = str[0];
         int64_t l = StringUtils::toLong(str.substr(1), RADIX);
@@ -90,7 +90,7 @@ namespace Lucene
         { // nop
         }
         else if (prefix == NEGATIVE_PREFIX)
-            l = l - LLONG_MAX - 1;
+            l = l - std::numeric_limits<int64_t>::max() - 1;
         else
             boost::throw_exception(NumberFormatException(L"string does not begin with the correct prefix"));
 

src/core/index/LogByteSizeMergePolicy.cpp

@@ -19,7 +19,7 @@ namespace Lucene
     LogByteSizeMergePolicy::LogByteSizeMergePolicy(IndexWriterPtr writer) : LogMergePolicy(writer)
     {
         minMergeSize = (int64_t)(DEFAULT_MIN_MERGE_MB * 1024 * 1024);
-        maxMergeSize = DEFAULT_MAX_MERGE_MB == DBL_MAX ? LLONG_MAX : (int64_t)(DEFAULT_MAX_MERGE_MB * 1024 * 1024);
+        maxMergeSize = DEFAULT_MAX_MERGE_MB == DBL_MAX ? std::numeric_limits<int64_t>::max() : (int64_t)(DEFAULT_MAX_MERGE_MB * 1024 * 1024);
     }
 
     LogByteSizeMergePolicy::~LogByteSizeMergePolicy()

src/core/index/LogDocMergePolicy.cpp

@@ -17,7 +17,7 @@ namespace Lucene
         minMergeSize = DEFAULT_MIN_MERGE_DOCS;
 
         // maxMergeSize is never used by LogDocMergePolicy; set it to LLONG_MAX to disable it
-        maxMergeSize = LLONG_MAX;
+        maxMergeSize = std::numeric_limits<int64_t>::max();
     }
 
     LogDocMergePolicy::~LogDocMergePolicy()

src/core/search/FieldCacheRangeFilter.cpp

@@ -215,7 +215,7 @@ namespace Lucene
     }
 
     FieldCacheRangeFilterLong::FieldCacheRangeFilterLong(const String& field, ParserPtr parser, int64_t lowerVal, int64_t upperVal, bool includeLower, bool includeUpper)
-        : FieldCacheRangeFilterNumeric<int64_t>(field, parser, lowerVal, upperVal, LLONG_MAX, includeLower, includeUpper)
+        : FieldCacheRangeFilterNumeric<int64_t>(field, parser, lowerVal, upperVal, std::numeric_limits<int64_t>::max(), includeLower, includeUpper)
     {
     }
 

src/core/search/NumericRangeQuery.cpp

@@ -202,27 +202,27 @@ namespace Lucene
             case 64:
             {
                 // lower
-                int64_t minBound = LLONG_MIN;
+                int64_t minBound = std::numeric_limits<int64_t>::min();
                 if (VariantUtils::typeOf<int64_t>(query->min))
                     minBound = VariantUtils::get<int64_t>(query->min);
                 else if (VariantUtils::typeOf<double>(query->min))
                     minBound = NumericUtils::doubleToSortableLong(VariantUtils::get<double>(query->min));
                 if (!query->minInclusive && !VariantUtils::isNull(query->min))
                 {
-                    if (minBound == LLONG_MAX)
+                    if (minBound == std::numeric_limits<int64_t>::max())
                         break;
                     ++minBound;
                 }
 
                 // upper
-                int64_t maxBound = LLONG_MAX;
+                int64_t maxBound = std::numeric_limits<int64_t>::max();
                 if (VariantUtils::typeOf<int64_t>(query->max))
                     maxBound = VariantUtils::get<int64_t>(query->max);
                 else if (VariantUtils::typeOf<double>(query->max))
                     maxBound = NumericUtils::doubleToSortableLong(VariantUtils::get<double>(query->max));
                 if (!query->maxInclusive && !VariantUtils::isNull(query->max))
                 {
-                    if (maxBound == LLONG_MIN)
+                    if (maxBound == std::numeric_limits<int64_t>::min())
                         break;
                     --maxBound;
                 }