C++ stringstream::clear方法代码示例

diagnostic_msgs::DiagnosticStatus getMemoryStatus() {
    diagnostic_msgs::DiagnosticStatus memoryStatus;

    memoryStatus.name = "memoryStatus";
    memoryStatus.message = "The current memory status is ";
    float percentage = (memory.memFree + memory.memCached + memory.memBuffers) * 1.0 / memory.memTotal;
    if (0.3 <= percentage) {
	memoryStatus.level = 0;
	memoryStatus.message += " OK";
    }
    else if (0.2 <= percentage) {
	memoryStatus.level = 1;
	memoryStatus.message += " moderate";
    }
    else {
	memoryStatus.level = 2;
	memoryStatus.message += " weak";
    }

    memoryStatus.hardware_id = "memory";
    memoryStatus.values.resize(5);

    floatStringHelper.clear();
    floatStringHelper << percentage;
    memoryStatus.values[0].key = "free";
    floatStringHelper >> memoryStatus.values[0].value;

    floatStringHelper.clear();
    floatStringHelper << memory.memTotal;
    memoryStatus.values[1].key = "memTotal";
    floatStringHelper >> memoryStatus.values[1].value;

    floatStringHelper.clear();
    floatStringHelper << memory.memFree;
    memoryStatus.values[2].key = "memFree";
    floatStringHelper >> memoryStatus.values[2].value;

    floatStringHelper.clear();
    floatStringHelper << memory.memCached;
    memoryStatus.values[3].key = "memCached";
    floatStringHelper >> memoryStatus.values[3].value;

    floatStringHelper.clear();
    floatStringHelper << memory.memBuffers;
    memoryStatus.values[4].key = "memBuffers";
    floatStringHelper >> memoryStatus.values[4].value;

    return memoryStatus;
}

void GuiHelper::printBytesPercent(GRender& render, uint32_t x, uint32_t y, long total, long other) {

	static std::stringstream ss;
	ss.str("");
	ss.clear();
	ss.imbue(std::locale(""));

	std::string unit;
	int div = 1;
	int digits = 0;

	switch (bytePercentUnit) {
	case GH_TYPE_BYTE:	div = 1; digits = 0; unit = " B"; break;
	case GH_TYPE_KBYTE: div = 1024; digits = 1; unit = " KiB"; break;
	case GH_TYPE_MBYTE: div = 1024 * 1024; digits = 1; unit = " MiB"; break;
	}

	float percent = (total) ? (100.0 * other / (total)) : (0);
	ss << " (" << std::setiosflags(std::ios::fixed) << std::setprecision(1) << percent << "%)";
	render.printR(x, y, ss.str());
	ss.str("");
	ss << std::setprecision(digits) << (other / (float) div) << unit ;
	render.printR(x-9, y, ss.str());

}

void printERRLOG() {
  std::string errLine;
  while( std::getline(ERRLOG,errLine) ) {
    std::cerr << errLine << std::endl;
  }
  ERRLOG.clear();
}

 // This resets the flags of streamToReset and sets its string to be
 // newString.
 inline void
 ParsingUtilities::ResetStringstream( std::stringstream& streamToReset,
                                      std::string const& newString )
 {
   streamToReset.clear();
   streamToReset.str( newString );
 }

    void init(uint64_t const _i)
    {
        i = _i;

        if (options.doubleIndexing)
        {
            indexBeginQry = (length(gH.qrySeqs) / options.queryPart) * i;
            indexEndQry = (i+1 == options.queryPart) // last interval
                            ? length(gH.qrySeqs) // reach until end
                            : (length(gH.qrySeqs) / options.queryPart) * (i+1);
            // make sure different frames of one sequence in same interval
            indexBeginQry -= (indexBeginQry % qNumFrames(blastProgram));
            indexEndQry -= (indexEndQry % qNumFrames(blastProgram));
        } else
        {
            indexBeginQry = qNumFrames(blastProgram) * i;
            indexEndQry = qNumFrames(blastProgram) * (i+1);
        }

        clear(seeds);
        clear(seedIndex);
        matches.clear();
        seedRefs.clear();
        seedRanks.clear();
//         stats.clear();
        statusStr.clear();
        statusStr.precision(2);
    }

