Example #1
0
bool rspfLocalTm::setIso8601(const std::string& timeString, bool shiftToGmtOffsetZero)
{
   rspfDate now;
   std::string::size_type pos = 0;
   rspf_int32 year  = 0;
   rspf_int32 month = 0;
   rspf_int32 day   = 0;
   rspf_int32 timeZoneOffset = 0;
   
   if(timeString[0] != 'T') // make sure it's not time only
   {
      // look for year
      //
      if(readIntegerFromString(year,
                               timeString,
                               pos,
                               4))
      {
         // retrieved the year portion
         // now check for separator not digit
         //
         
         // we at least have a year
         // now check for others
         setYear(year);
         if(!isdigit(timeString[pos]))
         {
            // skip separator
            ++pos;
         }
         if(readIntegerFromString(month,
                                  timeString,
                                  pos,
                                  2))
         
         {
            setMonth(month);
            if(!isdigit(timeString[pos]))
            {
               // skip separator
               ++pos;
            }
            if(readIntegerFromString(day,
                                     timeString,
                                     pos,
                                     2))
            {
               setDay(day);
            }
         }
      }
      else
      {
         return false;
      }
   }
   else // set year month day to current
   {
      setYear(now.getYear());
      setMonth(now.getMonth());
      setDay(now.getDay());
   }
   // check to see if we need to read time portion
   if(timeString[pos] == 'T')
   {
      ++pos; // skip T character
      rspf_int32 hours=0, minutes=0;
      
      if(readIntegerFromString(hours,
                               timeString,
                               pos,
                               2))
      {
         setHour(hours);
         
         // now check for separator
         if(!std::isdigit(timeString[pos]))
         {
            ++pos; // skip separator if present
         }
         if(readIntegerFromString(minutes,
                                  timeString,
                                  pos,
                                  2))
         {
            setMin(minutes);
            // now check for time zone if only a hour minute time
            //
            if(timeString[pos] == 'Z')
            {
               // no adjustment needed
            }
            else if(!readTimeZoneOffset(timeZoneOffset,
                                       timeString,
                                       pos))
            {
               double fractionalSeconds = 0.0;
               if(!std::isdigit(timeString[pos]))
               {
                  ++pos;
               }
               std::string::size_type endPos = timeString.find_first_not_of("0123456789.", pos);
               if(endPos == std::string::npos)
               {
                  fractionalSeconds = rspfString(timeString.begin()+pos,
                                                  timeString.end()).toDouble();
               }
               else
               {
                  fractionalSeconds = rspfString(timeString.begin()+pos,
                                                  timeString.begin()+endPos).toDouble();
               }
               setFloatSec(fractionalSeconds);
               pos = endPos;
               if(pos == std::string::npos)
               {
                  // we will not be too strict so if at the end then just return we got enough
                  return true;
               }
               if(timeString[pos] == 'Z')
               {
                  // no adjustment needed
               }
               else
               {
                  readTimeZoneOffset(timeZoneOffset,
                                          timeString,
                                     pos);
               }
            }
         }
      }
      else
      {
         // need at least hours 
         return false;
      }
   }
   else if(std::isdigit(timeString[pos]))
   {
      rspf_int32 hours=0, minutes=0;
      
      if(readIntegerFromString(hours,
                               timeString,
                               pos,
                               2))
      {
         setHour(hours);
         
         // now check for separator
         if(!std::isdigit(timeString[pos]))
         {
            ++pos; // skip separator if present
         }
         if(readIntegerFromString(minutes,
                                  timeString,
                                  pos,
                                  2))
         {
            setMin(minutes);
            
            if(!readTimeZoneOffset(timeZoneOffset,
                                  timeString,
                                  pos))
            {
               double fractionalSeconds = 0.0;
               if(!std::isdigit(timeString[pos]))
               {
                  ++pos;
               }
               std::string::size_type endPos = timeString.find_first_not_of("0123456789.", pos);
               if(endPos == std::string::npos)
               {
                  fractionalSeconds = rspfString(timeString.begin()+pos,
                                                  timeString.end()).toDouble();
               }
               else
               {
                  fractionalSeconds = rspfString(timeString.begin()+pos,
                                                  timeString.begin()+endPos).toDouble();
               }
               setFloatSec(fractionalSeconds);
               pos = endPos;
               if(pos == std::string::npos)
               {
                  // we will not be too strict so if at the end then just return we got enough
                  return true;
               }
               if(timeString[pos] == 'Z')
               {
                  // no adjustment needed
               }
               else
               {
                  readTimeZoneOffset(timeZoneOffset,
                                     timeString,
                                     pos);
               }
            }
         }
      }  
   }
   else
   {
      // need at least hours 
      return false;
   }
   
   if(shiftToGmtOffsetZero && (timeZoneOffset!=0))
   {
      addSeconds(-timeZoneOffset);
   }
   return true;
}
Example #2
0
bool is_comment(const std::string &line){
	auto first = line.find_first_not_of(" \t");
	return line[first] == ';';
}
Example #3
0
static void trimQuotes(std::string &s)
{
    s.erase(0, s.find_first_not_of(' '));
    s.erase(s.find_last_not_of(' ')+1);
}
Example #4
0
long Skini :: parseString( std::string& line, Message& message )
{
  message.type = 0;
  if ( line.empty() ) return message.type;

  // Check for comment lines.
  std::string::size_type lastPos = line.find_first_not_of(" ,\t", 0);
  std::string::size_type pos     = line.find_first_of("/", lastPos);
  if ( std::string::npos != pos ) {
    oStream_ << "// Comment Line: " << line;
    handleError( StkError::STATUS );
    return message.type;
  }

  // Tokenize the string.
  std::vector<std::string> tokens; 
  this->tokenize( line, tokens, " ,\t");

  // Valid SKINI messages must have at least three fields (type, time,
  // and channel).
  if ( tokens.size() < 3 ) return message.type;

  // Determine message type.
  int iSkini = 0;
  while ( iSkini < __SK_MaxMsgTypes_ ) {
    if ( tokens[0] == skini_msgs[iSkini].messageString ) break;
    iSkini++;
  }

  if ( iSkini >= __SK_MaxMsgTypes_ )  {
    oStream_ << "Skini::parseString: couldn't parse this line:\n   " << line;
    handleError( StkError::WARNING );
    return message.type;
  }
  
  // Found the type.
  message.type = skini_msgs[iSkini].type;

  // Parse time field.
  if ( tokens[1][0] == '=' ) {
    tokens[1].erase( tokens[1].begin() );
    if ( tokens[1].empty() ) {
      oStream_ << "Skini::parseString: couldn't parse time field in line:\n   " << line;
      handleError( StkError::WARNING );
      return message.type = 0;
    }
    message.time = (StkFloat) -atof( tokens[1].c_str() );
  }
  else
    message.time = (StkFloat) atof( tokens[1].c_str() );

  // Parse the channel field.
  message.channel = atoi( tokens[2].c_str() );

  // Parse the remaining fields (maximum of 2 more).
  int iValue = 0;
  long dataType = skini_msgs[iSkini].data2;
  while ( dataType != NOPE ) {

    if ( tokens.size() <= (unsigned int) (iValue+3) ) {
      oStream_ <<  "Skini::parseString: inconsistency between type table and parsed line:\n   " << line;
      handleError( StkError::WARNING );
      return message.type = 0;
    }

    switch ( dataType ) {

    case SK_INT:
      message.intValues[iValue] = atoi( tokens[iValue+3].c_str() );
      message.floatValues[iValue] = (StkFloat) message.intValues[iValue];
      break;

    case SK_DBL:
      message.floatValues[iValue] = atof( tokens[iValue+3].c_str() );
      message.intValues[iValue] = (long) message.floatValues[iValue];
      break;

    case SK_STR: // Must be the last field.
      message.remainder = tokens[iValue+3];
      return message.type;

    default: // MIDI extension message
      message.intValues[iValue] = dataType;
      message.floatValues[iValue] = (StkFloat) message.intValues[iValue];
      iValue--;
    }

    if ( ++iValue == 1 )
      dataType = skini_msgs[iSkini].data3;
    else
      dataType = NOPE;
  }

  return message.type;
}
Example #5
0
std::string trimLeft (const std::string& in, const std::string& t /*= " "*/)
{
  std::string out = in;
  return out.erase (0, in.find_first_not_of (t));
}
Example #6
0
void ossim::lexQuotedTokens(const std::string& str,
                            ossim_uint32 start,
                            const char* whitespace,
                            const char* quotes,
                            std::vector<std::string>& tokens,
                            bool& unbalancedQuotes)
{
   ossimREQUIRE(whitespace != NULL);
   ossimREQUIRE(quotes != NULL);
   ossimREQUIRE(tokens != NULL);
   
   const char openQuote(quotes[0]), closeQuote(quotes[1]);
   
   tokens.clear();
   unbalancedQuotes = false;
   
   int end=0;
   while (start < str.length())
   {
      if (str[start] == openQuote)
      {
         int openBraceCount = 1;
         
         if (start+1 < str.length())
         {
            start++;
            if (str[start] != closeQuote)
            {
               //               end = start+1;
               end = start;
               while (static_cast<ossim_uint32>(end) < str.length() &&
                      openBraceCount > 0)
               {
                  if (str[end] == openQuote)
                     openBraceCount++;
                  else if (str[end] == closeQuote)
                     openBraceCount--;
                  end++;
               }
            }
            else
            {
               openBraceCount = 0;
               start++;
               end = start+1;
            }
         }
         if (openBraceCount == 0)
         {
            tokens.push_back(str.substr(start, end-1-start));
         }
         else
         {
            unbalancedQuotes = true;
            end = (int)str.length();
         }
      }
      else if (str[start] == closeQuote)
      {
         unbalancedQuotes = true;
         end = (int)str.length();
	 
      }
      else
      {
         end = (int)str.find_first_of(whitespace, start);
         tokens.push_back(str.substr(start, end-start));
      }
      
      start = (ossim_uint32)str.find_first_not_of(whitespace, end);
   }
}
Example #7
0
std::string gTrim(const std::string &s)
{
	std::size_t first = s.find_first_not_of(" \n\t");	
	std::size_t last  = s.find_last_not_of(" \n\t");
	return s.substr(first, last-first+1);
}
Example #8
0
File: tools.cpp Project: Berze/sour
std::string trimString(std::string& str)
{
	str.erase(str.find_last_not_of(" ") + 1);
	return str.erase(0, str.find_first_not_of(" "));
}
Example #9
0
void SipperMediaPortable::trim_left(std::string &s, const std::string &t) 
{ 
  s.erase (0, s.find_first_not_of (t)) ; 
}  
std::string Instruction::extractType(const std::string args)
{
	size_t posFirst = args.find_first_not_of(" \t");
	size_t posLast = args.find_first_of(" \t(", posFirst);
	return args.substr(posFirst, posLast - posFirst);
}
Example #11
0
File: tools.cpp Project: Berze/sour
void trim_left(std::string& source, const std::string& t)
{
	source.erase(0, source.find_first_not_of(t));
}
/// <summary>
/// Determines if a given std::string only contains whitespace or is empty
/// </summary>
/// <param name="original_str">The original std::string</param>
/// <returns>True if the original_str only contains whitespace</returns>
bool StringFunctions::isOnlyWhitespace(const std::string &original_str)
{
	return original_str.find_first_not_of("\t\n\v\f\r ") == std::string::npos;
}
 static std::string TrimFromFront( std::string const& stringToTrim,
                                   std::string const& charsToTrim )
 { return
   stringToTrim.substr( stringToTrim.find_first_not_of( charsToTrim ),
                        std::string::npos ); }
