int
OperatorUtils::SaveMatrix( const QString& inFileName, const Param& inParam )
{
if( inFileName.isEmpty() )
return CouldNotWrite;
bool saveAsMatrix = ( QFileInfo( inFileName ).suffix() == MATRIX_EXTENSION );
if( !saveAsMatrix )
{
bool isNested = false;
for( int row = 0; row < inParam.NumRows(); ++row )
for( int col = 0; col < inParam.NumColumns(); ++col )
isNested = isNested | ( inParam.Value( row, col ).Kind() != Param::ParamValue::Single );
if( isNested )
return CannotWriteNestedMatrixAsText;
}
ofstream output( inFileName.toLocal8Bit() );
if( saveAsMatrix )
{
output << inParam;
}
else
{
for( int row = 0; row < inParam.NumRows(); ++row )
{
int col = 0;
while( col < inParam.NumColumns() - 1 )
output << inParam.Value( row, col++ ) << '\t';
output << inParam.Value( row, col ) << endl;
}
}
return output ? NoError : CouldNotWrite;
}
int
OperatorUtils::LoadMatrix( const QString& inFileName, Param& outParam )
{
if( inFileName.isEmpty() )
return MatNotFound;
if( QFileInfo( inFileName ).suffix() == MATRIX_EXTENSION )
{
ParamList paramsFromFile;
paramsFromFile.Load( inFileName.toLocal8Bit().constData(), true );
if( paramsFromFile.Size() == 0 )
return MatNotFound;
if( paramsFromFile.Size() > 1 )
return MatMultipleParams;
Param p = paramsFromFile[0];
outParam.SetDimensions( p.NumRows(), p.NumColumns() );
for( int row = 0; row < p.NumRows(); ++row )
for( int col = 0; col < p.NumColumns(); ++col )
outParam.Value( row, col ) = p.Value( row, col );
outParam.RowLabels() = p.RowLabels();
outParam.ColumnLabels() = p.ColumnLabels();
}
else
{
ifstream input( inFileName.toLocal8Bit() );
input.clear();
vector<vector<string> > matrix;
string line;
while( getline( input, line ) )
{
istringstream is( line );
vector<string> row;
string value;
while( getline( is, value, '\t' ) )
row.push_back( value );
if( !row.empty() )
matrix.push_back( row );
}
if( matrix.empty() )
return MatNotFound;
size_t numRows = matrix.size(),
numCols = matrix[ 0 ].size();
for( size_t row = 1; row < numRows; ++row )
if( matrix[ row ].size() != numCols )
return MatLoadColsDiff;
outParam.SetDimensions( numRows, numCols );
for( size_t row = 0; row < numRows; ++row )
for( size_t col = 0; col < numCols; ++col )
{
istringstream iss( matrix[ row ][ col ] );
iss >> outParam.Value( row, col );
}
}
return NoError;
}
////////////////////////////////////////////////////////////////////////////////
// MatlabEngine::StringMatrix definitions //
////////////////////////////////////////////////////////////////////////////////
MatlabEngine::StringMatrix::StringMatrix( const Param& p )
: vector<vector<string> >( p.NumRows(), vector<string>( p.NumColumns() ) )
{
for( size_t row = 0; row < size(); ++row )
for( size_t column = 0; column < ( *this )[ row ].size(); ++column )
( *this )[ row ][ column ] = p.Value( row, column );
}
Param*
_TParamDef::param_get_ptr_suffix( ParamList* inList, const char* inName, long inSuffix )
{
Param* result = NULL;
string _name = inName,
_blankName = _name;
unsigned int _replacePos = _name.find( RUNTIME_SUFFIX );
assert( _replacePos != string::npos );
_blankName.erase( _replacePos, sizeof( RUNTIME_SUFFIX ) - 1 );
ostringstream _suffix;
_suffix << inSuffix;
_name.replace( _replacePos, sizeof( RUNTIME_SUFFIX ) - 1, _suffix.str() );
if( inList->Exists( _name ) )
result = &( *inList )[ _name ];
else
{
static Param p;
if( inList->Exists( _blankName ) )
{
Param& param = ( *inList )[ _blankName ];
p.SetType( "list" );
p.SetNumValues( param.NumValues() );
for( int i = 0; i < param.NumColumns(); ++i )
p.Value( i ) = param.Value( inSuffix, i );
result = &p;
}
}
return result;
}
bool
EnvironmentBase::IsAutoConfigParam( const Param& p )
{
enum { autoType = 0, autoTag, autoKind, count };
static const char* s[][count] =
{
{ "blob", 0 },
{ "auto", "AutoConfig", 0 },
{ "(enumeration)", 0 },
};
struct
{
bool Is( int type, const char* str )
{
const char** p = s[type];
while( *p )
if( !::stricmp( *p++, str ) )
return true;
return false;
}
bool Contains( int type, const char* str )
{
while( *str )
if( Is( type, str++ ) )
return true;
return false;
}
} strings;
bool result = strings.Is( autoType, p.Type().c_str() );
if( p.NumValues() == 1 )
result = result || strings.Is( autoTag, p.Value().c_str() );
if( p.NumValues() > 0 && !::atoi( p.Value().c_str() ) )
result = result || strings.Contains( autoKind, p.Comment().c_str() )
&& strings.Contains( autoTag, p.Comment().c_str() );
return result;
}
void
_TParamDef::param_add_all( ParamList* inList, const char* inSectionPrefix, long inDefaultDimension )
{
string sectionPrefix( inSectionPrefix ),
externalPrefix( "ext_" ),
runtimeSuffix( RUNTIME_SUFFIX ),
runtimeElement( RUNTIME_ELEMENT );
for( list<_TParamDef*>::const_iterator i = _TParamDef::params().begin();
i != params().end(); ++i )
{
Param p( ( *i )->definitionLine() );
string section = p.Section();
if( section.find( externalPrefix ) != 0 )
{
if( section != sectionPrefix )
{
section = sectionPrefix + "_" + section;
p.SetSection( section );
}
string name = p.Name();
size_t suffixPos = name.find( runtimeSuffix );
if( suffixPos != name.npos )
{
p.SetType( "matrix" );
string value = p.Value();
size_t pos = value.find( runtimeSuffix );
p.SetDimensions( inDefaultDimension + 1, 1 );
for( int i = p.NumRows() - 1; i >= 0; --i )
{
// Replace RUNTIME_SUFFIX in the comment and use it as a row label.
ostringstream os;
os << i;
string comment = p.Comment();
size_t comment_pos = comment.find( runtimeSuffix );
if( comment_pos != comment.npos )
comment.replace( comment_pos, runtimeSuffix.length(), os.str() );
p.RowLabels()[ i ] = comment;
// Replace RUNTIME_SUFFIX in the parameter values.
if( pos == value.npos )
p.Value( i, 0 ) = value;
else
{
string newValue = value;
newValue.replace( pos, runtimeSuffix.length(), os.str() );
p.Value( i, 0 ) = newValue;
}
}
p.ColumnLabels()[ 0 ] = "";
ostringstream oss;
oss << p;
string line = oss.str();
// Replace RUNTIME_SUFFIX in the parameter name.
pos = line.find( runtimeSuffix );
if( pos != line.npos )
line.replace( pos, runtimeSuffix.length(), "" );
// Replace RUNTIME_SUFFIX in the comment.
pos = line.rfind( runtimeSuffix );
if( pos != line.npos )
line.replace( pos, runtimeSuffix.length(), "N" );
name.replace( suffixPos, runtimeSuffix.length(), "" );
if( !inList->Exists( name ) )
inList->Add( line );
}
else
{ // The parameter might be a special instance for a certain suffix.
// This will only work for true suffices, i.e. at the end of the name.
size_t pos = name.find_last_not_of( "0123456789" );
Param* param = NULL;
if( pos != name.length() - 1 )
{
string paramName = name.substr( 0, pos + 1 );
if( inList->Exists( paramName ) )
param = &( *inList )[ paramName ];
}
if( param != NULL && string( "matrix" ) == param->Type() )
{
long suffix = ::atoi( name.substr( pos ).c_str() );
param->Value( suffix, 0 ) = p.Value();
param->RowLabels()[ suffix ] = p.Comment();
}
else if( !PARAM_EXISTS( inList, p.Name() ) )
{
ostringstream oss;
oss << p;
string line = oss.str();
// Runtime elements are not supported, the user must supply a value.
size_t rtPos;
while( ( rtPos = line.find( runtimeElement ) ) != line.npos )
line.replace( rtPos, runtimeElement.length(), "N/A" );
inList->Add( line );
}
}
}
}
}
