const std::string& ArrayDataType::Impl::getIdentifier() const { if (identifier.empty()) { identifier = memberType.getIdentifier()+(getNumMembers() ? "["+boost::lexical_cast<std::string>(getNumMembers())+"]" : "[]"); } return identifier; }
void ArrayVariant::Value::setValue(const Variant::Value& value) { const Value& arrayValue = dynamic_cast<const Value&>(value); resize(arrayValue.getNumMembers()); for (size_t i = 0; i < getNumMembers(); ++i) setMember(i, arrayValue.getMember(i)); }
bool ArrayVariant::Value::hasMember(const std::string& name) const { int index; try { index = boost::lexical_cast<int>(name); } catch (...) { return false; } return (index < getNumMembers()); }
bool ArrayImpl::equalsData( void const *lhs, void const *rhs ) const { size_t lhsSize = getNumMembers( lhs ); size_t rhsSize = getNumMembers( rhs ); if ( lhsSize != rhsSize ) return false; else if( lhsSize ) { if( m_memberIsShallow ) return memcmp( getImmutableMemberData( lhs, 0 ), getImmutableMemberData( rhs, 0 ), lhsSize * m_memberImpl->getAllocSize() ) == 0; else { for ( size_t i=0; i<lhsSize; ++i ) { if( !m_memberImpl->equalsData( getImmutableMemberData( lhs, i ), getImmutableMemberData( rhs, i ) ) ) return false; } return true; } } else return true; }
std::string ArrayImpl::descData( void const *data ) const { std::string result = "["; size_t numMembers = getNumMembers( data ); size_t numMembersToDisplay = numMembers; if ( numMembersToDisplay > 4 ) numMembersToDisplay = 4; for ( size_t i=0; i<numMembersToDisplay; ++i ) { if ( result.length() > 1 ) result += ","; result += m_memberImpl->descData( getImmutableMemberData( data, i ) ); } if ( numMembers > numMembersToDisplay ) result += "..."; result += "]"; return result; }
void FixedArrayDesc::jsonDesc( JSON::ObjectEncoder &resultObjectEncoder ) const { ArrayDesc::jsonDesc( resultObjectEncoder ); resultObjectEncoder.makeMember( "internalType" ).makeString( "fixedArray" ); resultObjectEncoder.makeMember( "numMembers" ).makeInteger( getNumMembers() ); }
float InputNetcdf::getValueCore(const Key::Input& iKey) const { float returnValue = Global::MV; std::string filename = getFilename(iKey); int size = getNumOffsets()*getNumLocations()*getNumMembers(); float* values = new float[size]; NcFile ncfile(filename.c_str()); std::string localVariable; bool found = getLocalVariableName(iKey.variable, localVariable); assert(found); if(!ncfile.is_valid() || localVariable == "") { for(int i = 0; i < size; i++) { values[i] = Global::MV; } } else { std::stringstream ss; ss << "InputNetcdf: Loading " << filename << " " << iKey; Global::logger->write(ss.str(), Logger::message); assert(localVariable != ""); NcError q(NcError::silent_nonfatal); NcVar* ncvar = ncfile.get_var(localVariable.c_str()); if(ncvar) { long count[3] = {getNumOffsets(),getNumLocations(),getNumMembers()}; bool status = ncvar->get(values, count); assert(status); } else { std::stringstream ss; ss << "InputNetcdf: File " << filename << " does not contain local variable " << localVariable << ". Is the file corrupts?"; Global::logger->write(ss.str(), Logger::warning); for(int i = 0; i < size; i++) { values[i] = Global::MV; } } } ncfile.close(); std::vector<float> offsets = getOffsets(); std::vector<Member> members = getMembers(); int oC = getOffsetIndex(iKey.offset); int oS = mCacheOtherOffsets ? 0 : oC; int oE = mCacheOtherOffsets ? getNumOffsets()-1 : oC; int lC = iKey.location; int lS = mCacheOtherLocations ? 0 : lC; int lE = mCacheOtherLocations ? getNumLocations()-1 : lC; int iC = iKey.member; int iS = mCacheOtherMembers ? 0 : iC; int iE = mCacheOtherMembers ? getNumMembers()-1 : iC; std::vector<float> vec; vec.assign(values, values + size); delete[] values; Key::Input key = iKey; if(0 && getName() == "rda336") { std::cout << "Date: " << iKey.date << " " << iKey.variable << " " << getName() << " " << mCacheOtherLocations << std::endl; std::cout << oC << " " << oS << " " << oE << std::endl; std::cout << lC << " " << lS << " " << lE << std::endl; std::cout << iC << " " << iS << " " << iE << std::endl; } for(int offsetIndex = oS; offsetIndex <= oE; offsetIndex++) { key.offset = offsets[offsetIndex]; for(key.member = iS; key.member <= iE; key.member++) { for(key.location = lS; key.location <= lE; key.location++) { int index = offsetIndex*getNumLocations()*getNumMembers() + key.location*getNumMembers() + key.member; assert(index < vec.size()); Input::addToCache(key, vec[index]); assert(!std::isinf(vec[index])); if(key == iKey) { returnValue = vec[index]; } } } } if(std::isnan(returnValue)) { returnValue = Global::MV; } return returnValue; }
float InputFlat::getValueCore(const Key::Input& iKey) const { float returnValue = Global::MV; std::string filename = getFilename(iKey); std::vector<float> values; std::vector<float> offsets = getOffsets(); std::vector<Member> members = getMembers(); std::ifstream ifs(filename.c_str(), std::ifstream::in); if(!ifs.good()) { // Missing file std::vector<float> values; Key::Input key = iKey; for(int i = 0; i < offsets.size(); i++) { key.offset = offsets[i]; for(key.member = 0; key.member < members.size(); key.member++) { Input::addToCache(key, Global::MV); } } std::stringstream ss; ss << "InputFlat: File " << filename << " missing"; Global::logger->write(ss.str(), Logger::message); } else { // Loop over each line Key::Input key = iKey; int offsetId = 0; while(ifs.good()) { char line[10000]; ifs.getline(line, 10000, '\n'); if(ifs.good() && line[0] != '#') { if(offsetId >= offsets.size()) { std::stringstream ss; ss << "InputFlat: File '" << filename << "' has too many lines" << std::endl; Global::logger->write(ss.str(), Logger::warning); break; } assert(offsetId < offsets.size()); key.offset = offsets[offsetId]; std::stringstream ss(line); // Loop over each value key.member = 0; while(ss.good()) { float value; if(ss >> value) { Input::addToCache(key, value); } if(key.offset == iKey.offset && key.member == iKey.member) { returnValue = value; } key.member++; } } offsetId++; } offsetId--; // Deal with truncated files if(offsetId < offsets.size()-1) { std::stringstream ss; ss << "InputFlat: File '" << filename << "' has too few rows. Assume last rows are missing values"; Global::logger->write(ss.str(), Logger::warning); while(offsetId < offsets.size()) { key.offset = offsets[offsetId]; for(key.member = 0; key.member < getNumMembers(); key.member++) { Input::addToCache(key, Global::MV); } offsetId++; } } } return returnValue; }
void StructAdapter::llvmCompileToModule( ModuleBuilder &moduleBuilder ) const { if ( moduleBuilder.haveCompiledToModule( getCodeName() ) ) return; RC::Handle<Context> context = moduleBuilder.getContext(); RC::ConstHandle<StringAdapter> stringAdapter = getManager()->getStringAdapter(); stringAdapter->llvmCompileToModule( moduleBuilder ); RC::ConstHandle<SizeAdapter> sizeAdapter = getManager()->getSizeAdapter(); sizeAdapter->llvmCompileToModule( moduleBuilder ); RC::ConstHandle<OpaqueAdapter> dataAdapter = getManager()->getDataAdapter(); dataAdapter->llvmCompileToModule( moduleBuilder ); for ( MemberAdaptorVector::const_iterator it=m_memberAdapters.begin(); it!=m_memberAdapters.end(); ++it ) (*it)->llvmCompileToModule( moduleBuilder ); static const bool buildFunctions = true; if ( !m_isShallow ) { { InternalFunctionBuilder functionBuilder( moduleBuilder, 0, "__" + getCodeName() + "__DefaultAssign", "dst", this, USAGE_LVALUE, "src", this, USAGE_RVALUE, 0 ); if ( buildFunctions ) { llvm::Value *dstLValue = functionBuilder[0]; llvm::Value *srcRValue = functionBuilder[1]; BasicBlockBuilder basicBlockBuilder( functionBuilder ); basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) ); for ( size_t i=0; i<getNumMembers(); ++i ) { RC::ConstHandle<Adapter> const &memberAdapter = m_memberAdapters[i]; llvm::Value *dstMemberLValue = basicBlockBuilder->CreateConstGEP2_32( dstLValue, 0, i ); llvm::Value *srcMemberLValue = basicBlockBuilder->CreateConstGEP2_32( srcRValue, 0, i ); llvm::Value *srcMemberRValue = memberAdapter->llvmLValueToRValue( basicBlockBuilder, srcMemberLValue ); memberAdapter->llvmAssign( basicBlockBuilder, dstMemberLValue, srcMemberRValue ); } basicBlockBuilder->CreateRetVoid(); } } } { ConstructorBuilder functionBuilder( moduleBuilder, stringAdapter, this, ConstructorBuilder::HighCost ); if ( buildFunctions ) { llvm::Value *stringLValue = functionBuilder[0]; llvm::Value *structRValue = functionBuilder[1]; BasicBlockBuilder basicBlockBuilder( functionBuilder ); basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) ); llvm::Value *structLValue = llvmRValueToLValue( basicBlockBuilder, structRValue ); stringAdapter->llvmCallCast( basicBlockBuilder, this, structLValue, stringLValue ); basicBlockBuilder->CreateRetVoid(); } } if ( getDesc()->isShallow() ) { { MethodBuilder functionBuilder( moduleBuilder, sizeAdapter, this, USAGE_RVALUE, "dataSize" ); if ( buildFunctions ) { BasicBlockBuilder basicBlockBuilder( functionBuilder ); basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) ); llvm::Value *dataSizeRValue = llvm::ConstantInt::get( sizeAdapter->llvmRType( context ), getDesc()->getAllocSize() ); basicBlockBuilder->CreateRet( dataSizeRValue ); } } { MethodBuilder functionBuilder( moduleBuilder, dataAdapter, this, USAGE_LVALUE, "data" ); if ( buildFunctions ) { llvm::Value *thisLValue = functionBuilder[0]; BasicBlockBuilder basicBlockBuilder( functionBuilder ); basicBlockBuilder->SetInsertPoint( functionBuilder.createBasicBlock( "entry" ) ); basicBlockBuilder->CreateRet( basicBlockBuilder->CreatePointerCast( thisLValue, dataAdapter->llvmRType( context ) ) ); } } } }