svl/source/numbers/zforfind.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SVL_SOURCE_NUMBERS_ZFORFIND_HXX
  21 #define INCLUDED_SVL_SOURCE_NUMBERS_ZFORFIND_HXX
  22
  23 #include <com/sun/star/uno/Sequence.hxx>
  24 #include <rtl/ustring.hxx>
  25 #include <memory>
  26
  27 class Date;
  28 class SvNumberformat;
  29 class SvNumberFormatter;
  30 enum class SvNumFormatType : sal_Int16;
  31
  32 #define SV_MAX_COUNT_INPUT_STRINGS  20    // max count of substrings in input scanner
  33
  34 class ImpSvNumberInputScan
  35 {
  36 public:
  37     explicit ImpSvNumberInputScan( SvNumberFormatter* pFormatter );
  38     ~ImpSvNumberInputScan();
  39
  40 /*!*/   void ChangeIntl();                      // MUST be called if language changes
  41
  42     /// set reference date for offset calculation
  43     void ChangeNullDate( const sal_uInt16 nDay,
  44                          const sal_uInt16 nMonth,
  45                          const sal_Int16 nYear );
  46
  47     /// convert input string to number
  48     bool IsNumberFormat( const OUString& rString,            /// input string
  49                          SvNumFormatType& F_Type,                      /// format type (in + out)
  50                          double& fOutNumber,                 /// value determined (out)
  51                          const SvNumberformat* pFormat);     /// number format to which compare against
  52
  53     /// after IsNumberFormat: get decimal position
  54     short   GetDecPos() const { return nDecPos; }
  55     /// after IsNumberFormat: get count of numeric substrings in input string
  56     sal_uInt16  GetNumericsCount() const { return nNumericsCnt; }
  57
  58     /// set threshold of two-digit year input
  59     void    SetYear2000( sal_uInt16 nVal ) { nYear2000 = nVal; }
  60     /// get threshold of two-digit year input
  61     sal_uInt16  GetYear2000() const { return nYear2000; }
  62
  63     /** Whether input can be forced to ISO 8601 format.
  64
  65         Depends on locale's date separator and a specific date format order.
  66      */
  67     bool CanForceToIso8601( DateOrder eDateOrder );
  68
  69     void InvalidateDateAcceptancePatterns();
  70
  71 private:
  72     SvNumberFormatter*  pFormatter;
  73     const SvNumberformat* mpFormat;                            //* The format to compare against, if any
  74     std::unique_ptr<OUString[]> pUpperMonthText;               //* Array of month names, uppercase
  75     std::unique_ptr<OUString[]> pUpperAbbrevMonthText;         //* Array of month names, abbreviated, uppercase
  76     std::unique_ptr<OUString[]> pUpperGenitiveMonthText;       //* Array of genitive month names, uppercase
  77     std::unique_ptr<OUString[]> pUpperGenitiveAbbrevMonthText; //* Array of genitive month names, abbreviated, uppercase
  78     std::unique_ptr<OUString[]> pUpperPartitiveMonthText;      //* Array of partitive month names, uppercase
  79     std::unique_ptr<OUString[]> pUpperPartitiveAbbrevMonthText;//* Array of partitive month names, abbreviated, uppercase
  80     std::unique_ptr<OUString[]> pUpperDayText;                 //* Array of day of week names, uppercase
  81     std::unique_ptr<OUString[]> pUpperAbbrevDayText;           //* Array of day of week names, abbreviated, uppercase
  82     OUString  aUpperCurrSymbol;                 //* Currency symbol, uppercase
  83     bool    bTextInitialized;                   //* Whether days and months are initialized
  84     bool    bScanGenitiveMonths;                //* Whether to scan an input for genitive months
  85     bool    bScanPartitiveMonths;               //* Whether to scan an input for partitive months
  86     std::unique_ptr<Date> pNullDate;                 //* 30Dec1899
  87     // Variables for provisional results:
  88     OUString   sStrArray[SV_MAX_COUNT_INPUT_STRINGS];//* Array of scanned substrings
  89     bool       IsNum[SV_MAX_COUNT_INPUT_STRINGS];    //* Whether a substring is numeric
  90     sal_uInt16 nNums[SV_MAX_COUNT_INPUT_STRINGS];    //* Sequence of offsets to numeric strings
  91     sal_uInt16 nStringsCnt;                          //* Total count of scanned substrings
  92     sal_uInt16 nNumericsCnt;                         //* Count of numeric substrings
  93     bool       bDecSepInDateSeps;                    //* True <=> DecSep in {.,-,/,DateSep}
  94     sal_uInt8  nMatchedAllStrings;                   //* Scan...String() matched all substrings,
  95
  96     // bit mask of nMatched... constants
  97     static const sal_uInt8 nMatchedEndString;        // 0x01
  98     static const sal_uInt8 nMatchedMidString;        // 0x02
  99     static const sal_uInt8 nMatchedStartString;      // 0x04
 100     static const sal_uInt8 nMatchedVirgin;           // 0x08
 101     static const sal_uInt8 nMatchedUsedAsReturn;     // 0x10
 102
 103     int    nSign;                               // Sign of number
 104     int    nMonth;                              // Month (1..x) if date
 105                                                 // negative => short format
 106     short  nMonthPos;                           // 1 = front, 2 = middle
 107                                                 // 3 = end
 108     int    nDayOfWeek;                          // Temporary (!) day of week (1..7,-1..-7) if date
 109     sal_uInt16 nTimePos;                        // Index of first time separator (+1)
 110     short  nDecPos;                             // Index of substring containing "," (+1)
 111     bool   bNegCheck;                           // '( )' for negative
 112     short  nESign;                              // Sign of exponent
 113     short  nAmPm;                               // +1 AM, -1 PM, 0 if none
 114     short  nLogical;                            // -1 => False, 1 => True
 115     bool   mbEraCE;                            // Era if date, 0 => BCE, 1 => CE (currently only Gregorian)
 116     sal_uInt16 nThousand;                       // Count of group (AKA thousand) separators
 117     sal_uInt16 nPosThousandString;              // Position of concatenated 000,000,000 string
 118     SvNumFormatType eScannedType;               // Scanned type
 119     SvNumFormatType eSetType;                   // Preset Type
 120
 121     sal_uInt16 nStringScanNumFor;               // Fixed strings recognized in
 122                                                 // pFormat->NumFor[nNumForStringScan]
 123     short  nStringScanSign;                     // Sign resulting of FixString
 124     sal_uInt16 nYear2000;                       // Two-digit threshold
 125                                                 // Year as 20xx
 126                                                 // default 18
 127                                                 // number <= nYear2000 => 20xx
 128                                                 // number >  nYear2000 => 19xx
 129
 130     /** State of ISO 8601 detection.
 131
 132         0:= don't know yet
 133         1:= no
 134         2:= yes, <=2 digits in year
 135         3:= yes,   3 digits in year
 136         4:= yes, >=4 digits in year
 137
 138         @see MayBeIso8601()
 139      */
 140     sal_uInt8    nMayBeIso8601;
 141
 142     /** Whether the 'T' time separator was detected in an ISO 8601 string. */
 143     bool        bIso8601Tsep;
 144
 145     /** State of dd-month-yy or yy-month-dd detection, with month name.
 146
 147         0:= don't know yet
 148         1:= no
 149         2:= yes, dd-month-yy
 150         3:= yes, yy-month-dd
 151
 152         @see MayBeMonthDate()
 153      */
 154     sal_uInt8   nMayBeMonthDate;
 155
 156     /** Input matched this locale dependent date acceptance pattern.
 157         -2 if not checked yet, -1 if no match, >=0 matched pattern.
 158
 159         @see IsAcceptedDatePattern()
 160      */
 161     sal_Int32   nAcceptedDatePattern;
 162     css::uno::Sequence< OUString >  sDateAcceptancePatterns;
 163
 164     /** If input matched a date acceptance pattern that starts at input
 165         particle sStrArray[nDatePatternStart].
 166
 167         @see IsAcceptedDatePattern()
 168      */
 169     sal_uInt16  nDatePatternStart;
 170
 171     /** Count of numbers that matched the accepted pattern, if any, else 0.
 172
 173         @see GetDatePatternNumbers()
 174      */
 175     sal_uInt16  nDatePatternNumbers;
 176
 177     // Copy assignment is forbidden and not implemented.
 178     ImpSvNumberInputScan (const ImpSvNumberInputScan &) = delete;
 179     ImpSvNumberInputScan & operator= (const ImpSvNumberInputScan &) = delete;
 180
 181     void Reset();                               // Reset all variables before start of analysis
 182
 183     void InitText();                            // Init of months and days of week
 184
 185     // Convert string to double.
 186     // Only simple unsigned floating point values without any error detection,
 187     // decimal separator has to be '.'
 188     // If bForceFraction==true the string is taken to be the fractional part
 189     // of 0.1234 without the leading 0. (thus being just "1234").
 190     static double StringToDouble( const OUString& rStr,
 191                                   bool bForceFraction = false );
 192
 193     // Next number/string symbol
 194     static bool NextNumberStringSymbol( const sal_Unicode*& pStr,
 195                                         OUString& rSymbol );
 196
 197     // Concatenate ,000,23 blocks
 198     // in input to 000123
 199     bool SkipThousands( const sal_Unicode*& pStr, OUString& rSymbol ) const;
 200
 201     // Divide numbers/strings into
 202     // arrays and variables above.
 203     // Leading blanks and blanks
 204     // after numbers are thrown away
 205     void NumberStringDivision( const OUString& rString );
 206
 207
 208     /** Whether rString contains word (!) rWhat at nPos.
 209         rWhat will not be matched if it is a substring of a word.
 210      */
 211     bool StringContainsWord( const OUString& rWhat,
 212                              const OUString& rString,
 213                              sal_Int32 nPos ) const;
 214
 215     // optimized substring versions
 216
 217     // Whether rString contains rWhat at nPos
 218     static bool StringContains( const OUString& rWhat,
 219                                        const OUString& rString,
 220                                        sal_Int32 nPos )
 221         {
 222             if (rWhat.isEmpty() || rString.getLength() <= nPos)
 223             {
 224                 return false;
 225             }
 226             // mostly used with one character
 227             if ( rWhat[ 0 ] != rString[ nPos ] )
 228             {
 229                 return false;
 230             }
 231             return StringContainsImpl( rWhat, rString, nPos );
 232         }
 233
 234     // Whether pString contains rWhat at nPos
 235     static bool StringPtrContains( const OUString& rWhat,
 236                                           const sal_Unicode* pString,
 237                                           sal_Int32 nPos ) // nPos MUST be a valid offset from pString
 238         {
 239             // mostly used with one character
 240             if ( rWhat[ 0 ] != pString[ nPos ] )
 241             {
 242                 return false;
 243             }
 244             return StringPtrContainsImpl( rWhat, pString, nPos );
 245         }
 246
 247     //! DO NOT use directly
 248     static bool StringContainsImpl( const OUString& rWhat,
 249                                     const OUString& rString,
 250                                     sal_Int32 nPos );
 251     //! DO NOT use directly
 252     static bool StringPtrContainsImpl( const OUString& rWhat,
 253                                        const sal_Unicode* pString,
 254                                        sal_Int32 nPos );
 255
 256     // Skip a special character
 257     static inline bool SkipChar( sal_Unicode c,
 258                                  const OUString& rString,
 259                                  sal_Int32& nPos );
 260
 261     // Skip blank
 262     static inline void SkipBlanks( const OUString& rString,
 263                                    sal_Int32& nPos );
 264
 265     // Jump over rWhat in rString at nPos
 266     static inline bool SkipString( const OUString& rWhat,
 267                                    const OUString& rString,
 268                                    sal_Int32& nPos );
 269
 270     // Recognizes exactly ,111 as group separator
 271     inline bool GetThousandSep( const OUString& rString,
 272                                 sal_Int32& nPos,
 273                                 sal_uInt16 nStringPos ) const;
 274     // Get boolean value
 275     short GetLogical( const OUString& rString ) const;
 276
 277     // Get month and advance string position
 278     short GetMonth( const OUString& rString,
 279                     sal_Int32& nPos );
 280
 281     // Get day of week and advance string position
 282     int GetDayOfWeek( const OUString& rString,
 283                       sal_Int32& nPos );
 284
 285     // Get currency symbol and advance string position
 286     bool GetCurrency( const OUString& rString,
 287                       sal_Int32& nPos );
 288
 289     // Get symbol AM or PM and advance string position
 290     bool GetTimeAmPm( const OUString& rString,
 291                       sal_Int32& nPos );
 292
 293     // Get decimal separator and advance string position
 294     inline bool GetDecSep( const OUString& rString,
 295                            sal_Int32& nPos ) const;
 296
 297     // Get hundredth seconds separator and advance string position
 298     inline bool GetTime100SecSep( const OUString& rString,
 299                                   sal_Int32& nPos ) const;
 300
 301     // Get sign  and advance string position
 302     // Including special case '('
 303     int GetSign( const OUString& rString,
 304                  sal_Int32& nPos );
 305
 306     // Get sign of exponent and advance string position
 307     static short GetESign( const OUString& rString,
 308                            sal_Int32& nPos );
 309
 310     // Get next number as array offset
 311     inline bool GetNextNumber( sal_uInt16& i,
 312                                sal_uInt16& j ) const;
 313
 314     /** Converts time -> double (only decimals)
 315
 316         @return TRUE if time, FALSE if not (e.g. hours >12 with AM/PM)
 317      */
 318     bool GetTimeRef( double& fOutNumber,                     // result as double
 319                      sal_uInt16 nIndex,                      // Index of hour in input
 320                      sal_uInt16 nCnt ) const;                // Count of time substrings in input
 321     sal_uInt16 ImplGetDay  ( sal_uInt16 nIndex ) const;      // Day input, 0 if no match
 322     sal_uInt16 ImplGetMonth( sal_uInt16 nIndex ) const;      // Month input, zero based return, NumberOfMonths if no match
 323     sal_uInt16 ImplGetYear ( sal_uInt16 nIndex );   // Year input, 0 if no match
 324
 325     // Conversion of date to number
 326     bool GetDateRef( double& fDays,                          // OUT: days diff to null date
 327                      sal_uInt16& nCounter );                 // Count of date substrings
 328
 329     // Analyze start of string
 330     bool ScanStartString( const OUString& rString );
 331
 332     // Analyze middle substring
 333     bool ScanMidString( const OUString& rString,
 334                         sal_uInt16 nStringPos );
 335
 336
 337     // Analyze end of string
 338     bool ScanEndString( const OUString& rString );
 339
 340     // Compare rString to substring of array indexed by nString
 341     // nString == 0xFFFF => last substring
 342     bool ScanStringNumFor( const OUString& rString,
 343                            sal_Int32 nPos,
 344                            sal_uInt16 nString,
 345                            bool bDontDetectNegation = false );
 346
 347     // if nMatchedAllStrings set nMatchedUsedAsReturn and return true,
 348     // else do nothing and return false
 349     bool MatchedReturn();
 350
 351     //! Be sure that the string to be analyzed is already converted to upper
 352     //! case and if it contained native number digits that they are already
 353     //! converted to ASCII.
 354
 355     // Main analyzing function
 356     bool IsNumberFormatMain( const OUString& rString,
 357                              const SvNumberformat* pFormat);    // number format to match against
 358
 359     /** Whether input matches locale dependent date acceptance pattern.
 360
 361         @param nStartPatternAt
 362                The pattern matching starts at input particle
 363                sStrArray[nStartPatternAt].
 364
 365         NOTE: once called the result is remembered, subsequent calls with
 366         different parameters do not check for a match and do not lead to a
 367         different result.
 368      */
 369     bool IsAcceptedDatePattern( sal_uInt16 nStartPatternAt );
 370
 371     /** Sets (not advances!) rPos to sStrArray[nParticle].getLength() if string
 372         matches separator in pattern at nParticle.
 373
 374         Also detects a signed year case like M/D/-Y
 375
 376         @returns TRUE if separator matched.
 377      */
 378     bool SkipDatePatternSeparator( sal_uInt16 nParticle, sal_Int32 & rPos, bool & rSignedYear );
 379
 380     /** Returns count of numbers in accepted date pattern.
 381      */
 382     sal_uInt16 GetDatePatternNumbers();
 383
 384     /** Whether numeric string nNumber is of type cType in accepted date
 385         pattern, 'Y', 'M' or 'D'.
 386      */
 387     bool IsDatePatternNumberOfType( sal_uInt16 nNumber, sal_Unicode cType );
 388
 389     /** Obtain order of accepted date pattern coded as, for example,
 390         ('D'<<16)|('M'<<8)|'Y'
 391     */
 392     sal_uInt32 GetDatePatternOrder();
 393
 394     /** Obtain date format order, from accepted date pattern if available or
 395         otherwise the locale's default order.
 396      */
 397     DateOrder GetDateOrder();
 398
 399     /** Whether input may be an ISO 8601 date format, yyyy-mm-dd...
 400
 401         Checks if input has at least 3 numbers for yyyy-mm-dd and the separator
 402         is '-', and 1<=mm<=12 and 1<=dd<=31.
 403
 404         @see nMayBeIso8601
 405      */
 406     bool MayBeIso8601();
 407
 408     /** Whether input may be a dd-month-yy format, with month name, not
 409         number.
 410
 411         @see nMayBeMonthDate
 412      */
 413     bool MayBeMonthDate();
 414
 415     /** Whether input is acceptable as ISO 8601 date format in the current
 416         NfEvalDateFormat setting.
 417      */
 418     bool IsAcceptableIso8601();
 419 };
 420
 421 #endif // INCLUDED_SVL_SOURCE_NUMBERS_ZFORFIND_HXX
 422
 423 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */