C++ row类代码示例

	void update(int x, int y, ll v) {
		int m = (s+e)/2;
		if (s == e) val->update(y, v);
		else {
			if (x > m) {
				if (r == NULL) r = new row(x, x);
				else if (!r->inrange(x)) {
					row* tmp = r;
					pi nxt = lca(s, e, r->s, r->e, x);
					r = new row(nxt.first, nxt.second);
					if (tmp->e <= (r->s + r->e)/2 ) r->l = tmp;
					else r->r = tmp;
					r->val = tmp->val->clone();
				}
				r->update(x, y, v);
			}
			else {
				if (l == NULL) l = new row(x, x);
				else if (!l->inrange(x)) {
					row* tmp = l;
					pi nxt = lca(s, e, l->s, l->e, x);
					l = new row(nxt.first, nxt.second);
					if (tmp->e <= (l->s + l->e)/2 ) l->l = tmp;
					else l->r = tmp;
					l->val = tmp->val->clone();
				}
				l->update(x, y, v);
			}
			ll rv = 0;
			if (l != NULL) rv = __gcd(l->val->query(y, y), rv);
			if (r != NULL) rv = __gcd(r->val->query(y, y), rv);
			val->update(y, rv);
		}
	}

RINGING_USING_NAMESPACE
RINGING_USING_STD

bool is_cyclic_le( const row &lh, int hunts )
{
  const int n( lh.bells() - hunts );

  // Rounds doesn't count...
  if ( lh[hunts] == hunts ) 
    return false;

  {
    for ( int i=0; i<hunts; ++i )
      if ( lh[i] != i )
	return false;
  }

  {
    for ( int i=hunts+1; i<lh.bells(); ++i )
      if ( (lh[i] - hunts) % n != (lh[i-1] + 1 - hunts) % n )
	return false;
  }

  return true;
}

void
config_reader::parse_debug_line(row<long>& dbg_line, ch_string& str_ln){
#ifdef FULL_DEBUG
	bj_ostream& os = bj_out;
	MARK_USED(os);
	
	const char* pt_in = str_ln.c_str();

	dbg_line.clear();
	
	long num_ln = 0;

	if(isalnum(*pt_in)){
		skip_whitespace(pt_in, num_ln);
		while(isdigit(*pt_in) || isspace(*pt_in)){
			if(isspace(*pt_in)){
				pt_in++;
				continue;
			}
			//os << pt_in << "$\n";
			
			long val = parse_long(pt_in, num_ln); 
			//skip_whitespace(pt_in, num_ln);
	
			dbg_line.push(val);
		}
	} else {
		skip_line(pt_in, num_ln);
	}
#endif
}

void
read_batch_instances(ch_string file_nm, row<satex_entry>& f_insts){
	bj_ostream& os = bj_out;

	std::ifstream in_stm;

	in_stm.open(file_nm.c_str(), std::ios::binary);
	if(! in_stm.good() || ! in_stm.is_open()){
		os << "NO " << file_nm << " FILE FOUND." << bj_eol;
		return;
	}

	ch_string str_ln;
	long num_ln = 0;

	f_insts.clear();

	while(! in_stm.eof()){
		std::getline(in_stm, str_ln);
		num_ln++;

		if(! str_ln.empty()){
			satex_entry& n_inst = f_insts.inc_sz();
		
			//os << "Lei:<<" << str_ln << ">>" << bj_eol;
			n_inst.parse_entry(str_ln, num_ln);
		}
	}
	in_stm.close();
}

            /*!
             * initializes with values from a database row
             */
            void record::init(const row &values) {
                if (!values.is_valid()) {
                    return;
                }

                for (auto v = values.begin(); v != values.end(); ++v) {
                    set(v.name(), v->value());
                }

                on_record_init(values);
            }

row check_solution(const matrix &A , const row &X, const row &B) {
    row diff;
    diff.resize(B.size());
    int size = B.size();
    for(int i = 0; i < size; i++) {
        double temp = 0;
        for(int j = 0; j < size; j++) {
            temp += A[i][j] * X[j];
        }
        diff[i] = temp - B[i];
    }
    return diff;
}

int table::edit_row(const row &old_row, row new_row) {
  int count = 0;
  // add column data that is not included to new_row (still enables writing empty values)
  for (int i=0;i<_Tstruct.size();i++) {
    if (!new_row.is_defined(new_row[_Tstruct[i].name])) new_row.add(_Tstruct[i], old_row[_Tstruct[i].name]);
  }
  
  if (old_row.id >= 0) {
    _fdata->seek(old_row.id*_row_size);
    _write_row(new_row._data);
    count++;
    
    // if old row's key value has changed then update the key entry (insde _keys)
    if (old_row[_key.name] != new_row[_key.name]) {
      for (int i=0;i<_keys.size();i++) {
        if (_keys[i].row_id == old_row.id) {
          _keys[i].data = new_row[_key.name]; // change key entry data to represent change
          break;
        }
      }
    }
    
  }
  else {
    query q;
    predicate p;

    for (int i=0;i<_Tstruct.size();i++) p.And( equalto(_Tstruct[i], old_row[_Tstruct[i].name]) ); // build predicate matching the row

    q.where(p);
    vector<row> results = select(q);
    for (int i=0;i<results.size();i++) {
      _fdata->seek(results[i].id * _row_size);
      _write_row(new_row._data);
      count++;
      
      // if old row's key value has changed then update the key entry (insde _keys)
      if (old_row[_key.name] != new_row[_key.name]) {
        for (int i=0;i<_keys.size();i++) {
          if (_keys[i].row_id == results[i].id) {
            _keys[i].data = new_row[_key.name]; // change key entry data to represent change
            break;
          }
        }
      }
      
    }
  }
  return count;
}

    static bool fetch(const row& res, ColOrName col_or_name, std::unique_ptr<T>& v)
    {
        T tmp;
        if (res.fetch(col_or_name, tmp))
            v.reset(new T(std::move(tmp)));

        return true;
    }