void NaCl::flushLogs() {
    string loutStr = lout.str();
    if(loutStr.length() != 0) {
        accumulatedEvents.Set("isDirty", true);
		accumulatedEvents.Set("messages", loutStr);
        lout.str(string());
        lout.clear();
    }
    string lerrStr = lerr.str();
    if(lerrStr.length() != 0) {
        accumulatedEvents.Set("isDirty", true);
		accumulatedEvents.Set("errors", lerrStr);
        lerr.str(string());
        lerr.clear();
    }
}

   void setup () {

      // ----------------------------------------------------------------------
      // Initialize the Log component

      // Name of log file
      log_file = Parameters::get_optional<std::string>(
            "Log.log_file", "log.txt");
      log_file = Driver::output_dir + log_file;

      // Open log file
#ifdef PARALLEL_MPI
      if (Driver::proc_ID == log_master) {
         lout.open(log_file.c_str());
      }
#else // PARALLEL_MPI
      lout.open(log_file.c_str());
#endif // PARALLEL_MPI
      initialized = true;

      // Write the log file header
      lout << "Hydrodynamics Simulation" << std::endl << std::endl;

      // If the buffer is not empty, push it to the file
      lout << buffer.str();
      buffer.clear();
      buffer.str("");

   }

// stringstreamをクリアして再利用できるようにする
void IPBase::clear_stringstream(std::stringstream &ss) {
	static const std::string empty_string;

	ss.str(empty_string);
	ss.clear();
	ss << std::dec;     // clear()でも元に戻らないので、毎回指定する。
}

void CPlayer::SendSteamMessages(MessageTypes type, std::stringstream &ss)
{
    if (!ss.str().empty())
    {
        std::string item;

        while (std::getline(ss, item))
        {
            item = MSG_COLOR_WHITE + item + "|r"; // Default chat to white.
            const char* msg = item.c_str();

            if ((type & CHAT_BOX) != 0)
                ChatHandler(GetSession()).SendSysMessage(msg);
            if ((type & CHAT_WIDE) != 0)
            {
                WorldPacket data(SMSG_NOTIFICATION, (strlen(msg) + 1));
                data << msg;
                GetSession()->SendPacket(&data);
            }
        }

        ss.str(""); // Clear content
        ss.clear(); // Clear state flags.
    }
}

void SettingsDAOSqlite3Impl::set( const std::string& key, const double& value ) {
	static std::stringstream ss;
	ss.str("");
	ss.clear();
	ss << value;
	set( key, ss.str() );
}

    virtual std::string generateIndexedIndependent(const OperationNode<Base>& indexedIndep,
            const IndexPattern& ip) override {
        bool isX = indexedIndep.getInfo()[0] == 0;
        if (isX) {
            return _nameGen->generateIndexedIndependent(indexedIndep, ip);
        }

        size_t nIndex = indexedIndep.getArguments().size();

        CPPADCG_ASSERT_KNOWN(indexedIndep.getOperationType() == CGOpCode::LoopIndexedIndep, "Invalid node type");
        CPPADCG_ASSERT_KNOWN(nIndex > 0, "Invalid number of arguments");

        std::vector<const IndexDclrOperationNode<Base>*> indices(nIndex);
        for (size_t i = 0; i < nIndex; ++i) {// typically there is only one index but there may be more
            CPPADCG_ASSERT_KNOWN(indexedIndep.getArguments()[i].getOperation() != nullptr, "Invalid argument");
            CPPADCG_ASSERT_KNOWN(indexedIndep.getArguments()[i].getOperation()->getOperationType() == CGOpCode::Index, "Invalid argument");
            indices[i] = &static_cast<const IndexOperationNode<Base>&> (*indexedIndep.getArguments()[i].getOperation()).getIndex();
        }

        _ss.clear();
        _ss.str("");

        _ss << _multName << "[" << LanguageC<Base>::indexPattern2String(ip, indices) << "]";
        return _ss.str();
    }

void NCursesIOManager::setupNewLine(std::stringstream & ss, int & positionX, int & positionY) const
{
	move(positionY, positionX);
	++positionY;
	ss.clear();
	ss.str("");
}

bool XQueryCompiler::getLanguageMode(std::stringstream& s) const
{
  const size_t lPeekSize = 7;
  char lPeek[lPeekSize];
  s.get(lPeek, lPeekSize);
  s.clear();
  s.seekg(0, s.beg);

  bool lXQueryMode;

  if (strncmp(lPeek, "jsoniq", lPeekSize - 1) == 0)
  {
    lXQueryMode = false;
  }
  else if (strncmp(lPeek, "xquery", lPeekSize - 1) == 0)
  {
    lXQueryMode = true;
  }
  else
  {
    if (theCompilerCB->theRootSctx) // could be null in eval
    {
      StaticContextConsts::language_kind_t lKind
        = theCompilerCB->theRootSctx->language_kind();
      lXQueryMode = (lKind != StaticContextConsts::language_kind_jsoniq);
    }
    else
    {
      lXQueryMode = true;
    }
  }
  return lXQueryMode;
}

std::string to_string(const T& item) {
    static std::stringstream ss;
    ss.clear();

    ss << item;

    return ss.str();
}

returnType from_hex_string(std::string str) {
    static std::stringstream ss;
    ss.clear();
    ss << std::hex << str;
    returnType retval;
    ss >> retval;
    
    return retval;
}