Example #14
0
 std::string trimWS(std::string& s){
     std::string ws = " \t";
     s.erase(0, s.find_first_not_of(ws));
     s.erase(s.find_last_not_of(ws)+1);
     return s;
 }
Example #15
0
bool constant_exprt::value_is_zero_string() const
{
  const std::string val=id2string(get_value());
  return val.find_first_not_of('0')==std::string::npos;
}
Example #16
0
//Removes whitespace from the beginning of the line
void trimLeft(std::string& str)
{
	int start = str.find_first_not_of(whitespace);
	str.erase(0, start);
}
Example #17
0
std::string sunjwbase::strtrim_left(const std::string& s, const std::string& spaces)
{
	std::string d(s);
	return d.erase(0, s.find_first_not_of(spaces));
}  // end of trim_left
Example #18
0
/**
  * Check for valid address...
  */
bool valid_address (std::string addr)
{
	return addr.compare(0, 2, "0x") == 0
		&& addr.size() > 2
		&& addr.find_first_not_of("0123456789abcdefABCDEF", 2) == std::string::npos;
}
Example #19
0
   void PackedNavBits::rawBitInput(const std::string inString )
      throw(InvalidParameter)
   {
         // Debug
      //cout << " ENTERING rawBitInput( )-------------------------------------------------" << endl;
         //  Find first non-white space string.   
         //  Should translate as a decimal value.
         //  If so, assume this is the number of bits that follow, but do not 
         //  store it until success.
         //  For out purposes, treat space, tab, and comma as white space
         //  (the inclusion of comma allows CSV files to be read).
      string whiteSpace=" \t,";
      string::size_type begin = inString.find_first_not_of(whiteSpace);
      if (begin==string::npos)
      {
         InvalidParameter exc("Did not find #bits at beginning of input string.");
         GPSTK_THROW(exc);
      }
      string::size_type end = inString.find_first_of(whiteSpace,begin);
      if (end==string::npos)
      {
         InvalidParameter exc("Did not find space after #bits at beginning of input string.");
         GPSTK_THROW(exc);
      }
      string textBitCount = inString.substr(begin,end);
      int bitsExpected = StringUtils::asInt(textBitCount); 

         //  Find successive 32 bits quantities stored as hex strings.  
         //  That is to say, each should be of the format 0xAAAAAAAA
         //  There should be sufficient to cover the number of input 
         //  bits plus padding to the next even 32 bit word boundary.  
         //  That is to say, []# of 32 bits words] = ((inBits-1)/32) + 1;
      int numWordsExpected = (( bitsExpected-1)/32) + 1; 
      int bitsRead = 0;
         // debug
      //cout << "bitsExpected, numWordsExpected : " << bitsExpected << ", " << numWordsExpected << endl; 
      for (int i = 0; i<numWordsExpected; ++i)
      {
            // For each word, convert the string to a value, then add it
            // to the packed bit storage. 
         begin = inString.find_first_not_of(whiteSpace,end+1);
         if (begin==string::npos)
         {
            InvalidParameter exc("Did not find expected number of hex words.");
            GPSTK_THROW(exc);
         }
         end = inString.find_first_of(whiteSpace,begin);
         string::size_type length = end - begin; 
         string hexWord = inString.substr(begin,length);
            // Debug
         //   cout << "hexWord (string) : '" << hexWord << "'" << endl;
         if (hexWord.substr(0,2)!="0x" &&
             hexWord.substr(0,2)!="0X" )
         {
            InvalidParameter exc("Expected hex data did not being with '0x'");
            GPSTK_THROW(exc); 
         }
            
         unsigned long dataWord = StringUtils::x2uint(hexWord);

            // NOTE: Since the input is always in terms of complete left-
            // justified 32-bit words, the "numberBits" argument to 
            // addUnsignedLong() is always 32.  However, we need to keep
            // track of how many bits are actually being stored in the
            // PackedNavBits object.  The only word that is not 32-bits
            // "full" is the last word. 
         int numBitsToAdd = bitsExpected - bitsRead;
         if (numBitsToAdd>32) numBitsToAdd = 32;
             // Debug
         //    cout << " dataWord (dec) : " << dataWord << endl;
         //    cout << " numBitsToAdd : " << numBitsToAdd << endl;
         addUnsignedLong( dataWord, 32, 1); 

         bitsRead += numBitsToAdd; 

      }
      // Now trim the string and store the final size. 
      bits_used = bitsRead;
      trimsize();  

      return;
   }
