CachedPalette CachedPalette::fromColors(std::initializer_list<Color>v) { CachedPalette pal(v.size()); auto it = v.begin(); for (int i = 0; i < pal.levels(); i++) pal[i] = *(it++); return pal; }
void test ( const std::initializer_list<T> &vals ) { typedef std::dynarray<T> dynA; dynA d1 ( vals ); assert ( d1.size () == vals.size() ); assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ())); }
Matrix::Matrix(std::initializer_list<double> v) : nr(v.size()), nc(1) { data = new double [nr]; int i = 0; for (double d : v) data[i++] = d; }
bool setHeader(std::initializer_list<std::string> list) { if (list.size() != Columns) { return false; } header.insert(header.begin(), list); return true; }
double comb(std::initializer_list<double> values) { double sum = 0.0; for (double value: values) { sum += value; } return (sum/values.size()); }
void IGraphicObject::mFunction_AddVertices2D(NOISE_GRAPHIC_OBJECT_TYPE buffType, std::initializer_list<NVECTOR2> vertexList, std::initializer_list<NVECTOR4> colorList, std::initializer_list<NVECTOR2> texcoordList) { N_SimpleVertex tmpVertex; auto vertexIter = vertexList.begin(); auto colorIter = colorList.begin(); auto texcoordIter = texcoordList.begin(); //construct a N_SimpleVertex for (UINT i = 0;i < vertexList.size();i++) { tmpVertex = { NVECTOR3(vertexIter->x+m_pBaseScreenSpacePosOffset->x,vertexIter->y + m_pBaseScreenSpacePosOffset->y,0.0f), *colorIter++, *texcoordIter++ }; vertexIter++; m_pVB_Mem[buffType]->push_back(tmpVertex); } //now it is allowed to update because of modification mCanUpdateToGpu[buffType] = TRUE; }
ProtocolDescriptorTestNode::ProtocolDescriptorTestNode(QString name, std::initializer_list<ProtocolDescriptorTestNode> init) { qDebug() << "*** CONSTRUCTOR CALLED - 2 *** "; qDebug() << init.size(); for(ProtocolDescriptorTestNode x : init) { qDebug() << x.name << x.id; } }
Set<T>::Set(std::initializer_list<T> args) : map() { reserve(args.size()); for (const auto &elm : args) { insert(elm); } }
UIntVector::UIntVector(const std::initializer_list<unsigned int>& list) : count(list.size()), max_size(1 << static_cast<int>(ceil(log2(count)))), data(new unsigned int[max_size]) { size_t i; std::initializer_list<unsigned int>::iterator item; for(i = 0, item = list.begin(); item != list.end(); ++i, ++item) { data[i] = *item; } }
// Constructor with initializer list DNA::DNA(const std::initializer_list<unsigned char> inputList) { dataSize = inputList.size(); // Initialize genes dataGenes = (unsigned char*) malloc(dataSize * sizeof(unsigned char)); std::memcpy(dataGenes, inputList.begin(), dataSize); }
std::string format(const char* fmt, std::initializer_list<Printable> values) { std::stringstream ss; while (*fmt) { auto next = strchr(fmt, '%'); // emit the rest of the format string if there are no more percents if (!next) { ss << fmt; break; } // emit everything up to the next percent ss.write(fmt, next - fmt); ++next; REALM_ASSERT(*next); // %% produces a single escaped % if (*next == '%') { ss << '%'; fmt = next + 1; continue; } REALM_ASSERT(isdigit(*next)); // The const_cast is safe because stroul does not actually modify // the pointed-to string, but it lacks a const overload auto index = strtoul(next, const_cast<char**>(&fmt), 10) - 1; REALM_ASSERT(index < values.size()); (values.begin() + index)->print(ss); } return ss.str(); }
std::shared_ptr<cainteoir::buffer> zip_archive::read(const char *aFilename) const { std::string filename = aFilename; auto entry = data.find(filename); if (entry == data.end()) { size_t pos = 0; while ((pos = filename.find("%20", pos)) != std::string::npos) { filename.replace(pos, 3, " "); ++pos; } entry = data.find(filename); } if (entry == data.end()) return std::shared_ptr<cainteoir::buffer>(); const zip_data &item = entry->second; if (item.cached) return item.cached; auto decoder = *(zip_compression.begin() + item.compression_type); if (item.compression_type >= zip_compression.size() || decoder == nullptr) throw std::runtime_error(i18n("decompression failed (unsupported compression type)")); cainteoir::buffer compressed { item.begin, item.begin + item.compressed }; return const_cast<zip_data &>(item).cached = decoder(compressed, item.uncompressed); }
// Set with initializer list Set(const std::initializer_list<value_type>& l) { _set.reserve(l.size()); for (const auto& value : l) { insert(value); } }
BinTree::BinTree(std::initializer_list<int> inlist) { if (inlist.size()==0) return; root = new Node(*inlist.begin()); for (auto& el : inlist) insert(el); }
Vector<T>::Vector(const std::initializer_list<T> args) : size_array(args.size()), cap_array(args.size()*2), array(new T[cap_array]) { int i = 0; for (auto iter = args.begin(); iter != args.end(); ++iter) { array[i] = *iter; ++i; } }
static void emitDeallocatingCall(IRGenFunction &IGF, llvm::Constant *fn, std::initializer_list<llvm::Value *> args) { llvm::CallInst *call = IGF.Builder.CreateCall(fn, makeArrayRef(args.begin(), args.size())); call->setCallingConv(IGF.IGM.RuntimeCC); call->setDoesNotThrow(); }
long int VariableSet::var(std::string name, std::initializer_list<unsigned int > coord) { unsigned int index = subset_indices[name]; if (coord.size() != subset_dimensions[index].size()) throw std::domain_error( "Too much coordinates for VariableSet.var()."); unsigned int i = 0; long int code = 0; for (auto c = coord.begin(); c != coord.end(); c++) { if (*c >= subset_dimensions[index][i]) { std::stringstream msg; msg << "Coordinate " << i << " for VariableSet.var() is too large (" << (*c) << " >= " << subset_dimensions[index][i] << ")."; throw std::out_of_range(msg.str()); } if (i == 0) code = *c; else code = *c + subset_dimensions[index][i]*code; i++; } code += subset_cumulated_sizes[index] + 1; return code; }
bool TestReadWrite(typename T::type_t value, std::initializer_list<uint8_t> expected) { Buffer buffer(T::size); auto dest = buffer.as_wslice(); if (!T::write_to(dest, value)) return false; if(dest.is_not_empty()) return false; if (expected.size() != T::size) { return false; } auto i = 0; for (auto& byte : expected) { if (buffer.as_rslice()[i] != byte) { return false; } ++i; } typename T::type_t read_value; auto input = buffer.as_rslice(); return T::read_from(input, read_value) && input.is_empty() && (read_value == value); }
bool Reader::peekList(std::initializer_list<unsigned char> list) { if (list.size() == 0) { return false; } const QByteArray parr = dev.peek(list.size()); if (parr.size() != list.size()) { return false; } int i{0}; for (auto it = list.begin(); it != list.end(); it++, i++) { if (*it != (unsigned char) parr[i]) { return false; } } return true; }
template<UnsignedInt dimensions> void Listener<dimensions>::update(std::initializer_list<std::reference_wrapper<PlayableGroup<dimensions>>> groups) { /* Check if active listener just changed to this */ if(this != Implementation::activeListener) { /* Ensure that clean() is called also when switching between (clean) listeners */ Implementation::activeListener = this; this->object().setDirty(); /* Listener gain needs to be updated only when active listener changed and in setGain() */ Renderer::setListenerGain(_gain); } /* Add all objects of the Playables in the PlayableGroups to a vector to later setClean() */ std::vector<std::reference_wrapper<AbstractObject<dimensions, Float>>> objects; objects.push_back(this->object()); for(PlayableGroup<dimensions>& group : groups) { for(UnsignedInt i = 0; i < groups.size(); ++i) { objects.push_back(group[i].object()); } } /* Use the more performant way to set multiple objects clean */ AbstractObject<dimensions, Float>::setClean(objects); }
Polynomial PolyDomain::operator()(const std::initializer_list<BigUnsigned>& c) const { std::vector<FieldElement> coeffs(c.size()); std::transform(c.begin(), c.end(), coeffs.begin(), [&](const BigUnsigned& b) { return field->makeElement(b); }); return makeElement(coeffs); }
void testVarint(uint64_t val, std::initializer_list<uint8_t> bytes) { size_t n = bytes.size(); ByteRange expected(&*bytes.begin(), n); { uint8_t buf[kMaxVarintLength64]; EXPECT_EQ(expected.size(), encodeVarint(val, buf)); EXPECT_TRUE(ByteRange(buf, expected.size()) == expected); } { ByteRange r = expected; uint64_t decoded = decodeVarint(r); EXPECT_TRUE(r.empty()); EXPECT_EQ(val, decoded); } if (n < kMaxVarintLength64) { // Try from a full buffer too, different code path uint8_t buf[kMaxVarintLength64]; memcpy(buf, &*bytes.begin(), n); uint8_t fills[] = {0, 0x7f, 0x80, 0xff}; for (uint8_t fill : fills) { memset(buf + n, fill, kMaxVarintLength64 - n); ByteRange r(buf, kMaxVarintLength64); uint64_t decoded = decodeVarint(r); EXPECT_EQ(val, decoded); EXPECT_EQ(kMaxVarintLength64 - n, r.size()); } } }
void addToMatrix(PETScMatrix& m, std::initializer_list<double> values) { using IndexType = PETScMatrix::IndexType; auto const rows = m.getNumberOfRows(); auto const cols = m.getNumberOfColumns(); assert((IndexType) values.size() == rows*cols); Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> tmp(rows, cols); auto it = values.begin(); for (IndexType r=0; r<rows; ++r) { for (IndexType c=0; c<cols; ++c) { tmp(r, c) = *(it++); } } std::vector<IndexType> row_idcs(rows); std::vector<IndexType> col_idcs(cols); std::iota(row_idcs.begin(), row_idcs.end(), 0); std::iota(col_idcs.begin(), col_idcs.end(), 0); m.add(row_idcs, col_idcs, tmp); }
OpenGlVec(std::initializer_list<T> list) { assert(list.size() <= N); auto itr = list.begin(); for(std::size_t i = 0; i < N; ++i) std::array<T,N>::operator[](i) = itr != list.end() ? *(itr++) : T(0); }
CommandExecutor::CommandExecutor(State::Value state, const std::initializer_list<Commandable*> commandables) : _state(state), _commandables(commandables.size()) { std::copy(commandables.begin(), commandables.end(), _commandables.begin()); }
static SliceElem startFromList(const std::initializer_list<T>& list) { if(list.size() >= 1) return SliceElem(*list.begin()); return SliceElem(); }
Edge::Edge(std::initializer_list<std::string> verts) : weight(0) { assert(verts.size() == 2); this->vertexA = *verts.begin(); this->vertexB = *std::next(verts.begin()); }
const wchar_t* Networking::NetworkEnumNames::GetIANAInterfaceTypeName(uint32_t interfaceType) { if (interfaceType < kIANAInterfaceTypeNames.size()) return *(kIANAInterfaceTypeNames.begin() + interfaceType); return L"Unknown"; }
// cross-list operation void operator =(std::initializer_list<T> vallist){ //List a = {a, b}; clear(); std::vector<T> v; v.insert(v.end(), vallist.begin(), vallist.end()); for(int i=0;i<vallist.size();i++) add(v[i]); }
bool SAVectorInterval::setAt(const QVariant &val, const std::initializer_list<size_t> &index) { if(1 == index.size()) { return SAVectorDatas<QwtIntervalSample>::setAt(val,index); } else if(index.size()>=2) { for(auto i=(index.begin()+2);i!=index.end();++i) { if(0!=(*i)) { return false; } } int r = *(index.begin()); if(r < 0 || r > getValueDatas().size()) { return false; } QwtIntervalSample& sam = get(r); int c = *(index.begin()+1); bool isOK = false; double d = val.toDouble(&isOK); if(!isOK) return false; if(0 == c) { sam.value = d; } else if(1 == c) { sam.interval.setMinValue(d); } else if(2 == c) { sam.interval.setMaxValue(d); } else { return false; } setDirty(true); return true; } return false; }