自学教程：C++ FC_RETHROW_EXCEPTIONS函数代码示例

parameter_description_list api_generator::load_parameters(const fc::variants& json_parameter_descriptions){  parameter_description_list parameters;  for (const fc::variant& parameter_description_variant : json_parameter_descriptions)  {    fc::variant_object json_parameter_description = parameter_description_variant.get_object();    parameter_description parameter;    FC_ASSERT(json_parameter_description.contains("name"), "parameter is missing /"name/"");    parameter.name = json_parameter_description["name"].as_string();    try    {      FC_ASSERT(json_parameter_description.contains("description"), "parameter is missing /"description/"");      parameter.description = json_parameter_description["description"].as_string();      FC_ASSERT(json_parameter_description.contains("type"), "parameter is missing /"type/"");      parameter.type = lookup_type_mapping(json_parameter_description["type"].as_string());      if( json_parameter_description.contains( "prompt" ) )         parameter.prompt = json_parameter_description["prompt"].as_bool();      if (json_parameter_description.contains("default_value"))        parameter.default_value = json_parameter_description["default_value"];      if (json_parameter_description.contains("example"))        parameter.example = json_parameter_description["example"];    }    FC_RETHROW_EXCEPTIONS(error, "error processing parameter ${name}", ("name", parameter.name));    parameters.push_back(parameter);  }  return parameters;}

   char parseEscape( T& in )   {      if( in.peek() == '//' )      {         try {            in.get();            switch( in.peek() )            {               case 't':                  in.get();                  return '/t';               case 'n':                  in.get();                  return '/n';               case 'r':                  in.get();                  return '/r';               case '//':                  in.get();                  return '//';               default:                  return in.get();            }         } FC_RETHROW_EXCEPTIONS( info, "Stream ended with '//'" );      }	    FC_THROW_EXCEPTION( parse_error_exception, "Expected '//'"  );   }

void    signed_transaction::sign( const fc::ecc::private_key& k ){    try {        sigs.insert( k.sign_compact( digest() ) );    }    FC_RETHROW_EXCEPTIONS( warn, "error signing transaction", ("trx", *this ) );}