Example #20
0
bool valid_size (std::string size)
{
	return size.find_first_not_of("0123456789") == std::string::npos;
}
std::string CallHprose::DownloadHprose( std::string strHproseDownloadUrl, std::string strFileDir, std::string strFileName )
{
	CInternetSession sess;
	CHttpFile* pHttpFile;
	try
	{
		pHttpFile=(CHttpFile*)sess.OpenURL(strHproseDownloadUrl.c_str());
	}
	catch(CException* e)
	{
		pHttpFile = 0;
		TCHAR msg[1024];
		memset(msg, 0, 1024);
		e->GetErrorMessage(msg, 1023, NULL);
		ZTools::WriteZToolsFormatLog("打开URL失败:%s", msg);
		return "";
	}

	DWORD dwStatus;
	DWORD dwBuffLen = sizeof(dwStatus);
	BOOL bSuccess = pHttpFile->QueryInfo(HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &dwStatus, &dwBuffLen);

	int nReadBlockSize = 256*1024;
	char* pBuffer = new char[nReadBlockSize];
	if( bSuccess && dwStatus>= 200&& dwStatus<300 )
	{
		if (strFileName.length() == 0)
		{
			CString sContentDisposition;
			DWORD dwIndex = 0;
			bSuccess = pHttpFile->QueryInfo(HTTP_QUERY_CONTENT_DISPOSITION, sContentDisposition, &dwIndex);
			std::string strContentDisposition((LPCTSTR)sContentDisposition);
			std::string strKeyBegin("filename=\"");
			std::string strKeyEnd("\"");

			if (!strContentDisposition.empty())
			{
				size_t nBegin = strContentDisposition.find(strKeyBegin) + strKeyBegin.length();
				if (nBegin < strContentDisposition.length())
				{
					size_t nEnd = strContentDisposition.find(strKeyEnd, nBegin);
					strFileName = strContentDisposition.substr(nBegin, nEnd - nBegin);
				}
				strFileName = deescapeURL(strFileName);
				ZTools::UTF8ToMB(strFileName);
			}
		}

		if (strFileName.length() == 0)
		{
			delete[] pBuffer;
			pBuffer = NULL;
			pHttpFile->Close();
			//delete pHttpFile;
			sess.Close();
			ZTools::WriteZToolsFormatLog("没有找到文件名");
			return "";
		}

		std::replace(strFileDir.begin(), strFileDir.end(), '/', '\\');
		strFileDir.erase(strFileDir.find_last_not_of('\\') + 1);
		std::replace(strFileName.begin(), strFileName.end(), '/', '\\');
		strFileName.erase(0, strFileName.find_first_not_of('\\'));
		std::string strFilePath = ZTools::FormatString("%s\\%s", strFileDir.c_str(), strFileName.c_str());
		//先下载到临时文件中,下载成功后重命名
		std::string strFilePathTemp = ZTools::FormatString("%s\\%s", strFileDir.c_str(), ZTools::GetCurrentTimeString16().c_str());

		if (!MakeSureDirectoryPathExists(strFilePath.c_str()))
		{
			delete[] pBuffer;
			pBuffer = NULL;
			pHttpFile->Close();
			//delete pHttpFile;
			sess.Close();
			ZTools::WriteZToolsFormatLog("创建文件夹失败:%s", strFilePath.c_str());
			return "";
		}

		CFile fileWrite;
		ULONGLONG dwFileLen = 0;
		DWORD dwWriteIndex = 0;
		dwFileLen = pHttpFile->SeekToEnd();
		pHttpFile->SeekToBegin();
		if(fileWrite.Open(strFilePathTemp.c_str(), CFile::modeWrite|CFile::modeCreate))
		{
			int nCount = 0;
			while(dwWriteIndex < dwFileLen)
			{
				nCount = pHttpFile->Read(pBuffer, nReadBlockSize);
				fileWrite.Write(pBuffer, nCount);
				dwWriteIndex += nCount;                
			}
			fileWrite.Close();

			rename(strFilePathTemp.c_str(), strFilePath.c_str());

			delete[] pBuffer;
			pBuffer = NULL;
			pHttpFile->Close();
			delete pHttpFile;
			sess.Close();

			if (PathFileExists(strFilePath.c_str()))
			{
				return strFilePath;
			}
			else
			{
				return "";
			}
		}
		else
		{
			delete[] pBuffer;
			pBuffer = NULL;
			pHttpFile->Close();
			//delete pHttpFile;
			sess.Close();
			ZTools::WriteZToolsFormatLog("本地文件%s打开出错", strFilePath.c_str());
			return "";
		}
	}
	else
	{
		delete[] pBuffer;
		pBuffer = NULL;
		pHttpFile->Close();
		//delete pHttpFile;
		sess.Close();
		ZTools::WriteZToolsFormatLog("打开网页文件出错,错误码:%d", dwStatus);
		return "";
	}

	delete[] pBuffer;
	pBuffer = NULL;
	pHttpFile->Close();
	//delete pHttpFile;
	sess.Close();	
	return "";
}
Example #22
0
 BOOST_FILESYSTEM_DECL bool portable_posix_name(const std::string & name)
 {
   return name.size() != 0
     && name.find_first_not_of(valid_posix) == std::string::npos;     
 }
 void strip(std::string& str) {
    str.erase(str.find_last_not_of(" ") + 1);	//RTrim
    str.erase(0, str.find_first_not_of(" "));	//LTrim
 }
