inline bool operator == (range<char const*> const &value, range<char const*> const &other) { if (value.size() == other.size()) { return value.empty() ? true : strncmp(value.begin(), other.begin(), value.size()) == 0; } return false; }
template <typename Iter, typename Other> inline bool operator == (range<Iter> const &value, range<Other> const &other) { if (value.size() == other.size()) { return value.empty() ? true : std::equal(value.begin(), value.end(), other.begin()); } return false; }
inline range<Iter2_t> init_move ( const range<Iter2_t> & dest, const range<Iter1_t> & src) { //------------- static checking ------------------------------------------ typedef typename iterator_traits<Iter1_t>::value_type type1 ; typedef typename iterator_traits<Iter2_t>::value_type type2 ; static_assert ( std::is_same<type1, type2>::value, "Incompatible iterators\n"); //------------------------------- begin ---------------------------------- if ( src.size() == 0 ) return range<Iter2_t>(dest.first, dest.first); init_move(dest.first ,src.first, src.last ); return range<Iter2_t>(dest.first, dest.first + src.size()) ; };
void generic_par_for_wg(range<Dimensions> k_range, range<Dimensions> workgroup_size) { queue my_queue; // the product of all Dimensions e.g. 10*10*10 for {10,10,10} auto linr_size = k_range.size(), linwg_size = workgroup_size.size(); // these will simply have the group, local and global linear ids assigned to // them auto group_lin = buffer<int>(linr_size / linwg_size); auto loc_lin = buffer<int>(linr_size); auto gl_lin = buffer<int>(linr_size); my_queue.submit([&](handler &cgh) { auto group_lin_acc = group_lin.get_access<access::mode::write>(cgh); auto loc_lin_acc = loc_lin.get_access<access::mode::write>(cgh); auto gl_lin_acc = gl_lin.get_access<access::mode::read_write>(cgh); cgh.parallel_for_work_group<kernel_name>( nd_range<Dimensions>(k_range, workgroup_size), [=](group<Dimensions> group) { group_lin_acc[group.get_linear_id()] = group.get_linear_id(); group.parallel_for_work_item([=](h_item<Dimensions> tile) { loc_lin_acc[tile.get_global_linear_id()] = tile.get_local_linear_id(); gl_lin_acc[tile.get_global_linear_id()] = tile.get_global_linear_id(); }); }); }); auto loc_lin_out = loc_lin.get_access<access::mode::read>(); auto group_lin_out = group_lin.get_access<access::mode::read>(); auto gl_lin_out = gl_lin.get_access<access::mode::read>(); for (int i = 0; i < linr_size / linwg_size; ++i) { BOOST_CHECK(group_lin_out[i] == i); // group id } for (int i = 0; i < linr_size; ++i) { BOOST_CHECK(gl_lin_out[i] == i); // w1 global id BOOST_CHECK(loc_lin_out[i] == loc_lin_out[i] % linwg_size); // local id } /* We must wait for for the queue to finish as none of buffer's destruction is blocking. */ my_queue.wait(); }
void database::add(range key, range data) { assert(_db); struct slice sk, sv; sk.data = const_cast<char*>(key.begin()); sk.len = key.size(); sv.data = const_cast<char*>(data.begin()); sv.len = data.size(); if (::db_add(_db, &sk, &sv) == 0) { throw exception("error adding to ness backend"); } }
virtual std::size_t take (const range& data) { detail::dummy_input_take_impl (); typename range::value_type zero ( sound::sample_traits< typename sound::sample_type<range>::type >::zero_value ()); fill_frames (data, zero); return data.size (); }
void database::del(range key) { assert(_db); struct slice sk; sk.data = const_cast<char*>(key.begin()); sk.len = key.size(); ::db_remove(_db, &sk); }
__forceinline NodeRef operator() (const PrimRef* prims, const range<size_t>& set, const FastAllocator::CachedAllocator& alloc) const { size_t n = set.size(); size_t items = Primitive::blocks(n); size_t start = set.begin(); Primitive* accel = (Primitive*) alloc.malloc1(items*sizeof(Primitive),BVH::byteAlignment); typename BVH::NodeRef node = BVH::encodeLeaf((char*)accel,items); for (size_t i=0; i<items; i++) { accel[i].fill(prims,start,set.end(),bvh->scene); } return node; }
[[nodiscard]] inline size_t read(std::istream& Stream, const range<char*>& Buffer) { { const auto Exceptions = Stream.exceptions(); Stream.exceptions(Exceptions & ~(Stream.failbit | Stream.eofbit)); SCOPE_EXIT{ Stream.exceptions(Exceptions); }; Stream.read(Buffer.data(), Buffer.size()); if (!Stream.bad() && Stream.eof()) Stream.clear(); } return Stream.gcount(); }
range<byte*> read(const range<byte*>& buf) { zstream.avail_out = uInt(buf.size()); zstream.next_out = (Bytef*)buf.begin(); for(;zstream.avail_out != 0;){ if (zstream.avail_in == 0){ new_input_(); } auto res = ::inflate(&zstream, Z_NO_FLUSH); switch(res) { case Z_NEED_DICT: { if (dict.empty()) AIO_THROW(inflate_exception)("Need dictionary"); auto dic_err = inflateSetDictionary(&zstream, (Bytef*)dict.begin(), dict.size()); if (dic_err != Z_OK) AIO_THROW(inflate_exception)("Bad dictionary"); } case Z_OK: break; case Z_DATA_ERROR: AIO_THROW(inflate_exception)("Z_DATA_ERROR"); case Z_MEM_ERROR: AIO_THROW(inflate_exception)("Z_MEM_ERROR"); case Z_STREAM_END: uncompressed_size = zstream.total_out; return range<byte*>((buf.size() - zstream.avail_out) + buf.begin(), buf.end()); default: AIO_THROW(inflate_exception)("zlib internal error"); } } return range<byte*>(buf.end() - zstream.avail_out, buf.end()); }
std::string database::get(range key) { assert(_db); struct slice sk, sv; sk.data = const_cast<char*>(key.begin()); sk.len = key.size(); if (::db_get(_db, &sk, &sv) == 0) { throw exception("error reading from ness backend"); } // copy the data out std::string result(sv.data, sv.len); ::free(sv.data); return result; }
range<const byte*> write(const range<const byte*>& buf){ AIO_PRE_CONDITION(!finished); AIO_PRE_CONDITION(zstream.avail_in == 0); crc = crc32(buf, crc); zstream.next_in = (Bytef*)buf.begin(); zstream.avail_in = uInt(buf.size()); for(;zstream.avail_in != 0;){ if (zstream.avail_out ==0 ) new_buffer_(); switch (deflate(&zstream, Z_NO_FLUSH)){ case Z_OK: case Z_BUF_ERROR: break; default: AIO_THROW(deflate_exception)("deflate with Z_NO_FLUSH failed"); } } return range<const byte*>(buf.end(), buf.end()); }
static bool ProcessServiceModes(range<const wchar_t* const*> const Args, int& ServiceResult) { const auto& isArg = [](const wchar_t* Arg, string_view const Name) { return (*Arg == L'/' || *Arg == L'-') && equal_icase(Arg + 1, Name); }; if (Args.size() == 4 && IsElevationArgument(Args[0])) // /service:elevation {GUID} PID UsePrivileges { ServiceResult = ElevationMain(Args[1], std::wcstoul(Args[2], nullptr, 10), *Args[3] == L'1'); return true; } if (InRange(2u, Args.size(), 5u) && (isArg(Args[0], L"export"sv) || isArg(Args[0], L"import"sv))) { const auto Export = isArg(Args[0], L"export"sv); string strProfilePath(Args.size() > 2 ? Args[2] : L""), strLocalProfilePath(Args.size() > 3 ? Args[3] : L""), strTemplatePath(Args.size() > 4 ? Args[4] : L""); InitTemplateProfile(strTemplatePath); InitProfile(strProfilePath, strLocalProfilePath); Global->m_ConfigProvider = new config_provider(Export? config_provider::mode::m_export : config_provider::mode::m_import); ServiceResult = !ConfigProvider().ServiceMode(Args[1]); return true; } if (InRange(1u, Args.size(), 3u) && isArg(Args[0], L"clearcache"sv)) { string strProfilePath(Args.size() > 1 ? Args[1] : L""); string strLocalProfilePath(Args.size() > 2 ? Args[2] : L""); InitProfile(strProfilePath, strLocalProfilePath); config_provider::ClearPluginsCache(); ServiceResult = 0; return true; } return false; }
vector_range(VectorType & v, range const & entry_range) : base_type(v.handle(), entry_range.size(), v.start() + v.stride() * entry_range.start(), v.stride()) {}
virtual std::size_t put (const range& data) { detail::dummy_output_put_impl (); return data.size (); }
void DialogBuilder::AddButtons(range<const lng*> const Buttons, size_t const OkIndex, size_t const CancelIndex) { base::AddButtons(static_cast<int>(Buttons.size()), reinterpret_cast<const int*>(Buttons.data()), static_cast<int>(OkIndex), static_cast<int>(CancelIndex)); }
matrix_range(matrix_range<MatrixType> const & A, range const & row_range, range const & col_range) : base_type(const_cast<handle_type &>(A.handle()), row_range.size(), row_range.start() * A.stride1() + A.start1(), A.stride1(), A.internal_size1(), col_range.size(), col_range.start() * A.stride2() + A.start2(), A.stride2(), A.internal_size2(), A.row_major()) {}
inline bool operator > (range<char const*> const &value, range<char const*> const &other) { return (!value.empty() && !other.empty()) ? (strncmp(value.begin(), other.begin(), std::max(value.size(), other.size())) > 0) : !value.empty(); }
vector_range(vector_range<VectorType> const & v, range const & entry_range) : base_type(const_cast<handle_type &>(v.handle()), entry_range.size(), v.start() + v.stride() * entry_range.start(), v.stride()) {}
uint32_t crc32(range<const byte*> src, uint32_t crc /* = crc32_init() */){ return ::crc32(crc, (const Bytef*)src.begin(), (uInt)src.size()); }