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

 std::string to_string(T const &t)
 {
   static std::ostringstream oss;
   oss.clear(); oss.str("");
   oss << t;
   return oss.str();
 }

void logger::log(int line, std::ostringstream &outstring)
{
    if ( logging == 0 ) return;
    *out << file << ":" << line << " - " << outstring.str();
    outstring.str(std::string());
    outstring.clear();
}

std::string expand(Range const& key)
{
    thread_local std::ostringstream oss;
    oss.str().clear();
    oss.clear();
    oss.seekp(0);
    oss << " (subst_for_" << key.to_string() << ':' << (rand()%42) << ") ";
    return oss.str();
}

    void
    _SetCommonOptions(const std::string& url) {

        // set url
        CURLcode err = curl_easy_setopt(handle_, CURLOPT_URL, url.c_str());
        _CheckError(err, "set url");

        // Allow redirection
        err = curl_easy_setopt(handle_, CURLOPT_FOLLOWLOCATION, 1L);
        _CheckError(err, "set follow location");

        // Clear write stream
        write_stream_.str("");
        write_stream_.clear();

        // Set callback for write
        err = curl_easy_setopt(handle_, CURLOPT_WRITEFUNCTION, _WriteCb);
        _CheckError(err, "set write callback");

        // Set callback data
        err = curl_easy_setopt(handle_, CURLOPT_WRITEDATA, this);
        _CheckError(err, "set write data");

        if (enable_header_) {
            // Get curl header

            // clear existing header data
            header_stream_.str("");
            header_stream_.clear();

            // Set header callback function
            err = curl_easy_setopt(handle_, CURLOPT_HEADERFUNCTION, _HeaderCb);
            _CheckError(err, "set header callback");

            // Set header user data for callback function
            err = curl_easy_setopt(handle_, CURLOPT_HEADERDATA, this);
            _CheckError(err, "set header data");
        }

        // Set the user agent. Some servers requires this on requests
        err = curl_easy_setopt(handle_, CURLOPT_USERAGENT, "libcurl-agent/1.0");
        _CheckError(err, "set write data");
    }

    int Z3_check_interpolant(Z3_context ctx,
                             unsigned num,
                             Z3_ast *cnsts,
                             unsigned *parents,
                             Z3_ast *itp,
                             Z3_string *error,
                             unsigned num_theory,
                             Z3_ast *theory){

        ast_manager &_m = mk_c(ctx)->m();
        itp_err.clear();

        // need a solver -- make one here, but how?
        params_ref p = params_ref::get_empty(); //FIXME
        scoped_ptr<solver_factory> sf(mk_smt_solver_factory());
        scoped_ptr<solver> sp((*(sf))(_m, p, false, true, false, symbol("AUFLIA")));

        ptr_vector<ast> cnsts_vec(num);  // get constraints in a vector
        for (unsigned i = 0; i < num; i++){
            ast *a = to_ast(cnsts[i]);
            cnsts_vec[i] = a;
        }

        ptr_vector<ast> itp_vec(num);  // get interpolants in a vector
        for (unsigned i = 0; i < num - 1; i++){
            ast *a = to_ast(itp[i]);
            itp_vec[i] = a;
        }

        ::vector<int> parents_vec;  // get parents in a vector
        if (parents){
            parents_vec.resize(num);
            for (unsigned i = 0; i < num; i++)
                parents_vec[i] = parents[i];
        }

        ptr_vector<ast> theory_vec; // get background theory in a vector
        if (theory){
            theory_vec.resize(num_theory);
            for (unsigned i = 0; i < num_theory; i++)
                theory_vec[i] = to_ast(theory[i]);
        }

        bool res = iz3check(_m,
                            sp.get(),
                            itp_err,
                            cnsts_vec,
                            parents_vec,
                            itp_vec,
                            theory_vec);

        *error = res ? 0 : itp_err.str().c_str();
        return res;
    }

std::string to_binary(std::ostringstream &out, const T &t) {
  out.clear();
  out.seekp(0);
  bf::fold(t, 0, app_item(out));
  // because out.str() gives us the contents of the string buffer,
  // not the contents written since clear() was called, we need to
  // chop off any remaining garbage at the end.
  std::string rv = out.str();
  rv.resize(out.tellp());
  return rv;
}

void Actor::printActions(std::ostringstream& buff, bool full)
{
	buff.clear();
	buff<<"Actor state: "<<m_state->getName()<<std::endl;
	buff<<"Actor actions on effectors: "<<std::endl;
	for(EffectorMap::iterator it = m_effectors.begin(),end = m_effectors.end();
			it!=end;it++)
	{
		Effector* effector = it->second;
		buff<<Effector::convertToString(effector->getId())<<std::endl;
		std::string tabs;

		print(effector,m_rootAction,buff,tabs,full);
	}
}

void test_per_segment_const(Geometry const& geometry,
        std::string const& expected_dsv,
        double expected_length)
{
    typedef typename bg::point_type<Geometry>::type point_type;

    // function
    g_out.str("");
    g_out.clear();
    bg::for_each_segment(geometry,
            stream_segment<bg::model::referring_segment<point_type const> >);
    std::string out = g_out.str();
    boost::trim(out);
    BOOST_CHECK_EQUAL(out, expected_dsv);

    // functor
    sum_segment_length<bg::model::referring_segment<point_type const> > functor;
    functor = bg::for_each_segment(geometry, functor);

    BOOST_CHECK_CLOSE(functor.sum, expected_length, 0.0001);
}

    static bool iZ3_parse(Z3_context ctx, const char *filename, const char **error, svector<Z3_ast> &assertions){
        read_error.clear();
        try {
            std::string foo(filename);
            if (foo.size() >= 5 && foo.substr(foo.size() - 5) == ".smt2"){
                Z3_ast assrts = Z3_parse_smtlib2_file(ctx, filename, 0, 0, 0, 0, 0, 0);
                Z3_app app = Z3_to_app(ctx, assrts);
                int nconjs = Z3_get_app_num_args(ctx, app);
                assertions.resize(nconjs);
                for (int k = 0; k < nconjs; k++)
                    assertions[k] = Z3_get_app_arg(ctx, app, k);
            }
            else {
                Z3_parse_smtlib_file(ctx, filename, 0, 0, 0, 0, 0, 0);
                int numa = Z3_get_smtlib_num_assumptions(ctx);
                int numf = Z3_get_smtlib_num_formulas(ctx);
                int num = numa + numf;

                assertions.resize(num);
                for (int j = 0; j < num; j++){
                    if (j < numa)
                        assertions[j] = Z3_get_smtlib_assumption(ctx, j);
                    else
                        assertions[j] = Z3_get_smtlib_formula(ctx, j - numa);
                }
            }
        }
        catch (...) {
            read_error << "SMTLIB parse error: " << Z3_get_smtlib_error(ctx);
            read_msg = read_error.str();
            *error = read_msg.c_str();
            return false;
        }
        Z3_set_error_handler(ctx, 0);
        return true;
    }

void cleanup() {
    featureVector.clear();
    os.clear(); os.seekp(0);    // reset string stream
    os.str("");
}

 void emptyAndClearString() {
     str.str(std::string());
     str.clear();
 }

	void writeToConsole(std::ostream &os, std::ostringstream &oss) {
		boost::unique_lock<boost::mutex> console_lock(mutConsole);
		os << oss.str();
		oss.str("");
		oss.clear();
	}