コード例 #1
0
    binary_expression_sentence_t(name_t         verb,
                                 const array_t& subject_expression,
                                 const array_t& dirobj_expression) :
        verb_m(verb),
        subject_expression_m(subject_expression),
        dirobj_expression_m(dirobj_expression)
    {
        if (subject_expression_m == array_t())
            throw std::runtime_error("Subject expression cannot be empty");

        if (dirobj_expression_m == array_t())
            throw std::runtime_error("Direct object expression cannot be empty");
    }
コード例 #2
0
ファイル: accessor.cpp プロジェクト: flachesis/JSON-CC
member_of&
member_of::operator[](std::size_t offset)
{
  if(v_ptr_) {
    if( 0 == v_ptr_->which() ) 
      *v_ptr_ = array_t();

    if(ARRAY_WHICH == v_ptr_->which()) {
      v_ptr_ = &(boost::get<array_t>(*v_ptr_)[offset]);
    } else {
      v_ptr_ = 0;
    }
  }
  return *this;
}
コード例 #3
0
ファイル: accessor.cpp プロジェクト: yangacer/JSON-CC
member_of&
member_of::operator()(std::size_t offset)
{
  JSON_ACCESS_TRACKING(offset);
  if(v_ptr_) {
    if( 0 == v_ptr_->which() ) 
      *v_ptr_ = array_t();

    if(ARRAY_WHICH == v_ptr_->which()) {
      array_t &a = boost::get<array_t>(*v_ptr_);
      if(a.size() <= offset)
         a.resize(offset+1);
      v_ptr_ = &(a[offset]);
    } else {
      v_ptr_ = 0;
    }
  }
  return *this;
}
コード例 #4
0
int
drake_init(task_t *task, void* aux)
{
	link_t *link;
	array_t(int) *tmp;
	size_t input_buffer_size, input_size, i;

	// The following makes tasks having no predecessor to load input data
	// and make a new input link that links to no task but that holds the
	// data to be sorted and merged

	// Fetch arguments and only load data if an input filename is given
	args_t *args = (args_t*)aux;
	if(args->argc > 0)
	{
		input_filename = ((args_t*)aux)->argv[0];

		// Read only the number of elements in input
		tmp = pelib_array_preloadfilenamebinary(int)(input_filename);
		if(tmp != NULL)
		{
			// Read the number of elements to be sorted
			input_size = pelib_array_length(int)(tmp);
			// No need of this array anymore
			pelib_free_struct(array_t(int))(tmp);

			// If the task has no predecessor (is a leaf)
			// then we should build input links that hold
			// input data.
			if(pelib_array_length(link_tp)(task->pred) == 0)
			{
				// Destroy the input link array for this task
				// It will be replaced with an array of two link
				// each holding the data subset to be sorted and
				// merged
				pelib_free(array_t(link_tp))(task->pred);

				// Initialize a new input link array that can hold two input links
				task->pred = pelib_alloc_collection(array_t(link_tp))(2);

				// Calculate the number of elements each input links of this task will load, that is:
				// The total number of elements divided by the number of leaves. Here, we assume a
				// balanced binary tree.
				input_buffer_size = input_size / ((drake_task_number() + 1) / 2) / 2;

				// Let's build two new input links and make them load data
				for(i = 0; i < 2; i++)
				{
					// Allocation
					link = (link_t*)malloc(sizeof(link_t));

					// The new input link doesn't have any producer task
					link->prod = NULL;
					// The task being initialized is the consumer end of the link
					link->cons = task;
	
					// Load the portion of input file that corresponds to the leaf task. Since fifos have no implementation
					// for I/Os, we load an array and then turn it to a fifo
					link->buffer = (cfifo_t(int)*)pelib_array_loadfilenamewindowbinary(int)(input_filename, 2 * input_buffer_size * (task->id - ((drake_task_number() + 1) / 2)) + input_buffer_size * i, input_buffer_size);
					// Turn array to fifo
					link->buffer = pelib_cfifo_from_array(int)((array_t(int)*)link->buffer);

					// Finally, add the new link to the input links array
					pelib_array_append(link_tp)(task->pred, link);
				}
			}