C++ ptree::put_child方法代码示例

    void operator()( boost::property_tree::ptree & s, object_type & obj ) {
        boost::property_tree::ptree tr;
        state_getter< typename object_type::trait_space_type > tr_logger;
        tr_logger( tr, obj.m_trait_space );

        boost::property_tree::ptree fr;
        state_getter< typename object_type::free_space_type > free_logger;
        free_logger( fr, obj.m_free_space );

        boost::property_tree::ptree fx, alls;
        state_getter< typename object_type::allele_type > all_logger;
        all_logger( fx, obj.m_fixed );
        all_logger( alls, obj.m_allele_space );

        boost::property_tree::ptree c_pop;
        state_getter< typename object_type::sequence_space_type > pop_logger;
        pop_logger( c_pop, *(obj.m_pop.back()) );

        boost::property_tree::ptree ft;
        clotho::utility::add_value_array( ft, obj.m_fits.back()->begin(), obj.m_fits.back()->end() );
        c_pop.put_child( "fitness", ft );

        s.put_child( "free_space", fr );
        s.put_child( "allele_space", alls );
        s.put_child( "trait_space", tr );
        s.put_child( "fixed_alleles", fx );

        s.put_child( "child", c_pop );
    }

    void operator()( boost::property_tree::ptree & s, object_type & obj ) {
        boost::property_tree::ptree tr;
        state_getter< typename object_type::trait_space_type > tr_logger;
        tr_logger( tr, obj.m_trait_space );

        boost::property_tree::ptree ph;
        state_getter< typename object_type::phenotype_eval_type > pheno_logger;
        pheno_logger( ph, obj.m_pheno );

        boost::property_tree::ptree fr;
        state_getter< typename object_type::free_space_type > free_logger;
        free_logger( fr, obj.m_free_space );

        boost::property_tree::ptree fx, alls;
        state_getter< typename object_type::allele_type > all_logger;
        all_logger( fx, obj.m_fixed );
        all_logger( alls, obj.m_allele_space );

//        boost::property_tree::ptree c_pop;
//        state_getter< typename object_type::sequence_space_type > pop_logger;
//        pop_logger( c_pop, *(obj.m_child) );

        s.put_child( "phenotypes", ph );
        s.put_child( "free_space", fr );
        s.put_child( "allele_space", alls );
        s.put_child( "trait_space", tr );
        s.put_child( "fixed_alleles", fx );

//        s.put_child( "child", c_pop );
    }

    void operator()( boost::property_tree::ptree & s, object_type & obj ) {

        boost::property_tree::ptree al;
        state_getter< typename object_type::allele_type > a_log;
        a_log( al, obj.getAlleleSpace() );

        boost::property_tree::ptree ft;
        clotho::utility::add_value_array( ft, obj.fitness_begin(), obj.fitness_end() );

        s.put_child( "alleles" , al );
        s.put_child( "fitness", ft );
    }

    void recordResults( boost::property_tree::ptree & log ) {

        typedef ac::accumulator_set< size_type, ac::stats< ac::tag::min, ac::tag::mean, ac::tag::max, ac::tag::variance, ac::tag::median, ac::tag::count > > accumulator_t;

        accumulator_t   col_accum, row_accum;

        boost::property_tree::ptree dist, lfreq;

        // maximum frequency for an allele is bounded by the number of sequences (rows) in the population
        std::vector< size_type > freq( m_indices.size(), 0 );

        // evaluate allele (column) statistics
        size_type i = 0;
        while( i < m_column_margin_size ) {
            size_type v = m_column_margin[i++];
            clotho::utility::add_value_array( dist, v );
            col_accum( v );
            freq[v]++;
        }


        clotho::utility::add_value_array(lfreq, freq.begin(), freq.end() );

        log.put_child( "distribution", dist );
        log.put_child( "frequency_distribution", lfreq );

        log.put( "stats.sequences_per_allele.min", ac::min( col_accum ) );
        log.put( "stats.sequences_per_allele.max", ac::max( col_accum ) );
        log.put( "stats.sequences_per_allele.mean", ac::mean( col_accum ) );
        log.put( "stats.sequences_per_allele.median", ac::median( col_accum ) );
        log.put( "stats.sequences_per_allele.variance", ac::variance( col_accum ) );
        log.put( "stats.sequences_per_allele.total", ac::count(col_accum) );

        // evaluate sequence (row) statistics
        i = 0;
        while( i < m_row_margin_size ) {
            if( m_indices.test(i) ) {
                row_accum( m_row_margin[ i ] );
            }
            ++i;
        }

        log.put( "stats.alleles_per_sequence.min", ac::min( row_accum ) );
        log.put( "stats.alleles_per_sequence.max", ac::max( row_accum ) );
        log.put( "stats.alleles_per_sequence.mean", ac::mean( row_accum ) );
        log.put( "stats.alleles_per_sequence.median", ac::median( row_accum ) );
        log.put( "stats.alleles_per_sequence.variance", ac::variance( row_accum ) );
        log.put( "stats.alleles_per_sequence.total", ac::count(row_accum) );
    }

	bool upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a)
	{
		auto result (false);
		switch (version_a)
		{
			case 1:
			{
				rai::account account;
				account.decode_account (tree_a.get<std::string> ("account"));
				tree_a.erase ("account");
				tree_a.put ("account", account.to_account ());
				tree_a.erase ("version");
				tree_a.put ("version", "2");
				result = true;
			}
			case 2:
			{
				boost::property_tree::ptree rpc_l;
				rpc.serialize_json (rpc_l);
				tree_a.put ("rpc_enable", "false");
				tree_a.put_child ("rpc", rpc_l);
				tree_a.erase ("version");
				tree_a.put ("version", "3");
				result = true;
			}
			case 3:
			{
				auto opencl_enable_l (tree_a.get_optional<bool> ("opencl_enable"));
				if (!opencl_enable_l)
				{
					tree_a.put ("opencl_enable", "false");
				}
				auto opencl_l (tree_a.get_child_optional ("opencl"));
				if (!opencl_l)
				{
					boost::property_tree::ptree opencl_l;
					opencl.serialize_json (opencl_l);
					tree_a.put_child ("opencl", opencl_l);
				}
				tree_a.put ("version", "4");
				result = true;
			}
			case 4:
				break;
			default:
				throw std::runtime_error ("Unknown qt_wallet_config version");
		}
		return result;
	}