Example #24
0
/**
 * @brief remove whitespaces from string
 * @param str
 */
void string_trim(std::string &str)
{
	str.erase(0, str.find_first_not_of(" \t\n\r\v"));
	str.erase(str.find_last_not_of(" \t\n\r\v")+1);
}
Example #25
0
bool is_blank(const std::string &line){
	if (!line.size())
		return 1;
	auto first = line.find_first_not_of(" \t");
	return first == line.npos;
}
	bool
	FilteredTrace::parse_nmea_string(const std::string& nmea_string)
	{
		/* Guarantees that no spaces are inside nmea_string */
		/* ... */
		/** @todo Think about that later (is it necessary???) */
		
		const std::string ENDLINE = "\n";
		const std::string GPGGA_PREFIX("$GPGGA");
		const std::string GPRMC_PREFIX("$GPRMC");
		const int PREFIX_BEGIN_INDEX = 0;
		const int PREFIX_LENGTH = 6;
		const int TIME_BEGIN_INDEX = 7;
		const int TIME_LENGTH = 6;

		bool use_gpgga_string = true;
		bool found_gprmc_string = false;
		bool found_gpgga_string = false;
		std::string gpgga_string;
		std::string gprmc_string;
		std::string time_string;

		GPSPoint gps_point;
		int found_gps_points = 0;	
			
		std::string::size_type begin_index = nmea_string.find_first_not_of(ENDLINE);
		if (begin_index == std::string::npos)	return false;
		std::string::size_type end_index = nmea_string.find_first_of(ENDLINE, begin_index);
		
		while(end_index != std::string::npos)
		{
			std::string nmea_prefix(
				nmea_string.substr(begin_index + PREFIX_BEGIN_INDEX, PREFIX_LENGTH)
			);
			
//			std::cout << "nmea_prefix=" << nmea_prefix << "; ";
			if (nmea_prefix == GPRMC_PREFIX)
			{
//				std::cout << "GPRMC; ";
				if (use_gpgga_string)
				{
//					std::cout << "!found_gprmc_string; ";
					if (!found_gprmc_string)
					{
						if (!found_gpgga_string)
						{
//							std::cout << "!found_gpgga_string; ";
							time_string.append(nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH));
							gprmc_string.append(nmea_string.substr(begin_index, end_index - begin_index));
							found_gprmc_string = true;
						} else // explicit: if (found_gpgga_string)
						{
//							std::cout << "found_gpgga_string; ";
							gprmc_string.append(nmea_string.substr(begin_index, end_index - begin_index));
							
							if (nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH) == time_string)
							{
//								std::cout << "same_time; ";
								if (gps_point.parse_nmea_string(gpgga_string, gprmc_string))
								{
//									std::cout << "parse_gps_point ok; ";
									push_back(gps_point);
									++found_gps_points;
								} else
								{
									mlog(MLog::debug, "FilteredTrace::parse_from_nmea")
										<< "Parsing of NMEA strings fails! (GPGGA and GPRMC strings follows) "
										<< gpgga_string << " " << gprmc_string << "\n";
								}
								
								found_gprmc_string = false;
								found_gpgga_string = false;
								gpgga_string.erase();
								gprmc_string.erase();
								time_string.erase();
							} else // explicit: if (nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH) != time_string)
							{
//								std::cout << "!same_time; ";
								gpgga_string.erase();
								found_gpgga_string = false;
								found_gprmc_string = true;
								time_string.erase();
								time_string.append(
									nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH)
								);
							} // end: if (nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH) == time_string)
						} // end: if (!found_gpgga_string)
						
					} else // explicit: if(found_gprmc_string)
					{
						mlog(MLog::info, "FilteredTrace") << "Switching to \"No-GPGGA-Modus\".\n";
						use_gpgga_string = false;
						_gps_points_have_valid_altitudes = false;
						
						if (size() > 0)
						{
							mlog(MLog::debug, "FilteredTrace") << "Must review GPSPoints.\n";
							iterator iter = begin();
							iterator iter_end = end();
							for (; iter != iter_end; ++iter)
							{
								iter->set_altitude(-1.0);
								/** @todo Define a value for a invalid altitude
								 * (perhaps -1000000, because this value is never reached in
								 * real world!) */
							}
						}
						
						if (gps_point.parse_nmea_string("", gprmc_string))
						{
							push_back(gps_point);
							++found_gps_points;
						}
						
						if (gps_point.parse_nmea_string("", nmea_string.substr(begin_index, end_index - begin_index)))
						{
							push_back(gps_point);
							++found_gps_points;
						}
					}
					
				} else // explicit: if (!use_gpgga_string)
				{
//					std::cout << "found_gprmc_string; ";
					if (gps_point.parse_nmea_string("", nmea_string.substr(begin_index, end_index - begin_index)))
					{
						push_back(gps_point);
						++found_gps_points;
					}
				} // end: if (use_gpgga_string)
				
			} else if (use_gpgga_string && (nmea_prefix == GPGGA_PREFIX))
			{
//				std::cout << "GPGGA; ";
				if (!found_gpgga_string)
				{
//					std::cout << "!found_gpgga_string; ";
					if (!found_gprmc_string)
					{
//						std::cout << "!found_gprmc_string; ";
						time_string.append(nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH));
						gpgga_string.append(nmea_string.substr(begin_index, end_index- begin_index));
						found_gpgga_string = true;
					} else // explicit: if (found_gprmc_string)
					{
//						std::cout << "found_gprmc_string; ";
						gpgga_string.append(nmea_string.substr(begin_index, end_index - begin_index));
						
						if (nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH) == time_string)
						{
//							std::cout << "same_time; ";
							if (gps_point.parse_nmea_string(gpgga_string, gprmc_string))
							{
//								std::cout << "parse_gps_point ok; ";
								push_back(gps_point);
								++found_gps_points;
							} else
							{
								mlog(MLog::debug, "FilteredTrace::parse_from_nmea")
									<< "Parsing of NMEA strings fails! (GPGGA and GPRMC strings follows) "
									<< gpgga_string << " " << gprmc_string << "\n";
							}
							
							found_gprmc_string = false;
							found_gpgga_string = false;
							gpgga_string.erase();
							gprmc_string.erase();
							time_string.erase();
						} else // explicit: if (nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH) != time_string)
						{
//							std::cout << "!same_time; ";
							gprmc_string.erase();
							found_gprmc_string = false;
							found_gpgga_string = true;
							time_string.erase();
							time_string.append(
								nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH)
							);
						} // end: if (nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH) == time_string)
					} // end: if (!found_gprmc_string)
				} else // explicit: if (found_gpgga_string)
				{
//					std::cout << "found_gpgga_string; ";
					gpgga_string.erase();
					gpgga_string.append(nmea_string.substr(begin_index, end_index - begin_index));
					time_string.erase();
					time_string.append(nmea_string.substr(begin_index + TIME_BEGIN_INDEX, TIME_LENGTH));
				} // end: if (!found_gpgga_string)
			} // end: if (nmea_prefix == *)
			
			begin_index = nmea_string.find_first_not_of(ENDLINE, end_index);
			if (begin_index == std::string::npos)	break;
			end_index = nmea_string.find_first_of(ENDLINE, begin_index);
			
		} // end: while
		
