int CellmlModelDefinition::loadModel(const std::string &url)
{
std::cout << "Creating CellML Model Definition from the URL: "
<< url << std::endl;
mUrl = url;
if (mUrl.empty()) return -1;
std::wstring urlW = s2ws(url);
ObjRef<iface::cellml_api::CellMLBootstrap> cb = CreateCellMLBootstrap();
ObjRef<iface::cellml_api::DOMModelLoader> ml = cb->modelLoader();
int code;
try
{
ObjRef<iface::cellml_api::Model> model = ml->loadFromURL(urlW);
model->fullyInstantiateImports();
// we have a model, so we can start grabbing hold of the CellML API objects
mCapi = new CellmlApiObjects();
mCapi->model = model;
code = instantiateCellmlApiObjects();
}
catch (...)
{
std::wcerr << L"Error loading model: " << urlW << std::endl;
return -1;
}
return code;
}
int CellmlModelDefinition::loadModelFromString(const std::string &ms)
{
std::cout << "Creating CellML Model Definition from the given model string"
<< std::endl;
mUrl = "";
std::wstring msW = s2ws(ms);
ObjRef<iface::cellml_api::CellMLBootstrap> cb = CreateCellMLBootstrap();
ObjRef<iface::cellml_api::DOMModelLoader> ml = cb->modelLoader();
int code;
try
{
ObjRef<iface::cellml_api::Model> model = ml->createFromText(msW);
model->fullyInstantiateImports();
// we have a model, so we can start grabbing hold of the CellML API objects
mCapi = new CellmlApiObjects();
mCapi->model = model;
code = instantiateCellmlApiObjects();
}
catch (...)
{
std::wcerr << L"Error loading model from string." << std::endl;
return -1;
}
return code;
}
bool CellmlFile::doLoad(const QString &pFileName, const QString &pFileContents,
ObjRef<iface::cellml_api::Model> *pModel,
CellmlFileIssues &pIssues)
{
// Make sure that pIssues is empty
pIssues.clear();
// Get a bootstrap object and its model loader
ObjRef<iface::cellml_api::CellMLBootstrap> cellmlBootstrap = CreateCellMLBootstrap();
ObjRef<iface::cellml_api::DOMModelLoader> modelLoader = cellmlBootstrap->modelLoader();
// Try to create the model
try {
if (pFileContents.isEmpty())
*pModel = modelLoader->loadFromURL(QUrl::fromPercentEncoding(QUrl::fromLocalFile(pFileName).toEncoded()).toStdWString());
else
*pModel = modelLoader->createFromText(pFileContents.toStdWString());
} catch (iface::cellml_api::CellMLException &exception) {
// Something went wrong with the loading of the model
if (pFileContents.isEmpty()) {
pIssues << CellmlFileIssue(CellmlFileIssue::Error,
QObject::tr("the model could not be loaded (%1)").arg(Core::formatMessage(QString::fromStdWString(exception.explanation))));
} else {
pIssues << CellmlFileIssue(CellmlFileIssue::Error,
QObject::tr("the model could not be created (%1)").arg(Core::formatMessage(QString::fromStdWString(exception.explanation))));
}
return false;
}
// Update the base URI, should the CellML file be a remote one or its
// contents be directly passed onto us
Core::FileManager *fileManagerInstance = Core::FileManager::instance();
ObjRef<iface::cellml_api::URI> baseUri = (*pModel)->xmlBase();
if (fileManagerInstance->isRemote(pFileName)) {
// We are dealing with a remote file, so its XML base value should point
// to its remote location
baseUri->asText(fileManagerInstance->url(pFileName).toStdWString());
} else if (!pFileContents.isEmpty()) {
// We are dealing with a file which contents was directly passed onto
// us, so its XML base value should point to its actual location
baseUri->asText(pFileName.toStdWString());
}
return true;
}
void Tests::basicTests()
{
// Some very basic tests to make sure that we have access to the CellML API
// Get a bootstrap object and its model loader
ObjRef<iface::cellml_api::CellMLBootstrap> cellmlBootstrap = CreateCellMLBootstrap();
ObjRef<iface::cellml_api::DOMModelLoader> modelLoader = cellmlBootstrap->modelLoader();
QVERIFY(cellmlBootstrap);
QVERIFY(modelLoader);
// Create a CellML 1.0 model
ObjRef<iface::cellml_api::Model> cellml10Model = cellmlBootstrap->createModel(L"1.0");
QVERIFY(cellml10Model);
// Create a CellML 1.1 model
ObjRef<iface::cellml_api::Model> cellml11Model = cellmlBootstrap->createModel(L"1.1");
QVERIFY(cellml11Model);
// Create an invalid CellML model
ObjRef<iface::cellml_api::Model> invalidCellmlModel;
try {
invalidCellmlModel = cellmlBootstrap->createModel(L"xxx");
} catch (...) {
QVERIFY(!invalidCellmlModel);
}
// Load an existing model
ObjRef<iface::cellml_api::Model> existingModel = modelLoader->loadFromURL(QUrl::fromPercentEncoding(QUrl::fromLocalFile(QFileInfo(OpenCOR::fileName("models/noble_model_1962.cellml")).canonicalFilePath()).toEncoded()).toStdWString());
QVERIFY(existingModel);
QCOMPARE(QString::fromStdWString(existingModel->name()), QString("noble_model_1962"));
QCOMPARE(QString::fromStdWString(existingModel->cellmlVersion()), QString("1.0"));
// Load a non-existing model
ObjRef<iface::cellml_api::Model> nonExistingModel;
try {
nonExistingModel = modelLoader->loadFromURL(L"xxx");
} catch (...) {
QVERIFY(!nonExistingModel);
}
}
bool CellmlFileManager::canLoadFileContents(const QString &pFileContents) const
{
// Try to load the CellML file contents
ObjRef<iface::cellml_api::CellMLBootstrap> cellmlBootstrap = CreateCellMLBootstrap();
ObjRef<iface::cellml_api::DOMModelLoader> modelLoader = cellmlBootstrap->modelLoader();
ObjRef<iface::cellml_api::Model> model;
try {
model = modelLoader->createFromText(pFileContents.toStdWString());
return true;
} catch (iface::cellml_api::CellMLException &) {
return false;
}
}
bool isCellmlFile(const QString &pFileName)
{
// If the given file is already managed by our CellML file manager, then we
// consider that it's still a CellML file (even though it may not be a
// CellML file anymore after having been edited and saved, but in this case
// it's good to keep considering the file as a CellML file, so that the user
// can continue editing it for example)
QString nativeFileName = Core::nativeCanonicalFileName(pFileName);
if (CellMLSupport::CellmlFileManager::instance()->cellmlFile(nativeFileName))
return true;
// The given file is not managed by our CellML file manager, so check
// whether it's a new file and, if so, consider it as a CellML file
if (Core::FileManager::instance()->isNew(nativeFileName))
return true;
// Check whether we are dealing with an empty file or a file that contains
// spaces of sorts and, if not, whether we can load it using the CellML API
QString fileContents;
if (Core::readTextFromFile(nativeFileName, fileContents)) {
if (fileContents.trimmed().isEmpty())
return true;
ObjRef<iface::cellml_api::CellMLBootstrap> cellmlBootstrap = CreateCellMLBootstrap();
ObjRef<iface::cellml_api::DOMModelLoader> modelLoader = cellmlBootstrap->modelLoader();
ObjRef<iface::cellml_api::Model> model;
try {
model = modelLoader->createFromText(fileContents.toStdWString());
return true;
} catch (iface::cellml_api::CellMLException &) {
return false;
}
} else {
return false;
}
}
