/var/lib/jenkins/jobs/Skylark/workspace/base/context.hpp

Go to the documentation of this file.

#ifndef SKYLARK_CONTEXT_HPP
#define SKYLARK_CONTEXT_HPP

#include "../config.h"

#include "exception.hpp"
#include "../utility/randgen.hpp"

#include "boost/smart_ptr.hpp"
#include "boost/property_tree/ptree.hpp"
#include "boost/property_tree/json_parser.hpp"

namespace skylark { namespace base {

struct context_t {
    context_t (int seed, int counter=0) :
        _counter(counter),
        _seed(seed) {}

#if 0
    context_t (context_t&& ctxt) :
        _counter(std::move(ctxt._counter)), _seed(std::move(ctxt._seed))
    {}

    context_t(const context_t& other) {
        _seed    = other._seed;
        _counter = other._counter;
    }

    context_t& operator=(const context_t& other) {
        _seed    = other._seed;
        _counter = other._counter;
        return *this;
    }
#endif

    context_t (const boost::property_tree::ptree& json) {
        _seed = json.get<int>("seed");
        _counter = json.get<size_t>("counter");
    }

    boost::property_tree::ptree to_ptree() const {
        boost::property_tree::ptree pt;
        pt.put("skylark_object_type", "context");
        pt.put("skylark_version", VERSION);
        pt.put("seed", _seed);
        pt.put("counter", _counter);
        return pt;
    }


     template <typename Distribution>
     skylark::utility::random_samples_array_t<Distribution>
     allocate_random_samples_array(size_t size, Distribution& distribution) {
         skylark::utility::random_samples_array_t<Distribution>
             random_samples_array(_counter, size, _seed, distribution);
         _counter += size;
         return random_samples_array;
     }

    template <typename Distribution >
    std::vector<typename Distribution::result_type>
      generate_random_samples_array(size_t size,
        Distribution& distribution) {
        skylark::utility::random_samples_array_t<Distribution>
            allocated_random_samples_array(_counter, size, _seed, distribution);
        _counter += size;
        std::vector<typename Distribution::result_type> random_samples_array;
        try {
            random_samples_array.resize(size);
        } catch (std::bad_alloc ba) {
            SKYLARK_THROW_EXCEPTION (
                base::allocation_exception()
                    << base::error_msg(ba.what()) );
        }
        for(size_t i = 0; i < size; i++) {
            random_samples_array[i] = allocated_random_samples_array[i];
        }
        return random_samples_array;
    }


    skylark::utility::random_array_t allocate_random_array(size_t size) {
        skylark::utility::random_array_t random_array(_counter, size, _seed);
        _counter += size;
        return random_array;
    }


     int random_int() {
         skylark::utility::random_array_t random_array =
             allocate_random_array(1);
         int sample = random_array[0];
         return sample;
    }


    size_t get_counter() { return _counter; }

    friend boost::property_tree::ptree& operator<<(
            boost::property_tree::ptree &sk, const context_t &data);
private:

    size_t _counter;
    int _seed;
};

boost::property_tree::ptree& operator<<(boost::property_tree::ptree &sk,
                                        const context_t &data) {
        sk.put("sketch.context.seed", data._seed);
        sk.put("sketch.context.counter", data._counter);
        return sk;
}

} } 
#endif // SKYLARK_CONTEXT_HPP