void stcp_socket::close(){  try   {    _sock.close();  }FC_RETHROW_EXCEPTIONS( warn, "error closing stcp socket" );}

  /**   *  A price will reorder the asset types such that the   *  asset type with the lower enum value is always the   *  denominator.  Therefore  bts/usd and  usd/bts will   *  always result in a price measured in usd/bts because   *  asset::bts <  asset::usd.   */  price operator / ( const asset& a, const asset& b )  {    try     {        if( a.asset_id == b.asset_id )           FC_CAPTURE_AND_THROW( asset_divide_by_self );        price p;        auto l = a; auto r = b;        if( l.asset_id < r.asset_id ) { std::swap(l,r); }        ilog( "${a} / ${b}", ("a",l)("b",r) );        if( r.amount == 0 )           FC_CAPTURE_AND_THROW( asset_divide_by_zero, (r) );        p.base_asset_id = r.asset_id;        p.quote_asset_id = l.asset_id;        fc::bigint bl = l.amount;        fc::bigint br = r.amount;        fc::bigint result = (bl * fc::bigint(BTS_PRICE_PRECISION)) / br;        p.ratio = result;        return p;    } FC_RETHROW_EXCEPTIONS( warn, "${a} / ${b}", ("a",a)("b",b) );  }

   variants arrayFromStream( T& in )   {      variants ar;      try      {        if( in.peek() != '[' )           FC_THROW_EXCEPTION( parse_error_exception, "Expected '['" );        in.get();        skip_white_space(in);        while( in.peek() != ']' )        {           if( in.peek() == ',' )           {              in.get();              continue;           }           if( skip_white_space(in) ) continue;           ar.push_back( variant_from_stream<T, parser_type>(in) );           skip_white_space(in);        }        if( in.peek() != ']' )           FC_THROW_EXCEPTION( parse_error_exception, "Expected ']' after parsing ${variant}",                                    ("variant", ar) );        in.get();      } FC_RETHROW_EXCEPTIONS( warn, "Attempting to parse array ${array}",                                         ("array", ar ) );      return ar;   }

   variants arrayFromStreamBase( T& in, std::function<variant(T&)>& get_value  )   {      variants ar;      try      {        if( in.peek() != '[' )           FC_THROW_EXCEPTION( parse_error_exception, "Expected '['" );        in.get();        while( in.peek() != ']' )        {           if( in.peek() == ',' )           {              in.get();              continue;           }           if( skip_white_space(in) ) continue;           ar.push_back( get_value(in) );        }        if( in.peek() != ']' )           FC_THROW_EXCEPTION( parse_error_exception, "Expected ']' after parsing ${variant}",                                    ("variant", ar) );        in.get();      } FC_RETHROW_EXCEPTIONS( warn, "Attempting to parse array ${array}",                                         ("array", ar ) );      return ar;   }

  /**   *  A price will reorder the asset types such that the   *  asset type with the lower enum value is always the   *  denominator.  Therefore  bts/usd and  usd/bts will   *  always result in a price measured in usd/bts because   *  asset::bts <  asset::usd.   */  price operator / ( const asset& a, const asset& b )  {    try     {        ilog( "${a} / ${b}", ("a",a)("b",b) );        price p;        auto l = a; auto r = b;        if( l.asset_id < r.asset_id ) { std::swap(l,r); }        ilog( "${a} / ${b}", ("a",l)("b",r) );        p.base_asset_id = r.asset_id;        p.quote_asset_id = l.asset_id;        //fc::uint128 bl(l.amount);        //fc::uint128 bl(r.amount);       // p.ratio = (bl* BTS_PRICE_PRECISION) / br;        fc::bigint bl = l.amount;        fc::bigint br = r.amount;        fc::bigint result = (bl * fc::bigint(BTS_PRICE_PRECISION)) / br;        p.ratio = result;        return p;    } FC_RETHROW_EXCEPTIONS( warn, "${a} / ${b}", ("a",a)("b",b) );  }

 void tcp_socket::close() {   try {       if( is_open() )       {          my->_sock.close();       }   } FC_RETHROW_EXCEPTIONS( warn, "error closing tcp socket" ); }

 void tcp_server::accept( tcp_socket& s )  {   try   {     FC_ASSERT( my != nullptr );     fc::asio::tcp::accept( my->_accept, s.my->_sock  );    } FC_RETHROW_EXCEPTIONS( warn, "Unable to accept connection on socket." ); }

   std::string tokenFromStream( T& in )   {      fc::stringstream token;      try      {         char c = in.peek();         while( true )         {            switch( c = in.peek() )            {               case '//':                  token << parseEscape( in );                  break;               case '/t':               case ' ':               case ',':               case ':':               case '/0':               case '/n':               case '/x04':                  in.get();                  return token.str();               case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h':               case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p':               case 'q': case 'r': case 's': case 't': case 'u': case 'v': case 'w': case 'x':               case 'y': case 'z':               case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H':               case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P':               case 'Q': case 'R': case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':               case 'Y': case 'Z':               case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':               case '8': case '9':               case '_': case '-': case '.': case '+': case '/':                  token << c;                  in.get();                  break;               default:                  return token.str();            }         }         return token.str();      }      catch( const fc::eof_exception& eof )      {         return token.str();      }      catch (const std::ios_base::failure&)      {         return token.str();      }      FC_RETHROW_EXCEPTIONS( warn, "while parsing token '${token}'",                                          ("token", token.str() ) );   }

  /**   *  Assuming a.type is either the numerator.type or denominator.type in   *  the price equation, return the number of the other asset type that   *  could be exchanged at price p.   *   *  ie:  p = 3 usd/bts & a = 4 bts then result = 12 usd   *  ie:  p = 3 usd/bts & a = 4 usd then result = 1.333 bts    */  asset operator * ( const asset& a, const price& p )  {    try {        if( a.asset_id == p.base_asset_id )        {            fc::bigint ba( a.amount ); // 64.64            fc::bigint r( p.ratio ); // 64.64            auto amnt = ba * r; //  128.128            amnt /= BTS_PRICE_PRECISION; // 128.64             auto lg2 = amnt.log2();            if( lg2 >= 128 )            {               FC_THROW_EXCEPTION( addition_overflow, "overflow ${a} * ${p}", ("a",a)("p",p) );            }            asset rtn;            rtn.amount = amnt.to_int64();            rtn.asset_id = p.quote_asset_id;            ilog( "${a} * ${p} => ${rtn}", ("a", a)("p",p )("rtn",rtn) );            return rtn;        }        else if( a.asset_id == p.quote_asset_id )        {            fc::bigint amt( a.amount ); // 64.64            amt *= BTS_PRICE_PRECISION; //<<= 64;  // 64.128            fc::bigint pri( p.ratio ); // 64.64            auto result = amt / pri;  // 64.64//            ilog( "amt: ${amt} / ${pri}", ("amt",string(amt))("pri",string(pri) ) ); //           ilog( "${r}", ("r",string(result) ) );            auto lg2 = result.log2();            if( lg2 >= 128 )            {             //  wlog( "." );               FC_THROW_EXCEPTION( addition_overflow,                                     "overflow ${a} / ${p} = ${r} lg2 = ${l}",                                     ("a",a)("p",p)("r", std::string(result)  )("l",lg2) );            }          //  result += 5000000000; // TODO: evaluate this rounding factor..            asset r;            r.amount    = result.to_int64();            r.asset_id  = p.base_asset_id;            ilog( "r.amount = ${r}", ("r",r.amount) );            ilog( "${a} * ${p} => ${rtn}", ("a", a)("p",p )("rtn",r) );            return r;        }        FC_THROW_EXCEPTION( asset_type_mismatch, "type mismatch multiplying asset ${a} by price ${p}",                                             ("a",a)("p",p) );    } FC_RETHROW_EXCEPTIONS( warn, "type mismatch multiplying asset ${a} by price ${p}",                                         ("a",a)("p",p) );  }

   std::string stringFromStream( T& in )   {      try      {         char c = in.peek(), c2;         switch( c )         {             case '/'':                 if( strict )                     FC_THROW_EXCEPTION( parse_error_exception, "expected: '/"' at beginning of string, got '/''" );                 // falls through             case '"':                 return quoteStringFromStream<T, strict, true>( in );             case 'r':                 if( strict )                     FC_THROW_EXCEPTION( parse_error_exception, "raw strings not supported in strict mode" );             case 'R':                 in.get();                 c2 = in.peek();                 switch( c2 )                 {                     case '"':                     case '/'':                         if( strict )                             FC_THROW_EXCEPTION( parse_error_exception, "raw strings not supported in strict mode" );                         return quoteStringFromStream<T, strict, false>( in );                     default:                         if( strict )                             FC_THROW_EXCEPTION( parse_error_exception, "unquoted strings not supported in strict mode" );                         return c+tokenFromStream( in );                 }                 break;             case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g': case 'h':             case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': case 'o': case 'p':             case 'q':           case 's': case 't': case 'u': case 'v': case 'w': case 'x':             case 'y': case 'z':             case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G': case 'H':             case 'I': case 'J': case 'K': case 'L': case 'M': case 'N': case 'O': case 'P':             case 'Q':           case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':             case 'Y': case 'Z':             case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':             case '8': case '9':             case '_': case '-': case '.': case '+': case '/':                 if( strict )                     FC_THROW_EXCEPTION( parse_error_exception, "unquoted strings not supported in strict mode" );                 return tokenFromStream( in );             default:                 FC_THROW_EXCEPTION( parse_error_exception, "expected: string" );         }       } FC_RETHROW_EXCEPTIONS( warn, "while parsing string" );       return {};   }

 void connection::connect( const fc::ip::endpoint& ep ) {    try {      // TODO: do we have to worry about multiple calls to connect?      my->sock = std::make_shared<stcp_socket>();      my->sock->connect_to(ep);       my->remote_ep = remote_endpoint();      ilog( "    connected to ${ep}", ("ep", ep) );      my->_read_loop_complete = fc::async( [=](){ my->read_loop(); } );    } FC_RETHROW_EXCEPTIONS( warn, "error connecting to ${ep}", ("ep",ep) ); }

/** *  Adds the owner to the required signature list *  Adds the balance to the trx balance sheet * *  TODO: this input is also valid if it is 1 year old and an output exists *        paying 95% of the balance back to the owner. * *  TODO: what if the source is an unvested market order... it means the *        proceeds of this trx are also 'unvested'.  Perhaps we will have to *        propagate the vested state along with the trx, if any inputs are *        sourced from an unvested trx, the new trx is also 'unvested' until *        the most receint input is fully vested. */void trx_validation_state::validate_signature( const meta_trx_input& in ){   try {       auto cbs = in.output.as<claim_by_signature_output>();       ilog( "${cbs}", ("cbs",cbs));       required_sigs.insert( cbs.owner );       asset output_bal( in.output.amount, in.output.unit );       balance_sheet[(asset::type)in.output.unit].in += output_bal;      } FC_RETHROW_EXCEPTIONS( warn, "validating signature input ${i}", ("i",in) );}

 void connection::send( const message& m ) {   try {     fc::scoped_lock<fc::mutex> lock(my->write_lock);     size_t len = MAIL_PACKED_MESSAGE_HEADER + m.size;     len = 16*((len+15)/16); //pad the message we send to a multiple of 16 bytes     std::vector<char> tmp(len);     memcpy( tmp.data(), (char*)&m, MAIL_PACKED_MESSAGE_HEADER );     memcpy( tmp.data() + MAIL_PACKED_MESSAGE_HEADER, m.data.data(), m.size );     my->sock->write( tmp.data(), tmp.size() );     my->sock->flush();   } FC_RETHROW_EXCEPTIONS( warn, "unable to send message" ); }

   variant_object objectFromStream( T& in, uint32_t depth )   {      depth++;      FC_ASSERT( depth <= JSON_MAX_RECURSION_DEPTH );      mutable_variant_object obj;      try      {         char c = in.peek();         if( c != '{' )            FC_THROW_EXCEPTION( parse_error_exception,                                     "Expected '{', but read '${char}'",                                     ("char",string(&c, &c + 1)) );         in.get();         skip_white_space( in, depth );         while( in.peek() != '}' )         {            if( in.peek() == ',' )            {               in.get();               continue;            }            if( skip_white_space( in, depth ) ) continue;            string key = stringFromStream( in, depth );            skip_white_space( in, depth );            if( in.peek() != ':' )            {               FC_THROW_EXCEPTION( parse_error_exception, "Expected ':' after key /"${key}/"",                                        ("key", key) );            }            in.get();            auto val = variant_from_stream<T, parser_type>( in, depth );            obj(std::move(key),std::move(val));            skip_white_space( in, depth );         }         if( in.peek() == '}' )         {            in.get();            return obj;         }         FC_THROW_EXCEPTION( parse_error_exception, "Expected '}' after ${variant}", ("variant", obj ) );      }      catch( const fc::eof_exception& e )      {         FC_THROW_EXCEPTION( parse_error_exception, "Unexpected EOF: ${e}", ("e", e.to_detail_string() ) );      }      catch( const std::ios_base::failure& e )      {         FC_THROW_EXCEPTION( parse_error_exception, "Unexpected EOF: ${e}", ("e", e.what() ) );      } FC_RETHROW_EXCEPTIONS( warn, "Error parsing object" );   }

        void store( const Key& k, const Value& v, bool sync = false )        { try {           FC_ASSERT( is_open(), "Database is not open!" );           ldb::Slice ks( (char*)&k, sizeof(k) );           auto vec = fc::raw::pack(v);           ldb::Slice vs( vec.data(), vec.size() );           auto status = _db->Put( sync ? _sync_options : _write_options, ks, vs );           if( !status.ok() )           {               FC_THROW_EXCEPTION( level_pod_map_failure, "database error: ${msg}", ("msg", status.ToString() ) );           }        } FC_RETHROW_EXCEPTIONS( warn, "error storing ${key} = ${value}", ("key",k)("value",v) ); }

        bool last( Key& k )        { try {           FC_ASSERT( is_open(), "Database is not open!" );           std::unique_ptr<ldb::Iterator> it( _db->NewIterator( _iter_options ) );           FC_ASSERT( it != nullptr );           it->SeekToLast();           if( !it->Valid() )           {             return false;           }           FC_ASSERT( sizeof( Key) == it->key().size() );           k = *((Key*)it->key().data());           return true;        } FC_RETHROW_EXCEPTIONS( warn, "error reading last item from database" ); }

 void store( const Key& k, const Value& v ) {   try   {      ldb::Slice ks( (char*)&k, sizeof(k) );      auto vec = fc::raw::pack(v);      ldb::Slice vs( vec.data(), vec.size() );            auto status = _db->Put( ldb::WriteOptions(), ks, vs );      if( !status.ok() )      {          FC_THROW_EXCEPTION( exception, "database error: ${msg}", ("msg", status.ToString() ) );      }   } FC_RETHROW_EXCEPTIONS( warn, "error storing ${key} = ${value}", ("key",k)("value",v) ); }

        bool last( Key& k )        { try {           FC_ASSERT( is_open(), "Database is not open!" );           std::unique_ptr<ldb::Iterator> it( _db->NewIterator( ldb::ReadOptions() ) );           FC_ASSERT( it != nullptr );           it->SeekToLast();           if( !it->Valid() )           {             return false;           }           fc::datastream<const char*> ds2( it->key().data(), it->key().size() );           fc::raw::unpack( ds2, k );           return true;        } FC_RETHROW_EXCEPTIONS( warn, "error reading last item from database" ); }

        void remove( const Key& k, bool sync = false )        { try {           FC_ASSERT( is_open(), "Database is not open!" );           ldb::Slice ks( (char*)&k, sizeof(k) );           auto status = _db->Delete( sync ? _sync_options : _write_options, ks );           if( status.IsNotFound() )           {             FC_THROW_EXCEPTION( fc::key_not_found_exception, "unable to find key ${key}", ("key",k) );           }           if( !status.ok() )           {               FC_THROW_EXCEPTION( level_pod_map_failure, "database error: ${msg}", ("msg", status.ToString() ) );           }        } FC_RETHROW_EXCEPTIONS( warn, "error removing ${key}", ("key",k) ); }

    void message_oriented_connection_impl::send_message(const message& message_to_send)    {      VERIFY_CORRECT_THREAD();#if 0 // this gets too verbose#ifndef NDEBUG      fc::optional<fc::ip::endpoint> remote_endpoint;      if (_sock.get_socket().is_open())        remote_endpoint = _sock.get_socket().remote_endpoint();      struct scope_logger {        const fc::optional<fc::ip::endpoint>& endpoint;        scope_logger(const fc::optional<fc::ip::endpoint>& endpoint) : endpoint(endpoint) { dlog("entering message_oriented_connection::send_message() for peer ${endpoint}", ("endpoint", endpoint)); }        ~scope_logger() { dlog("leaving message_oriented_connection::send_message() for peer ${endpoint}", ("endpoint", endpoint)); }      } send_message_scope_logger(remote_endpoint);#endif#endif      struct verify_no_send_in_progress {        bool& var;        verify_no_send_in_progress(bool& var) : var(var)        {          if (var)            elog("Error: two tasks are calling message_oriented_connection::send_message() at the same time");          assert(!var);          var = true;        }        ~verify_no_send_in_progress() { var = false; }      } _verify_no_send_in_progress(_send_message_in_progress);      try      {        size_t size_of_message_and_header = sizeof(message_header) + message_to_send.size;        if( message_to_send.size > MAX_MESSAGE_SIZE )           elog("Trying to send a message larger than MAX_MESSAGE_SIZE. This probably won't work...");        //pad the message we send to a multiple of 16 bytes        size_t size_with_padding = 16 * ((size_of_message_and_header + 15) / 16);        std::unique_ptr<char[]> padded_message(new char[size_with_padding]);        memcpy(padded_message.get(), (char*)&message_to_send, sizeof(message_header));        memcpy(padded_message.get() + sizeof(message_header), message_to_send.data.data(), message_to_send.size );        char* paddingSpace = padded_message.get() + sizeof(message_header) + message_to_send.size;        size_t toClean = size_with_padding - size_of_message_and_header;        memset(paddingSpace, 0, toClean);        _sock.write(padded_message.get(), size_with_padding);        _sock.flush();        _bytes_sent += size_with_padding;        _last_message_sent_time = fc::time_point::now();      } FC_RETHROW_EXCEPTIONS( warn, "unable to send message" );    }

        void remove( const Key& k, bool sync = false )        { try {           FC_ASSERT( is_open(), "Database is not open!" );           std::vector<char> kslice = fc::raw::pack( k );           ldb::Slice ks( kslice.data(), kslice.size() );           auto status = _db->Delete( ldb::WriteOptions(), ks );           if( status.IsNotFound() )           {             FC_THROW_EXCEPTION( fc::key_not_found_exception, "unable to find key ${key}", ("key",k) );           }           if( !status.ok() )           {               FC_THROW_EXCEPTION( db_exception, "database error: ${msg}", ("msg", status.ToString() ) );           }        } FC_RETHROW_EXCEPTIONS( warn, "error removing ${key}", ("key",k) ); }

        void store( const Key& k, const Value& v, bool sync = false )        { try {           FC_ASSERT( is_open(), "Database is not open!" );           std::vector<char> kslice = fc::raw::pack( k );           ldb::Slice ks( kslice.data(), kslice.size() );           auto vec = fc::raw::pack(v);           ldb::Slice vs( vec.data(), vec.size() );           auto status = _db->Put( ldb::WriteOptions(), ks, vs );           if( !status.ok() )           {               FC_THROW_EXCEPTION( db_exception, "database error: ${msg}", ("msg", status.ToString() ) );           }        } FC_RETHROW_EXCEPTIONS( warn, "error storing ${key} = ${value}", ("key",k)("value",v) ); }