Changeset 571


Ignore:
Timestamp:
07/15/14 02:59:50 (5 years ago)
Author:
jls17
Message:
  • the DocTextReferences? class uses CARParseField class now (which has the currency support)
  • moved code for the field documentation to docField method
  • note: keywords in text aren't processed anymore; will get implemented in one of next commits
  • fixed a little issue in DocTextReferencesTest?.h
  • added another test
Location:
branches/work_311
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branches/work_311/core/AREnum.cpp

    r544 r571  
    26902690        } 
    26912691} 
     2692 
     2693const char* CAREnum::StatHistoryTag(int usrOrTime) 
     2694{ 
     2695        switch (usrOrTime) 
     2696        { 
     2697        case AR_STAT_HISTORY_USER: return "USER"; 
     2698        case AR_STAT_HISTORY_TIME: return "TIME"; 
     2699        } 
     2700        return EnumDefault; 
     2701} 
  • branches/work_311/core/AREnum.h

    r544 r571  
    9494        static const char* WeekDayName(int day); 
    9595        static const char* CurrencyPart(int currencyPartType); 
     96        static const char* StatHistoryTag(int usrOrTime); 
    9697}; 
  • branches/work_311/doc/DocTextReferences.cpp

    r568 r571  
    1717#include "stdafx.h" 
    1818#include "DocTextReferences.h" 
     19#include "../core/ARParseField.h" 
     20#include "../output/ObjNotFound.h" 
    1921#include "../output/URLLink.h" 
    2022#include "../ARInside.h" 
     
    263265} 
    264266 
     267void CDocTextReferences::docField(std::ostream &strm, const ARParseField &parsedField) 
     268{ 
     269        int fieldId = 0; 
     270        switch (parsedField.tag) 
     271        { 
     272        case AR_FIELD: 
     273        case AR_STAT_HISTORY: 
     274                fieldId = parsedField.u.fieldId; 
     275                break; 
     276        case AR_CURRENCY_FLD: 
     277                fieldId = parsedField.u.currencyField->fieldId; 
     278                break; 
     279        } 
     280 
     281        strm << refFieldID(fieldId); 
     282 
     283        if (parsedField.tag == AR_STAT_HISTORY) 
     284        { 
     285                // handle status history 
     286                int enumId = parsedField.u.statHistory.enumVal; 
     287                string enumValue = pInside->GetFieldEnumValue(schemaInsideId, 7, enumId); 
     288 
     289                strm << "."; 
     290                if (enumValue.empty()) 
     291                        strm << enumId; 
     292                else 
     293                        strm << enumValue; 
     294 
     295                strm << "."; 
     296                strm << CAREnum::StatHistoryTag(parsedField.u.statHistory.userOrTime); 
     297        } 
     298        else if (parsedField.tag == AR_CURRENCY_FLD) 
     299        { 
     300                // handle currency details 
     301                strm << "."; 
     302                strm << CAREnum::CurrencyPart(parsedField.u.currencyField->partTag); 
     303                strm << "."; 
     304                strm << parsedField.u.currencyField->currencyCode; 
     305        } 
     306} 
     307 
    265308void CDocTextReferences::replaceAllFields() 
    266309{ 
     
    269312        string::size_type startPos = 0; 
    270313        string::size_type maxLen = inText.length(); 
    271         string::size_type fieldIdPos = 0; 
    272  
    273         char fieldId[20]; 
    274         char *enumId;    // points to the enum part of status history within fieldId later 
    275         char *usrOrTime; // points to the "user or time" part of status history within fieldId later 
    276314 
    277315        while ((startPos = inText.find(fieldSeparator.at(0),curPos)) != std::string::npos) 
    278316        { 
    279317                ++startPos; 
    280                 strmTmp << inText.substr(curPos,startPos - curPos); 
     318                strmTmp << inText.substr(curPos, startPos - curPos); 
    281319                curPos = startPos; 
    282320 
    283                 // reset 
    284                 fieldIdPos = 0;  
    285                 fieldId[0] = 0; 
    286                 enumId = NULL; 
    287                 usrOrTime = NULL; 
    288  
    289                 for (curPos = startPos; curPos < maxLen; ++curPos) 
    290                 { 
    291                         char currChar = inText.at(curPos); 
    292                         if (currChar == '-' && fieldIdPos != 0)   
    293                                 break; // - is only allowed at the beginning 
    294                         if (currChar >= '0' && currChar <= '9' || currChar == '-' || currChar == '.') 
     321                string::size_type endPos = inText.find(fieldSeparator.at(0), startPos); 
     322 
     323                if (endPos != string::npos) 
     324                { 
     325                        CARParseField fieldParser(inText.substr(startPos, endPos - startPos)); 
     326                        const ARParseField& parsedField = fieldParser.getField(); 
     327 
     328                        if (parsedField.tag != 0) 
    295329                        { 
    296                                 if (fieldIdPos + 1 == 20) 
    297                                         break;  // max length .. that cant be a field 
    298  
    299                                 if (currChar != '.' && fieldIdPos > 1 && fieldId[fieldIdPos-1] == '.') 
    300                                 { 
    301                                         fieldId[fieldIdPos-1] = 0; 
    302                                         if (enumId == NULL) 
    303                                                 enumId = &fieldId[fieldIdPos]; 
    304                                         else if (usrOrTime == NULL) 
    305                                                 usrOrTime = &fieldId[fieldIdPos]; 
    306                                         else 
    307                                                 break; // uhh ohh 
    308                                 } 
    309                                 // copy it over 
    310                                 fieldId[fieldIdPos++] = currChar; 
    311                                 continue; 
     330                                // now create documentation/link for the parsed field 
     331                                docField(strmTmp, parsedField); 
     332 
     333                                // write the end-separator to the output and skip it for next parsing 
     334                                strmTmp << inText.substr(endPos, 1); 
     335                                endPos++; 
    312336                        } 
    313                         if (currChar == fieldSeparator.at(0)) 
     337                        else 
    314338                        { 
    315                                 // end found 
    316                                 fieldId[fieldIdPos] = 0; 
    317  
    318                                 if (fieldId[0] == 0) 
    319                                         break;  // two $$ .. someone must be dreaming about more money 
    320  
    321                                 int iFieldId = atoi(fieldId); 
    322                                 if (iFieldId > 0) 
    323                                 { 
    324                                         CARField field(schemaInsideId, iFieldId); 
    325  
    326                                         if (!field.Exists()) 
    327                                         { 
    328                                                 strmTmp << fieldId << "$"; 
    329                                                 ++curPos; // skip the $ so it isnt found again 
    330                                                 break; 
    331                                         } 
    332  
    333                                         // now link to the field 
    334                                         strmTmp << URLLink(field, rootLevel); 
    335                                         if (refItem != NULL) 
    336                                                 pInside->AddFieldReference(schemaInsideId, iFieldId, *refItem); 
    337  
    338                                         // special handling for status history 
    339                                         if (iFieldId == 15) 
    340                                         { 
    341                                                 if (enumId == NULL || usrOrTime == NULL) break; 
    342  
    343                                                 // resolve user or time attribute 
    344                                                 int iUsrOrTime = atoi(usrOrTime); 
    345                                                 const char* usrOrTimeStr = usrOrTime; 
    346                                                 switch (iUsrOrTime) 
    347                                                 { 
    348                                                 case AR_STAT_HISTORY_USER: 
    349                                                         usrOrTimeStr = "USER"; 
    350                                                         break; 
    351                                                 case AR_STAT_HISTORY_TIME: 
    352                                                         usrOrTimeStr = "TIME"; 
    353                                                         break; 
    354                                                 } 
    355  
    356                                                 // handle status history 
    357                                                 CARField fieldStatus(schemaInsideId,7); // get status field 
    358                                                 string enumValue; 
    359                                                 if (fieldStatus.Exists()) 
    360                                                 { 
    361                                                         int iEnumId = atoi(enumId); 
    362                                                         enumValue = pInside->GetFieldEnumValue(schemaInsideId, fieldStatus.GetInsideId(), iEnumId); 
    363                                                 } 
    364  
    365                                                 strmTmp << "."; 
    366                                                 if (enumValue.empty()) 
    367                                                         strmTmp << enumId; 
    368                                                 else 
    369                                                         strmTmp << enumValue; 
    370                                                 strmTmp << "." << usrOrTimeStr; 
    371                                         } 
    372                                         strmTmp << "$"; 
    373                                         ++curPos; // skip the $ so it isnt found again 
    374                                 } 
    375                                 else if (fieldId[0] == '-' && iFieldId <= 0) 
    376                                 { 
    377                                         // keyword handling 
    378                                         int iKeyword = abs(iFieldId); 
    379                                         strmTmp << CAREnum::Keyword(iKeyword) << "$"; 
    380                                         ++curPos; // skip the $ so it isnt found again 
    381                                 } 
    382                                 break; 
     339                                strmTmp << inText.substr(curPos, endPos - curPos); 
    383340                        } 
    384                         break; 
    385                 } 
    386                 if (curPos < startPos) 
    387                         strmTmp << inText.substr(curPos,startPos - curPos); 
     341 
     342                        curPos = endPos; 
     343                } 
    388344        } 
    389345        if (curPos < maxLen) 
    390                 strmTmp << inText.substr(curPos,maxLen - curPos); 
     346                strmTmp << inText.substr(curPos); 
    391347 
    392348        inText = strmTmp.str(); 
  • branches/work_311/doc/DocTextReferences.h

    r568 r571  
    1919class CARInside; 
    2020class CRefItem; 
     21struct ARParseField; 
    2122 
    2223class CDocTextReferences 
     
    4849        void replaceAllFields(); 
    4950 
     51        void docField(std::ostream &strm, const ARParseField& parsedField); 
     52 
    5053protected: /* this is protected to overwrite methods in subclasses for testing support */ 
    5154        virtual string refFieldID(int iFieldID); 
  • branches/work_311/doc/DocTextReferencesTest.cpp

    r567 r571  
    66        CDocTextReferencesTest textRef("select * from $8$", "$", 1, 1, true, NULL); 
    77        string result = textRef.TextFindFields(); 
    8         ASSERT_EQ("select * from <a href='Test'>8</a>", result.c_str()); 
     8        ASSERT_STREQ("select * from $<a href='Test'>8</a>$", result.c_str()); 
    99} 
     10 
     11TEST(DocTextReferencesTests, InvalidFieldFormat) 
     12{ 
     13        CDocTextReferencesTest textRef("select * from $8.35.19$", "$", 1, 1, true, NULL); 
     14        string result = textRef.TextFindFields(); 
     15        ASSERT_STREQ("select * from $8.35.19$", result.c_str()); 
     16} 
  • branches/work_311/doc/DocTextReferencesTest.h

    r567 r571  
    1010 
    1111protected: 
    12         virtual string refFieldId(int iFieldId)  
     12        virtual string refFieldID(int iFieldId)  
    1313        {  
    1414                stringstream tmp;        
Note: See TracChangeset for help on using the changeset viewer.