//		std::cout << std::endl;
		
		return (found_gps_points > 0);
	}
void trimLeft(std::string &str, std::string delim) {
	size_t pos = str.find_first_not_of(delim);
	if (pos != std::string::npos) {
		str.erase(0, pos);
	}
}
Example #28
0
std::string trim (const std::string& str)
{
  const size_t first = str.find_first_not_of(' ');
  const size_t last = str.find_last_not_of(' ');
  return str.substr(first, (last - first + 1));
}
Example #29
0
	bool Document::parseTag(ElementPtr &_currentNode, std::string _content)
	{

		// убераем лишнее
		utility::trim(_content);

		if (_content.empty()) {
			// создаем пустой тег
			if (_currentNode) _currentNode = _currentNode->createChild("");
			else {
				_currentNode = new Element("", 0);
				// если это первый то запоминаем
				if (!mRoot) mRoot = _currentNode;
			}
			return true;
		}

		char simbol = _content[0];
		bool tag_info = false;

		if (simbol == '!') return true; // проверяем на коментарии

		if (simbol == '?') { // проверяем на информационный тег
			tag_info = true;
			_content.erase(0, 1); // удаляем первый символ
		}

		size_t start, end;
		// проверяем на закрытие тега
		if (simbol == '/') {
			if (_currentNode == 0) {
				// чета мы закрывам а ниче даже и не открыто
				if (!mRoot) {
					mLastError = ErrorType::CloseNotOpenedElement;
					return false;
				}
			}
			// обрезаем имя тэга
			start = _content.find_first_not_of(" \t", 1);
			if (start == _content.npos) {
				// тег пустой
				_content.clear();
			} else {
				end = _content.find_last_not_of(" \t");
				_content = _content.substr(start, end - start+1);
			}
			// проверяем соответствие открывающего и закрывающего тегов
			if (_currentNode->getName() != _content) {
				mLastError = ErrorType::InconsistentOpenCloseElements;
				return false;
			}
			// а теперь снижаем текущий узел вниз
			_currentNode = _currentNode->getParent();

		}
		else {
			// выделяем имя до первого пробела или закрывающего тега
			std::string cut = _content;
			start = _content.find_first_of(" \t/?", 1); // << превед
			if (start != _content.npos) {
				cut = _content.substr(0, start);
				_content = _content.substr(start);
			} else _content.clear();

			if (_currentNode) _currentNode = _currentNode->createChild(cut);
			else {
				if (tag_info) {
					// информационный тег
					if (mDeclaration) {
						mLastError = ErrorType::MoreThanOneXMLDeclaration;
						return false;
					}
					_currentNode = new Element(cut, 0, ElementType::Comment);
					mDeclaration = _currentNode;
				} else {
					// рутовый тег
					if (mRoot) {
						mLastError = ErrorType::MoreThanOneRootElement;
						return false;
					}
					_currentNode = new Element(cut, 0, ElementType::Normal);
					mRoot = _currentNode;
				}
			}

			// проверим на пустоту
			start = _content.find_last_not_of(" \t");
			if (start == _content.npos) return true;

			// сразу отделим закрывающийся тэг
			bool close = false;
			if ((_content[start] == '/') || (_content[start] == '?')) {
				close = true;
				// не будем резать строку, просто поставим пробел
				_content[start] = ' ';
				// проверим на пустоту
				start = _content.find_last_not_of(" \t");
				if (start == _content.npos) {
					// возвращаем все назад и уходим
					_currentNode = _currentNode->getParent();
					return true;
				}
			}

			// а вот здесь уже в цикле разбиваем на атрибуты
			while (true) {

				// ищем равно
				start = _content.find('=');
				if (start == _content.npos) {
					mLastError = ErrorType::IncorrectAttribute;
					return false;
				}
				// ищем вторые ковычки
				end = _content.find_first_of("\"\'", start+1);
				if (end == _content.npos) {
					mLastError = ErrorType::IncorrectAttribute;
					return false;
				}
				end = _content.find_first_of("\"\'", end+1);
				if (end == _content.npos) {
					mLastError = ErrorType::IncorrectAttribute;
					return false;
				}

				std::string key = _content.substr(0, start);
				std::string value = _content.substr(start+1, end-start);

				// проверка на валидность
				if (! checkPair(key, value)) {
					mLastError = ErrorType::IncorrectAttribute;
					return false;
				}

				// добавляем пару в узел
				_currentNode->addAttribute(key, value);

				// следующий кусок
				_content = _content.substr(end+1);

				// в строке не осталось символов
				start = _content.find_first_not_of(" \t");
				if (start == _content.npos) break;

				mCol += start;

			};

			// был закрывающий тег для текущего тега
			if (close) {
				// не проверяем имена, потому что это наш тэг
				_currentNode = _currentNode->getParent();
			}

		}
		return true;
	}
Example #30
0
void IO::
TrimLeadingWhitespace(std::string &rStr)
{
    string::size_type front = rStr.find_first_not_of(" \t\r\n");
    rStr.erase(0, front);
}