void table::delete_row(const row& del_row) {
  if (del_row.id >= 0) delete_row(del_row.id);
  else {
    predicate p;
    for (int i=0;i<_Tstruct.size();i++) if (del_row.is_defined(_Tstruct[i])) p.And( equalto(_Tstruct[i], del_row[_Tstruct[i]]) ); // build predicate matching the row
    delete_row(select(query().where(p)));
  }
}

    static bool fetch(const row& res, ColOrName col_or_name, boost::posix_time::ptime& v)
    {
        std::tm tm_struct;
        bool ret = res.fetch(col_or_name, tm_struct);
        if (ret)
            v = boost::posix_time::ptime_from_tm(tm_struct);

        return ret;
    }

    void debugEcho(const row& row_)
    {
        std::ostringstream doc;
        doc << "<row>" << std::endl;
        for(std::size_t i = 0; i != row_.size(); ++i)
        {
            const column_properties & props = row_.get_properties(i);

            doc << "   " << props.get_name();

            switch(props.get_data_type())
            {
            case dt_string:
                doc << "-string:" << row_.get<std::string>(i);
                break;
            case dt_double:
                doc << "-double:" << row_.get<double>(i);
                break;
            case dt_integer:
                doc << "-integer:" << row_.get<int>(i);
                break;
            case dt_unsigned_long:
                doc << "-ulong:" << row_.get<unsigned long>(i);
                break;
            case dt_long_long:
                doc << "-long long:" << row_.get<long long>(i);
                break;
            case dt_date:
                std::tm when = row_.get<std::tm>(i);
                doc << "-date:" << asctime(&when);
                break;
            }

            doc << std::endl;
        }
        doc << "</row>" << std::endl;

        std::cout << doc.str();
    }

bool	ck_sorted_sorsets(row<sorset*>& rr_srss, cmp_srs_func_t cmp_fn){
	std::ostream& os = std::cout;

	long the_sz = rr_srss.size();
	if(the_sz == 0){ return true; }
	sorset* lst = rr_srss[0];
	for(row_index ii = 1; ii < the_sz; ii++){
		sorset* srs = rr_srss[ii];
		if((*cmp_fn)(lst, srs) > 0){
			os << "ck_sorted_sorsets_FAILED_with" << std::endl;
			os << "srs_1=" << lst << std::endl; 	// prt_sorset
			os << "srs_2=" << srs << std::endl;   // prt_sorset
			return false;
		}
		lst = srs;
	}
	return true;
}

void
sql::write_extrinsic_comparison(relation r, const abstract_column_sequence &lhs, const row &rhs) {
    vector<thunk> lhs_thunks;
    vector<thunk> rhs_thunks;
    lhs.for_each_column([&](const column_mapper &c) {
        lhs_thunks.push_back([&](sql &cmd) {
            cmd.write_evaluation(c);
        });

        const string placeholder = next_placeholder();
        rhs_thunks.push_back([=](sql &cmd) {
            write(placeholder);
        });
        attach_cell(*rhs.find_cell(c.name()));
    });

    write_lexicographic_comparison(r, lhs_thunks, rhs_thunks);
}

void
sql::write_values(
    const abstract_mapper_base &value_mapper,
    const row &data,
    optional<column_id> excluded
) {
    write(" VALUES (");
    comma_separated_list_scope list_scope(*this);
    value_mapper.for_each_persistent_column(
        [&](const persistent_column_mapper &p) {
            if (p.id() != excluded) {
                list_scope.start_item();
                write_value(*data.find_cell(p.name()));
            }
        }
    );
    write(")");
}

row solve_progon(const matrix &A,const row &B) {
    row P, Q, ans;
    int N = B.size();
    P.resize(N);
    Q.resize(N);
    ans.resize(N);
    P[0] = - A[0][1] / A[0][0];
    Q[0] = B[0]/A[0][0];
    //Pr9moy xod
    for(int i = 1; i < N; i++) {
        P[i] = A[i][i + 1]/(-A[i][i] - A[i][i - 1]*P[i-1]);
        Q[i] = (A[i][i - 1] * Q[i - 1] - B[i]) / (-A[i][i] - A[i][i-1] * P[i - 1]);
    }

    //Obratniy xod
    ans[N - 1] = (A[N-1][N-2] * Q[N-2] - B[N-1]) / (-A[N-1][N-1] - A[N-1][N-2] * P[N-2]);
    for(int i = N - 2; i >= 0; --i) {
        ans[i] = P[i] * ans[i+1] + Q[i];
    }
    return ans;
}