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 ) ) );
}
}
}
}