bool rai_daemon::daemon_config::upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a)
{
	auto result (false);
	switch (version_a)
	{
	case 1:
	{
		auto opencl_enable_l (tree_a.get_optional <bool> ("opencl_enable"));
		if (!opencl_enable_l)
		{
			tree_a.put ("opencl_enable", "false");
		}
		auto opencl_l (tree_a.get_child_optional ("opencl"));
		if (!opencl_l)
		{
			boost::property_tree::ptree opencl_l;
			opencl.serialize_json (opencl_l);
			tree_a.put_child ("opencl", opencl_l);
		}
		tree_a.put ("version", "2");
		result = true;
	}
	case 2:
		break;
	default:
		throw std::runtime_error ("Unknown daemon_config version");
	}
	return result;
}

void merge( boost::property_tree::ptree& pt, const boost::property_tree::ptree& updates )
{
   BOOST_FOREACH( auto& update, updates )
   {
	   printf("boost foreach\n");
      pt.put_child( update.first, update.second );
   }

    void init( size_t aN, boost::property_tree::ptree & config ) {
        size_t pN = 0;
        if( m_pop_growth ) {
            pN = m_pop_growth->operator()( pN, m_generation );
        }

        boost::property_tree::ptree lconfig;

        lconfig = config.get_child( "generations", lconfig);

        unsigned int intermed = lconfig.get< unsigned int>( "intermediates", 0 );

        lconfig.put("intermediates", intermed );
        config.put_child( "generations", lconfig );

        for( unsigned int i = 0; i < intermed + 2; ++i ) {
            sequence_space_type * ss = new sequence_space_type();
            m_pop.push_back( ss );

            fitness_type * f = new fitness_type( config );

            assert( f->isEmpty() );

            m_fits.push_back( f );

            mutation_pool_type * p = new mutation_pool_type();
            m_mut_pools.push_back( p );

            mutation_distribution_type * d = new mutation_distribution_type();
            m_mut_dists.push_back( d );
        }


        if( m_thread_count.m_tc > 0 ) {
            m_worker_rng = new random_engine_type * [ m_thread_count.m_tc ];
            m_worker_off_gens = new offspring_generator_type * [ m_thread_count.m_tc ];

            for( int offset = 0; offset < m_thread_count.m_tc; ++offset ) {
                m_worker_rng[ offset ] = new random_engine_type( (*m_rand)());
                m_worker_off_gens[ offset ] = new offspring_generator_type( m_worker_rng[ offset ], &m_allele_space, &m_trait_space, config );
            }
        }

#ifdef USE_ROW_VECTOR
        m_pop1.getSequenceSpace().fill_empty();
        m_pop1.getSequenceSpace().finalize();
#endif // USE_ROW_VECTOR
        ++m_generation;
    }

    void buildTimeVectorLog( boost::property_tree::ptree & log, time_map & times ) {
        for( typename time_map::iterator it = times.begin(); it != times.end(); it++ ) {
            boost::property_tree::ptree starts, stops;

            for( typename time_vector::iterator iter = it->second.begin(); iter != it->second.end(); ++iter ) {
                clotho::utility::add_value_array( starts, iter->first );
                clotho::utility::add_value_array( stops, iter->second );
            }

            boost::property_tree::ptree tmp;
            tmp.put_child( "start", starts );
            tmp.put_child( "stop", stops );

            log.put_child( it->first, tmp );
        }
    }

    quadratic_fitness_parameter( boost::property_tree::ptree & config ) :
        m_scale( 1.0 ) {
        boost::property_tree::ptree fblock;
        fblock = config.get_child( FITNESS_BLOCK_K, fblock );
        
        boost::property_tree::ptree pblock;
        pblock = fblock.get_child( PARAM_K, pblock );

        m_scale = pblock.get< RealType >( SCALE_K, m_scale );
        
        pblock.put( SCALE_K, m_scale );

        fblock.put( NAME_K, QUAD_NAME );
        fblock.put_child( PARAM_K, pblock );

        config.put_child( FITNESS_BLOCK_K, fblock );
    }

    void record( boost::property_tree::ptree & xo, boost::property_tree::ptree & mt, boost::property_tree::ptree & ph, boost::property_tree::ptree & fx ) {

        boost::property_tree::ptree xo_begins, xo_ends;
        buildTimeLog( xo_begins, xo_ends, m_crossover_times );
        xo.put_child( "start", xo_begins);
        xo.put_child( "stop", xo_ends);

        boost::property_tree::ptree mt_begins, mt_ends;
        buildTimeLog( mt_begins, mt_ends, m_mutate_times );
        mt.put_child( "start", mt_begins);
        mt.put_child( "stop", mt_ends);

        boost::property_tree::ptree ph_begins, ph_ends;
        buildTimeLog( ph_begins, ph_ends, m_phenotype_times );
        ph.put_child( "start", ph_begins);
        ph.put_child( "stop", ph_ends);

        boost::property_tree::ptree fx_begins, fx_ends;
        buildTimeLog( fx_begins, fx_ends, m_fixed_times );
        fx.put_child( "start", fx_begins);
        fx.put_child( "stop", fx_ends);
    }

void NetworkManagerHandler::wifiScan(boost::property_tree::ptree &responsePt)
{
    std::vector<WirelessManager::ScanResult> scanResult = qpcrApp.wirelessManager()->scanResult();
    boost::property_tree::ptree array;

    for (const WirelessManager::ScanResult &result: scanResult)
    {
        boost::property_tree::ptree ptree;
        ptree.put("ssid", result.ssid);
        ptree.put("quality", result.quality);
        ptree.put("siganl_level", result.siganlLevel);

        switch (result.encryption)
        {
        case WirelessManager::ScanResult::WepEncryption:
            ptree.put("encryption", "wep");
            break;

        case WirelessManager::ScanResult::Wpa1Ecryption:
            ptree.put("encryption", "wpa1");
            break;

        case WirelessManager::ScanResult::Wpa2PSKEcryption:
            ptree.put("encryption", "wpa2 psk");
            break;

        case WirelessManager::ScanResult::Wpa28021xEcryption:
            ptree.put("encryption", "wpa2 802.1x");
            break;

        default:
            ptree.put("encryption", "none");
            break;
        }

        array.push_back(std::make_pair("", ptree));
    }

    responsePt.put_child("scan_result", array);
}

    void parse_configuration( boost::property_tree::ptree & config ) {
        boost::property_tree::ptree lconfig;

        if( config.get_child_optional( "mutation" ) != boost::none ) {
            lconfig = config.get_child( "mutation" );
        }

        if( lconfig.get_child_optional( "mutation_per_sequence" ) == boost::none ) {
            lconfig.put("mutation_per_sequence", m_mutation_rate );
        } else {
            m_mutation_rate = lconfig.get< real_type >( "mutation_per_sequence", m_mutation_rate );
        }

        if( lconfig.get_child_optional( "rng.seed" ) != boost::none ) {
            m_seed = lconfig.get< seed_type >( "rng.seed", m_seed );
        }

        if( m_seed == 0 ) {
            m_seed = clotho::utility::clock_type::now().time_since_epoch().count();
            lconfig.put("rng.seed", m_seed );
        }

        config.put_child( "mutation", lconfig );
    }

 void to_ptree(const details::global_kernel_state_t &state, ::boost::property_tree::ptree &ptree, int level)
 {
   {
     ::boost::property_tree::ptree init;
     state.initialization_parameters_ref().to_ptree(init);
     ptree.put_child("initialization", init);
   }
   {
     ::boost::property_tree::ptree last_collect;
     last_collect.put("clear_mark_time", ::std::to_string(state.clear_mark_time_span().count()));
     last_collect.put("mark_time", ::std::to_string(state.mark_time_span().count()));
     last_collect.put("sweep_time", ::std::to_string(state.sweep_time_span().count()));
     last_collect.put("notify_time", ::std::to_string(state.notify_time_span().count()));
     last_collect.put("total_time", ::std::to_string(state.total_collect_time_span().count()));
     ptree.put_child("last_collect", last_collect);
   }
   {
     ::boost::property_tree::ptree slab_allocator;
     state._internal_slab_allocator().to_ptree(slab_allocator, level);
     ptree.put_child("slab_allocator", slab_allocator);
   }
   {
     ::boost::property_tree::ptree cgc_allocator;
     state._internal_allocator().to_ptree(cgc_allocator, level);
     ptree.put_child("cgc_allocator", cgc_allocator);
   }
   {
     ::boost::property_tree::ptree gc_allocator;
     state.gc_allocator().to_ptree(gc_allocator, level);
     ptree.put_child("gc_allocator", gc_allocator);
   }
   {
     ::boost::property_tree::ptree packed_allocator;
     state._bitmap_allocator().to_ptree(packed_allocator, level);
     ptree.put_child("packed_allocator", packed_allocator);
   }
 }

    void getPerformanceResults( boost::property_tree::ptree & log ) {

        for( int i = 0; i < m_thread_count.m_tc; ++i ) {
            std::ostringstream oss;
            oss << "W_" << (i + 1);

            boost::property_tree::ptree mut, xo, ph, fx, ft;
            m_worker_off_gens[ i ]->record( xo, mut, ph, fx, ft );
            
            log.put_child( "performance.mutate." + oss.str(), mut );
            log.put_child( "performance.crossover." + oss.str(), xo );
            log.put_child( "performance.fixed." + oss.str(), fx );
            log.put_child( "performance.phenotype." + oss.str(), ph );
            log.put_child( "performance.fitness." + oss.str(), ft );
        }

        boost::property_tree::ptree mut, xo, ph, fx, ft;
        m_main_off_gen.record( xo, mut, ph, fx, ft );
        
        log.put_child( "performance.mutate.main", mut );
        log.put_child( "performance.crossover.main", xo );
        log.put_child( "performance.fixed.main", fx );
        log.put_child( "performance.phenotype.main", ph );
        log.put_child( "performance.fitness.main", ft );

        log.put_child( "memory.free_count", free_sizes );
        log.put_child( "memory.variable_count", var_sizes );
        log.put_child( "memory.fixed_count", fixed_sizes );
    }