void SearchTreeBrowser::printStringPairsToStringBuffer(std::vector<std::string>& vStringBuffer,
const std::string& sDataGroup, const BaseData::StringPairVector& vStringPairs) const
{
while (vStringBuffer.size() < vStringPairs.size() + 2) {
std::string stringBuffer;
if (vStringBuffer.size() != 0) {
std::string sLastLine = vStringBuffer.back();
if (sLastLine.length() != 0) {
std::string sFilledWhiteSpace;
sFilledWhiteSpace.append(sLastLine.length(), ' ');
stringBuffer += sFilledWhiteSpace;
}
}
vStringBuffer.push_back(stringBuffer);
}
assert(vStringBuffer.size() >= 2);
std::pair<int, int> maxLength = getMaxLengthOfStringPairs(vStringPairs);
int iTotalLength = maxLength.first + maxLength.second;
vStringBuffer[0] += "+-- " + sDataGroup + " data -";
vStringBuffer[0] += fillString(std::string(), iTotalLength - sDataGroup.length() - 5, "-")
+ "+ ";
for (BaseData::StringPairVector::const_iterator cit = vStringPairs.begin();
cit != vStringPairs.end(); ++cit) {
int iStringBufferIndex = cit - vStringPairs.begin() + 1;
std::string sProperty = cit->first;
if (sProperty.length() < maxLength.first)
sProperty.append(maxLength.first - sProperty.length(), ' ');
std::string sValue = cit->second;
if (sValue.length() < maxLength.second)
sValue.append(maxLength.second - sValue.length(), ' ');
vStringBuffer[iStringBufferIndex] += "| " + sProperty + " | " + sValue + " | ";
}
vStringBuffer[vStringPairs.size() + 1] += "+-" + fillString(std::string(), iTotalLength + 3, "-")
+ "-+ ";
}
int FRModel::fiscalization(QString registrationNumber, QString INN, QString newPassword, QString password)
{
fillString(password, getPasswordLength(password));
fillString(newPassword, getPasswordLength(password));
fillString(registrationNumber, getRegistrationNumberLength());
fillString(INN, getINNNumberLength());
int result = hw->hw()->ECR_SetMode(0);
if (result == 0 || result == 157)
{
result = hw->hw()->ECR_SetMode(5, codec->fromUnicode(password));
if (!result)
result = hw->hw()->ECR_Fiscalization(codec->fromUnicode(registrationNumber), codec->fromUnicode(INN), codec->fromUnicode(newPassword));
}
result = err->analizeError(result, "fiscalization");
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = fiscalization(registrationNumber, INN, newPassword, password);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка фискализации."), result));
}
return result;
}
/**
* @brief writeRegister Method to append a whole registry. Add new element to database.
* @param pFileName is the name of database file to add to.
* @param pColumnData it's what to append.
* @param columnPos is where to append it.
*/
bool writefile::writeRegister(string pFileName, array<char*>* pColumnData ,
array<char*>* pColumnNam){
int currSeek = file.tellg();
string standardDir = createNewFile(pFileName);
file.open(standardDir.c_str());
bool isOpen = true;
if(!file.is_open()){
cout << "NED " + pFileName << endl;
return false;
}
file.seekg(K->ZE_ROW);
int spacesToMove;
int Csize;
int lon = pColumnNam->getLenght();
array<char*> tempCDataArr = *pColumnData;
array<char*> tempNames = *pColumnNam;
array<int> ColumnPos (lon);
string registerToWrite = K->EMPTY_STRING;
string Cdata;
const char* charT ;
for (int i = K->ZE_ROW ; i < lon ; i++){
charT = tempNames[i];
string strToAdd(charT);
ColumnPos[i] = getColumnNumber(&pFileName, &strToAdd);
}
//Get the register and fill the blanks.
fillString (®isterToWrite , getRegisterSize());
for (int i = 0 ; i < ColumnPos.getLenght() ; i++){
Cdata = tempCDataArr[i];
checkString(&Cdata);
Csize = columnSize(ColumnPos[i]);
//Not sure
spacesToMove = sizeUntilColumn(ColumnPos[i]);
fillString(&Cdata ,Csize);
registerToWrite.replace(spacesToMove , Csize , Cdata.c_str());
}
if (file.is_open()){
file.seekg(K->ZE_ROW , ios::end);
file << registerToWrite;
}
file.seekg(currSeek);
file.close();
return isOpen;
}
/**
* @brief updateField changes the value of a given field on the whole database.
* @param newData new information to be inserted.
* @param pFile the database to be used
* @param pRow
* @param pColumn
*/
bool writefile::updateField(string newData, string pFile , int pRow , int pColumn){
int currSeek = file.tellg();
int sizeToColumn;
int cSize;
bool bowl = true;
//Relative route + the name of the file
if ( !(file.is_open()) ){
string fileH = pFile;
string standardDir = createNewFile(fileH.c_str());
file.open(standardDir.c_str());
}
if ( !(file.is_open()) ){
cout << "NED " + pFile << endl;
bowl = false;
}
placeSeekOn(&pRow , &pColumn, &sizeToColumn, &cSize);
fillString(&newData,cSize);
if (file.is_open()){
file << newData;
}
file.seekg(currSeek);
if (file.is_open()){
file.close();
}
return bowl;
}
int FRModel::setSerialNumber(const QString &number, QString password)
{
fillString(password, getPasswordLength(password));
int result = hw->hw()->ECR_SetMode(0);
if (result == 0 || result == 157)
{
result = hw->hw()->ECR_SetMode(5, codec->fromUnicode(password));
if (!result)
result = hw->hw()->ECR_SetSerialNumber(codec->fromUnicode(number));
}
result = err->analizeError(result);
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = setSerialNumber(number, password);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка установки серийного номера."), result));
}
return result;
}
int FRModel::makeFullReport(int sessionBegin, int sessionEnd, QString password)
{
fillString(password, getPasswordLength(password));
int result = hw->hw()->ECR_SetMode(0);
if (result == 0 || result == 157)
{
result = hw->hw()->ECR_SetMode(5, codec->fromUnicode(password));
if (!result)
result = hw->hw()->ECR_Report(FULL_REPORT_BY_SESSION, 0, 0, 0, 0, 0, 0, sessionBegin, sessionEnd);
}
result = err->analizeError(result);
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = makeFullReport(sessionBegin, sessionEnd, password);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка снятия полного отчета по сменам."), result));
}
return result;
}
int FRModel::makeBriefReport(int dayBegin, int monthBegin, int yearBegin, int dayEnd, int monthEnd, int yearEnd, QString password)
{
fillString(password, getPasswordLength(password));
int result = hw->hw()->ECR_SetMode(0);
if (result == 0 || result == 157)
{
result = hw->hw()->ECR_SetMode(5, codec->fromUnicode(password));
if (!result)
result = hw->hw()->ECR_Report(BRIEF_REPORT_BY_DATE, dayBegin, monthBegin, yearBegin, dayEnd, monthEnd, yearEnd);
}
result = err->analizeError(result);
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = makeBriefReport(dayBegin, monthBegin, yearBegin, dayEnd, monthEnd, yearEnd, password);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка снятия краткого отчета по датам."), result));
}
return result;
}
void fillPktStart(circular* buf,int type) {
fillString(buf,"$PKWN");
fill(buf,headerNMEASIRF[type*2]);
//Reset all formatting parameters so that
//it doesn't matter what the last packet was
buf->dataDigits=0;
buf->dataDec=1;
buf->dataAsciiz=0;
buf->dataComma=1;
}
string
StringConverter::leftTrim(string _string,unsigned int stringSize)
{
// stringSize is the desired string size after the function call
// if the cutChars value is bigger then the size length
// the return value will be an empty string
if (stringSize>_string.size())
{
string fillString(stringSize-_string.size(),'0');
return (fillString + _string);
}
_string.substr(_string.size()-stringSize,stringSize);
return _string;
}
void fillPktStart(circular* buf,int type) {
switch(writeMode) {
case PKT_NMEA:
fillString(buf,"$PKWN");
fill(buf,headerNMEASIRF[type*2]);
break;
case PKT_SIRF:
fillStartSirf(buf, headerNMEASIRF[type*2+1]);
break;
}
//Reset all formatting parameters so that
//it doesn't matter what the last packet was
buf->dataDigits=0;
buf->dataDec=1;
buf->dataAsciiz=0;
buf->dataComma=1;
}
bool writefile::deleteRegister(string pFile, string pCName, string newData){
int currSeek = file.tellg();
int Column;
int cSize;
string standardDir;
bool bowl = true;
//Relative route + the name of the file
if ( !(file.is_open()) ){
standardDir = createNewFile(pFile.c_str());
file.open(standardDir.c_str());
}
if ( !(file.is_open()) ){
cout << "NED " + pFile << endl;
return false;
}
Column = getColumnNumber(&standardDir , &pCName );
cSize = getRegisterSize();
int regQty = getRegisterQuantity();
string voidField = K->EMPTY_STRING;
int sizeToColumn = sizeUntilColumn(Column);
fillString(&voidField,cSize);
cout << voidField.length() <<endl;
for (int rowCounter = K->ONE_BYTE ; rowCounter <= regQty ; rowCounter++){
//Compare data.
if (readField(pFile , rowCounter , Column) == newData){
placeSeekOn(&rowCounter , &Column, &sizeToColumn, &cSize);
if (file.is_open()){
file << voidField;
} else {
bowl = false;
}
}
}
file.seekg(currSeek);
if (file.is_open()){
file.close();
}
return bowl;
}
/**
* The actual installation of the content handler
* @return <code>JSR211_OK</code> if the installation completes successfully.
*/
static jsr211_result installHandler(int n) {
JSR211_content_handler ch = JSR211_CONTENT_HANDLER_INITIALIZER;
char *ptr = rowHandlers[n];
jsr211_result status = JSR211_FAILED;
int anm_num; // buffer for actionname map length
/*
* Fill up CH data:
* ID from handlerIds.
* Others from rowHandlers:
* <suite_ID> -- if this line is empty, the handler's flag is NATIVE
* <classname> -- if the handler's flag is NATIVE here is executive path
* <type1 type2 type3 ...> -- array of types devided by whitespases
* <suffix1 suffix2 suffix3 ...> -- suffixes (see types)
* <locale1 locale2 locale3 ...> -- locales (see types)
* <actionName11 actionName21 ...> -- action_name_i_j is for
* action_i and locale_j
* <access1 access2 access3 ...> -- accesses (see types)
*/
if (PCSL_STRING_OK == pcsl_string_dup(handlerIds[n], &(ch.id)) &&
fillString(&ptr, &ch.class_name) &&
fillArray(&ptr, &ch.type_num, &ch.types) &&
fillArray(&ptr, &ch.suff_num, &ch.suffixes) &&
fillArray(&ptr, &ch.act_num, &ch.actions) &&
fillArray(&ptr, &ch.locale_num, &ch.locales) &&
fillArray(&ptr, &anm_num, &ch.action_map) &&
fillArray(&ptr, &ch.access_num, &ch.accesses) &&
anm_num == (ch.act_num * ch.locale_num)) {
ch.suite_id = INTERNAL_SUITE_ID;
ch.flag = JSR211_FLAG_COMMON;
status = jsr211_register_handler(&ch);
#if REPORT_LEVEL <= LOG_CRITICAL
} else {
REPORT_CRIT(LC_NONE, "jsr211_deploy.c: handler data parsing failed");
#endif
}
// clean up handler's memory
jsr211_cleanHandlerData(&ch);
return status;
}
void PaloHttpRequest::setKeyValue(char * keyStart, char * keyPtr, char * valueStart, char * valuePtr)
{
const struct CommandOption * option = Perfect_Hash::PaloValue(keyStart, (unsigned int)(keyPtr - keyStart));
if (Server::flightRecorderEnabled()) {
httpParams.seekg(0, ios::end);
std::streamoff size = httpParams.tellg();
httpParams.seekg(0, ios::beg);
if (size == 0) {
httpParams << "?";
} else {
httpParams << "&";
}
httpParams.write(keyStart, keyPtr - keyStart);
httpParams << '=';
if (option != 0 && option->code == PaloRequestHandler::CMD_SID) {
httpParams << PaloSession::shortenSid(string(valueStart, valuePtr));
} else if (valuePtr - valueStart > 1000000) {
httpParams.write(valueStart, 1000000);
httpParams << "...(argument total " << valuePtr-valueStart << " bytes)";
} else {
httpParams.write(valueStart, valuePtr - valueStart);
}
}
if (option != 0) {
switch (option->code) {
case PaloRequestHandler::CMD_SID:
fillSid(paloJobRequest->sid, valueStart, valuePtr);
paloJobRequest->hasSession = true;
break;
case PaloRequestHandler::CMD_ID_CUBE:
fillIdentifier(paloJobRequest->cube, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_DATABASE:
fillIdentifier(paloJobRequest->database, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_DIMENSION:
fillIdentifier(paloJobRequest->dimension, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_ELEMENT:
fillIdentifier(paloJobRequest->element, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_LIMIT: {
IdentifiersType *limitValues = 0;
fillVectorIdentifier(limitValues, valueStart, valuePtr);
if (!limitValues) {
break;
}
if (limitValues->size() > 1) {
paloJobRequest->limitCount = (*limitValues)[1];
}
if (limitValues->size()) {
paloJobRequest->limitStart = (*limitValues)[0];
}
delete limitValues;
}
break;
case PaloRequestHandler::CMD_ID_LOCK:
fillIdentifier(paloJobRequest->lock, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_LOCKED_PATHS:
fillIdentifier(paloJobRequest->lock, valueStart, valuePtr);
fillVectorVectorIdentifier(paloJobRequest->lockedPaths, valueStart, valuePtr, ':', ',');
break;
case PaloRequestHandler::CMD_ID_RULE:
fillVectorIdentifier(paloJobRequest->rules, valueStart, valuePtr);
if (paloJobRequest->rules && paloJobRequest->rules->size()) {
paloJobRequest->rule = paloJobRequest->rules->at(0);
}
break;
case PaloRequestHandler::CMD_ACTIVATE:
fillUint(paloJobRequest->activate, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ADD:
fillBoolean(paloJobRequest->add, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_BASE_ONLY:
fillBoolean(paloJobRequest->baseOnly, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_COMPLETE:
fillBoolean(paloJobRequest->complete, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_EVENT_PROCESSOR:
fillBoolean(paloJobRequest->eventProcess, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SHOW_ATTRIBUTE:
fillBoolean(paloJobRequest->showAttribute, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SHOW_INFO:
fillBoolean(paloJobRequest->showInfo, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SHOW_GPUTYPE:
fillBoolean(paloJobRequest->showGputype, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SHOW_LOCK_INFO:
fillBoolean(paloJobRequest->showLockInfo, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SHOW_NORMAL:
fillBoolean(paloJobRequest->showNormal, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SHOW_RULE:
fillBoolean(paloJobRequest->showRule, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SHOW_SYSTEM:
fillBoolean(paloJobRequest->showSystem, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SHOW_USER_INFO:
fillBoolean(paloJobRequest->showUserInfo, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SKIP_EMPTY:
fillBoolean(paloJobRequest->skipEmpty, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_USE_IDENTIFIER:
fillBoolean(paloJobRequest->useIdentifier, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_USE_RULES:
fillBoolean(paloJobRequest->useRules, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ACTION:
fillString(paloJobRequest->action, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_COMMENT:
fillString(paloJobRequest->comment, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_CONDITION:
fillString(paloJobRequest->condition, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_NAME_CUBE:
fillString(paloJobRequest->cubeName, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_NAME_DATABASE:
fillString(paloJobRequest->databaseName, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_DEFINITION:
fillString(paloJobRequest->definition, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_NAME_DIMENSION:
fillString(paloJobRequest->dimensionName, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_NAME_ELEMENT:
fillString(paloJobRequest->elementName, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_EVENT:
fillString(paloJobRequest->event, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_EXTERN_PASSWORD:
fillString(paloJobRequest->externPassword, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_EXTERNAL_IDENTIFIER:
fillString(paloJobRequest->externalIdentifier, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_FUNCTIONS:
fillString(paloJobRequest->functions, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_NEW_NAME:
fillString(paloJobRequest->newName, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_PASSWORD:
fillString(paloJobRequest->password, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SOURCE:
fillString(paloJobRequest->source, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_NAME_USER:
fillString(paloJobRequest->user, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_VALUE:
fillString(paloJobRequest->value, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_BLOCKSIZE:
fillUint(paloJobRequest->blockSize, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_MODE:
fillUint(paloJobRequest->mode, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_POSITION:
fillUint(paloJobRequest->position, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_PROPERTIES:
fillVectorIdentifier(paloJobRequest->properties, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_SPLASH:
fillUint(paloJobRequest->splash, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_NUM_STEPS:
fillUint(paloJobRequest->steps, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_TYPE:
fillUint(paloJobRequest->type, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_TYPES:
fillVectorUint(paloJobRequest->types, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_DIMENSIONS:
fillVectorIdentifier(paloJobRequest->dimensions, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_PARENT:
if (valueStart == valuePtr) {
// empty parameter -> no parent specified - root
paloJobRequest->parent = NO_IDENTIFIER;
} else {
fillIdentifier(paloJobRequest->parent, valueStart, valuePtr);
}
break;
case PaloRequestHandler::CMD_ID_PATH:
fillVectorIdentifier(paloJobRequest->path, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_PATH_TO:
fillVectorIdentifier(paloJobRequest->pathTo, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ID_ELEMENTS:
fillVectorIdentifier(paloJobRequest->elements, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_WEIGHTS:
fillVectorVectorDouble(paloJobRequest->weights, valueStart, valuePtr, ':', ',');
break;
case PaloRequestHandler::CMD_NAME_DIMENSIONS:
fillVectorString(paloJobRequest->dimensionsName, valueStart, valuePtr, ',');
break;
case PaloRequestHandler::CMD_NAME_ELEMENTS:
fillVectorStringQuote(paloJobRequest->elementsName, valueStart, valuePtr, ',');
break;
case PaloRequestHandler::CMD_NAME_PATH:
fillVectorString(paloJobRequest->pathName, valueStart, valuePtr, ',');
break;
case PaloRequestHandler::CMD_NAME_PATH_TO:
fillVectorString(paloJobRequest->pathToName, valueStart, valuePtr, ',');
break;
case PaloRequestHandler::CMD_VALUES:
fillVectorStringQuote(paloJobRequest->values, valueStart, valuePtr, ':');
break;
case PaloRequestHandler::CMD_ID_AREA:
fillVectorVectorIdentifier(paloJobRequest->area, valueStart, valuePtr, ',', ':');
break;
case PaloRequestHandler::CMD_ID_CHILDREN:
fillVectorVectorIdentifier(paloJobRequest->children, valueStart, valuePtr, ':', ',');
break;
case PaloRequestHandler::CMD_ID_PATHS:
fillVectorVectorIdentifier(paloJobRequest->paths, valueStart, valuePtr, ':', ',');
break;
case PaloRequestHandler::CMD_NAME_AREA:
fillVectorVectorString(paloJobRequest->areaName, valueStart, valuePtr, ',', ':');
break;
case PaloRequestHandler::CMD_NAME_CHILDREN:
fillVectorVectorStringQuote(paloJobRequest->childrenName, valueStart, valuePtr, ':', ',');
break;
case PaloRequestHandler::CMD_NAME_PATHS:
fillVectorVectorString(paloJobRequest->pathsName, valueStart, valuePtr, ':', ',');
break;
case PaloRequestHandler::CMD_FUNCTION:
fillUint(paloJobRequest->function, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_EXPAND:
fillVectorUint(paloJobRequest->expand, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_ACTCODE:
fillString(paloJobRequest->actcode, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_LICKEY:
fillString(paloJobRequest->lickey, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_MACHINE:
fillString(paloJobRequest->machineString, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_REQUIRED:
fillString(paloJobRequest->requiredFeatures, valueStart, valuePtr);
break;
case PaloRequestHandler::CMD_OPTIONAL:
fillString(paloJobRequest->optionalFeatures, valueStart, valuePtr);
break;
}
}
}
void SearchTreeBrowser::printComment(std::ostream& os, NodePtr pNode, bool bExtend, bool bHide) const
{
if (bHide) {
std::string sHint = "[Press <C> to toogle comments]";
os << " \033[1;36m" << sHint << "\033[0m" << std::endl;
return;
}
const int kPrintCommentWidth = JobLevelConfigure::g_configure.iPrintCommentWidth;
const int kPrintCommentLine = JobLevelConfigure::g_configure.iPrintCommentLine;
// print ┌── Comment ────────┐
std::string sHeadLine = "\033[1;37m+-- Comments ";
sHeadLine = fillString(sHeadLine, kPrintCommentWidth - 11, "-");
sHeadLine.append("-+");
os << sHeadLine << std::endl;
// print │ some comments... │
int iLineCounter = 0;
bool bStopPrinting = false;
std::string sHint;
std::istringstream iss(pNode->getComment());
std::string sLineOfComment;
while (bStopPrinting == false && getline(iss, sLineOfComment)) {
do {
std::string sLine = sLineOfComment.substr(0, kPrintCommentWidth);
int nFindReturnR = sLine.find('\r');
if (nFindReturnR != std::string::npos)
sLine.erase(nFindReturnR);
if (sLine.length() < kPrintCommentWidth)
sLine.append(kPrintCommentWidth - sLine.length(), ' ');
os << "| " << sLine << " |" << std::endl;
if (sLineOfComment.length() > kPrintCommentWidth)
sLineOfComment = sLineOfComment.substr(kPrintCommentWidth);
else
sLineOfComment.clear();
// increment line counter and check if need stop
iLineCounter++;
if (bExtend == false) {
if (iLineCounter == kPrintCommentLine) {
sHint = "[Press <E> to extend]";
sHint.append(kPrintCommentWidth - sHint.length(), ' ');
os << "| \033[1;34m" << sHint << "\033[1;37m |" << std::endl;
bStopPrinting = true;
break;
}
}
} while (sLineOfComment.length() != 0);
}
if (bExtend && iLineCounter > kPrintCommentLine) {
sHint = "[Press <E> to shrink]";
sHint.append(kPrintCommentWidth - sHint.length(), ' ');
os << "| \033[1;34m" << sHint << "\033[1;37m |" << std::endl;
}
// print └───────────────────┘
std::string sFootLine = "+-";
sFootLine = fillString(sFootLine, kPrintCommentWidth, "-");
sFootLine.append("-+\033[0m");
os << sFootLine << std::endl;
/* if (bStopPrinting) {
std::string sHint = "[Press <C> to show all comments]";
sHint.append(kPrintCommentWidth - sHint.length(), ' ');
os << " \033[1;36m" << sHint << "\033[0m" << std::endl;
} */
}
