Commit 003d8c5c authored by Aaron Bray's avatar Aaron Bray
Browse files

Serialization Encapsulation Complete

parent d3b0300a
......@@ -26,7 +26,7 @@
#endif
#define CDM_BIND_DECL(type) namespace cdm { class type; }
#define CDM_DECL_BIND(type) \
#define CDM_BIND_DECL2(type) \
class SE##type;\
namespace cdm { class type##Data; }
......@@ -116,6 +116,8 @@ struct CommonDataModelException : public std::runtime_error
#include "Macros.h"
#include "utils/Logger.h"
enum SerializationMode { BINARY = 0, ASCII };
// General Enums
// Keep enums in sync with appropriate schema/cdm/Enums.proto file !!
//
......@@ -136,6 +138,7 @@ extern const std::string& eCharge_Name(eCharge m);
class CCompoundUnit;
class SERunningAverage;
class SEScalar; class SEUnitScalar; class SEGenericScalar; class NoUnit;
class SEScalar0To1;
class SEScalarNegative1To1;
......
......@@ -47,6 +47,7 @@ struct PhysiologyEngineException : public CommonDataModelException
: CommonDataModelException(_Message) {}
};
class CDM_DECL PhysiologyEngine
{
public:
......@@ -61,27 +62,36 @@ public:
/// Engine will be in a cleared state if this method fails.
/// Note the provided configuration will overwrite any configuration options in the state with its contents (Use with caution!)
//--------------------------------------------------------------------------------------------------
virtual bool LoadStateFile(const std::string& filename, const SEScalarTime* simTime=nullptr, const SEEngineConfiguration* config = nullptr) = 0;
virtual bool SerializeFromFile(const std::string& filename, SerializationMode m=ASCII, const SEScalarTime* simTime=nullptr, const SEEngineConfiguration* config = nullptr) = 0;
//--------------------------------------------------------------------------------------------------
/// \brief
/// Reset engine and set it to the state in the provided file.
/// Save the current state of the engine to provided filename.
/// Engine will be in a cleared state if this method fails.
//--------------------------------------------------------------------------------------------------
virtual bool SerializeToFile(const std::string& filename="engine.state", SerializationMode m=ASCII) const = 0;
//--------------------------------------------------------------------------------------------------
/// \brief
/// Reset engine and set it to the state in the provided string.
/// The state is saved as bytes in the given string.
/// Note that the bytes are binary, not text; we only use the string class as a convenient container.
/// You may provided a Simulation Time to be used if desired.
/// It will be reflected in the GetSimulationTime method.
/// Return value indicates engine was able to load provided state file.
/// Engine will be in a cleared state if this method fails.
/// Note the provided configuration will overwrite any configuration options in the state with its contents (Use with caution!)
//--------------------------------------------------------------------------------------------------
virtual bool LoadState(const void* state, const SEScalarTime* simTime = nullptr, const SEEngineConfiguration* config = nullptr) = 0;
virtual bool SerializeFromString(const std::string& state, SerializationMode m=BINARY, const SEScalarTime* simTime = nullptr, const SEEngineConfiguration* config = nullptr) = 0;
//--------------------------------------------------------------------------------------------------
/// \brief
/// Save the current state of the engine.
/// State will be written to a file if provided.
/// State object will be returned.
/// The state is saved as bytes in the given string.
/// Note that the bytes are binary, not text; we only use the string class as a convenient container.
/// Engine will be in a cleared state if this method fails.
//--------------------------------------------------------------------------------------------------
virtual void* SaveState(const std::string& filename = "") = 0;
virtual bool SerializeToString(std::string& state, SerializationMode m=BINARY) const = 0;
//--------------------------------------------------------------------------------------------------
/// \brief
......
......@@ -4,7 +4,6 @@
#include "stdafx.h"
#include "engine/SEAutoSerialization.h"
#include "properties/SEScalarTime.h"
#include "bind/cdm/Engine.pb.h"
SEAutoSerialization::SEAutoSerialization(Logger* logger) : Loggable(logger)
{
......@@ -44,44 +43,6 @@ bool SEAutoSerialization::IsValid() const
return true;
}
void SEAutoSerialization::Load(const cdm::AutoSerializationData& src, SEAutoSerialization& dst)
{
SEAutoSerialization::Serialize(src, dst);
}
void SEAutoSerialization::Serialize(const cdm::AutoSerializationData& src, SEAutoSerialization& dst)
{
dst.Clear();
if (src.has_period())
SEScalarTime::Load(src.period(), dst.GetPeriod());
if(src.periodtimestamps()!=cdm::eSwitch::NullSwitch)
dst.SetPeriodTimeStamps((eSwitch)src.periodtimestamps());
if (src.afteractions() != cdm::eSwitch::NullSwitch)
dst.SetAfterActions((eSwitch)src.afteractions());
if (src.reloadstate() != cdm::eSwitch::NullSwitch)
dst.SetReloadState((eSwitch)src.reloadstate());
dst.SetDirectory(src.directory());
dst.SetFileName(src.filename());
}
cdm::AutoSerializationData* SEAutoSerialization::Unload(const SEAutoSerialization& src)
{
cdm::AutoSerializationData *dst = new cdm::AutoSerializationData();
SEAutoSerialization::Serialize(src,*dst);
return dst;
}
void SEAutoSerialization::Serialize(const SEAutoSerialization& src, cdm::AutoSerializationData& dst)
{
if (src.HasPeriod())
dst.set_allocated_period(SEScalarTime::Unload(*src.m_Period));
dst.set_periodtimestamps((cdm::eSwitch)src.m_PeriodTimeStamps);
dst.set_afteractions((cdm::eSwitch)src.m_AfterActions);
dst.set_reloadstate((cdm::eSwitch)src.m_ReloadState);
if (src.HasDirectory())
dst.set_directory(src.m_Directory);
if (src.HasFileName())
dst.set_filename(src.m_FileName);
}
bool SEAutoSerialization::HasPeriod() const
{
return m_Period == nullptr ? false : m_Period->IsValid();
......
......@@ -2,10 +2,10 @@
See accompanying NOTICE file for details.*/
#pragma once
CDM_BIND_DECL(AutoSerializationData)
class CDM_DECL SEAutoSerialization : public Loggable
{
friend class PBEngine;//friend the serialization class
public:
SEAutoSerialization(Logger* logger);
virtual ~SEAutoSerialization();
......@@ -13,14 +13,6 @@ public:
virtual void Clear();
virtual bool IsValid() const;
static void Load(const cdm::AutoSerializationData& src, SEAutoSerialization& dst);
static cdm::AutoSerializationData* Unload(const SEAutoSerialization& src);
protected:
static void Serialize(const cdm::AutoSerializationData& src, SEAutoSerialization& dst);
static void Serialize(const SEAutoSerialization& src, cdm::AutoSerializationData& dst);
public:
virtual bool HasPeriod() const;
virtual SEScalarTime& GetPeriod();
virtual double GetPeriod(const TimeUnit& unit) const;
......
......@@ -12,8 +12,7 @@
#include "scenario/SEDataRequest.h"
#include "properties/SEScalarTime.h"
#include "utils/TimingProfile.h"
#include <google/protobuf/text_format.h>
#include "bind/cdm/Engine.pb.h"
#include "io/protobuf/PBEngine.h"
SEDynamicStabilization::SEDynamicStabilization(Logger *logger) : SEEngineStabilization(logger)
......@@ -31,7 +30,6 @@ SEDynamicStabilization::~SEDynamicStabilization()
delete m_FeedbackConvergence;
}
void SEDynamicStabilization::Clear()
{
SEEngineStabilization::Clear();
......@@ -43,66 +41,21 @@ void SEDynamicStabilization::Clear()
DELETE_MAP_SECOND(m_ConditionConvergence);
}
void SEDynamicStabilization::Load(const cdm::DynamicStabilizationData& src, SEDynamicStabilization& dst)
{
SEDynamicStabilization::Serialize(src, dst);
}
void SEDynamicStabilization::Serialize(const cdm::DynamicStabilizationData& src, SEDynamicStabilization& dst)
bool SEDynamicStabilization::SerializeToString(std::string& output, SerializationMode m) const
{
dst.Clear();
if (src.trackingstabilization() != cdm::eSwitch::NullSwitch)
dst.TrackStabilization((eSwitch)src.trackingstabilization());
if(src.has_restingconvergence())
SEDynamicStabilizationEngineConvergence::Load(src.restingconvergence(), dst.GetRestingConvergence());
if (src.has_feedbackconvergence())
SEDynamicStabilizationEngineConvergence::Load(src.feedbackconvergence(), dst.GetFeedbackConvergence());
for (auto itr : src.conditionconvergence())
{
SEDynamicStabilizationEngineConvergence* c = new SEDynamicStabilizationEngineConvergence(dst.GetLogger());
SEDynamicStabilizationEngineConvergence::Load(itr.second,*c);
dst.m_ConditionConvergence[itr.first] = c;
}
return PBEngine::SerializeToString(*this, output, m);
}
cdm::DynamicStabilizationData* SEDynamicStabilization::Unload(const SEDynamicStabilization& src)
bool SEDynamicStabilization::SerializeToFile(const std::string& filename, SerializationMode m) const
{
cdm::DynamicStabilizationData* dst(new cdm::DynamicStabilizationData());
SEDynamicStabilization::Serialize(src,*dst);
return dst;
return PBEngine::SerializeToFile(*this, filename, m);
}
void SEDynamicStabilization::Serialize(const SEDynamicStabilization& src, cdm::DynamicStabilizationData& dst)
bool SEDynamicStabilization::SerializeFromString(const std::string& src, SerializationMode m)
{
dst.set_trackingstabilization((cdm::eSwitch)src.m_TrackingStabilization);
dst.set_allocated_restingconvergence(SEDynamicStabilizationEngineConvergence::Unload(*src.m_RestingConvergence));
if (src.HasFeedbackConvergence())
dst.set_allocated_feedbackconvergence(SEDynamicStabilizationEngineConvergence::Unload(*src.m_FeedbackConvergence));
for (auto &c : src.m_ConditionConvergence)
{
cdm::DynamicStabilizationData_EngineConvergenceData* cData = SEDynamicStabilizationEngineConvergence::Unload(*c.second);
(*dst.mutable_conditionconvergence())[c.first] = *cData;
delete cData;
}
return PBEngine::SerializeFromString(src, *this, m);
}
bool SEDynamicStabilization::LoadFile(const std::string& file)
bool SEDynamicStabilization::SerializeFromFile(const std::string& filename, SerializationMode m)
{
try
{
Clear();
std::ifstream input(file);
std::string fmsg((std::istreambuf_iterator<char>(input)), std::istreambuf_iterator<char>());
cdm::DynamicStabilizationData ds;
if (!google::protobuf::TextFormat::ParseFromString(fmsg, &ds))
return false;
SEDynamicStabilization::Load(ds, *this);
return true;
}
catch (std::exception ex)
{
Error("Unable to read file : " + file);
}
return false;
return PBEngine::SerializeFromFile(filename, *this, m);
}
SEDynamicStabilizationEngineConvergence& SEDynamicStabilization::GetRestingConvergence()
......
......@@ -4,24 +4,20 @@
#pragma once
#include "engine/SEEngineStabilization.h"
class SEDynamicStabilizationEngineConvergence;
CDM_BIND_DECL(DynamicStabilizationData)
class CDM_DECL SEDynamicStabilization : public SEEngineStabilization
{
friend class PBEngine;//friend the serialization class
public:
SEDynamicStabilization(Logger* logger);
virtual ~SEDynamicStabilization();
virtual void Clear();
static void Load(const cdm::DynamicStabilizationData& src, SEDynamicStabilization& dst);
static cdm::DynamicStabilizationData* Unload(const SEDynamicStabilization& src);
protected:
static void Serialize(const cdm::DynamicStabilizationData& src, SEDynamicStabilization& dst);
static void Serialize(const SEDynamicStabilization& src, cdm::DynamicStabilizationData& dst);
public:
virtual bool LoadFile(const std::string& file);
bool SerializeToString(std::string& output, SerializationMode m) const;
bool SerializeToFile(const std::string& filename, SerializationMode m) const;
bool SerializeFromString(const std::string& src, SerializationMode m);
bool SerializeFromFile(const std::string& filename, SerializationMode m);
virtual bool StabilizeRestingState(PhysiologyEngine& engine);
virtual bool StabilizeFeedbackState(PhysiologyEngine& engine);
......
......@@ -4,7 +4,6 @@
#include "stdafx.h"
#include "engine/SEDynamicStabilizationEngineConvergence.h"
#include "engine/SEDynamicStabilizationPropertyConvergence.h"
#include "bind/cdm/Engine.pb.h"
#include "scenario/SEDataRequest.h"
#include "scenario/SEDataRequestManager.h"
#include "properties/SEScalarTime.h"
......@@ -35,55 +34,6 @@ void SEDynamicStabilizationEngineConvergence::Clear()
DELETE_VECTOR(m_PropertyConvergence);
}
void SEDynamicStabilizationEngineConvergence::Load(const cdm::DynamicStabilizationData_EngineConvergenceData& src, SEDynamicStabilizationEngineConvergence& dst)
{
SEDynamicStabilizationEngineConvergence::Serialize(src, dst);
}
void SEDynamicStabilizationEngineConvergence::Serialize(const cdm::DynamicStabilizationData_EngineConvergenceData& src, SEDynamicStabilizationEngineConvergence& dst)
{
dst.Clear();
// TODO Warn if these are not provided
if (src.has_convergencetime())
SEScalarTime::Load(src.convergencetime(), dst.GetConvergenceTime());
if (src.has_minimumreactiontime())
SEScalarTime::Load(src.minimumreactiontime(), dst.GetMinimumReactionTime());
if (src.has_maximumallowedstabilizationtime())
SEScalarTime::Load(src.maximumallowedstabilizationtime(), dst.GetMaximumAllowedStabilizationTime());
for (int i=0; i<src.propertyconvergence_size(); i++)
{
const cdm::DynamicStabilizationData_PropertyConvergenceData& pcData = src.propertyconvergence(i);
if (pcData.has_datarequest())
{
SEDataRequest& dr = dst.m_DataRequestMgr->CreateDataRequest((eDataRequest_Category)pcData.datarequest().category());
SEDataRequest::Load(pcData.datarequest(), dr);
dst.CreatePropertyConvergence(dr, pcData.percentdifference());
}
else
{
dst.Error("Ignoring property convergence that has no data request");
}
}
}
cdm::DynamicStabilizationData_EngineConvergenceData* SEDynamicStabilizationEngineConvergence::Unload(const SEDynamicStabilizationEngineConvergence& src)
{
cdm::DynamicStabilizationData_EngineConvergenceData* dst = new cdm::DynamicStabilizationData_EngineConvergenceData();
SEDynamicStabilizationEngineConvergence::Serialize(src,*dst);
return dst;
}
void SEDynamicStabilizationEngineConvergence::Serialize(const SEDynamicStabilizationEngineConvergence& src, cdm::DynamicStabilizationData_EngineConvergenceData& dst)
{
dst.set_allocated_convergencetime(SEScalarTime::Unload(*src.m_ConvergenceTime));
dst.set_allocated_minimumreactiontime(SEScalarTime::Unload(*src.m_MinimumReactionTime));
dst.set_allocated_maximumallowedstabilizationtime(SEScalarTime::Unload(*src.m_MaximumAllowedStabilizationTime));
for (auto pc : src.m_PropertyConvergence)
{
cdm::DynamicStabilizationData_PropertyConvergenceData* pcData = dst.mutable_propertyconvergence()->Add();
pcData->set_percentdifference(pc->m_Error);
pcData->set_allocated_datarequest(SEDataRequest::Unload(pc->m_DataRequest));
}
}
SEDynamicStabilizationPropertyConvergence& SEDynamicStabilizationEngineConvergence::CreatePropertyConvergence(SEDataRequest& dr, double percentError)
{
SEDynamicStabilizationPropertyConvergence* p = new SEDynamicStabilizationPropertyConvergence(dr, GetLogger());
......
......@@ -2,13 +2,13 @@
See accompanying NOTICE file for details.*/
#pragma once
CDM_BIND_DECL(DynamicStabilizationData_EngineConvergenceData)
class SEDynamicStabilizationPropertyConvergence;
class SEDataRequest;
class SEDataRequestManager;
class CDM_DECL SEDynamicStabilizationEngineConvergence : public Loggable
{
friend class PBEngine;//friend the serialization class
friend class SEDynamicStabilization;
protected:
SEDynamicStabilizationEngineConvergence(Logger* logger);
......@@ -18,12 +18,6 @@ public:
virtual void Clear();
static void Load(const cdm::DynamicStabilizationData_EngineConvergenceData& src, SEDynamicStabilizationEngineConvergence& dst);
static cdm::DynamicStabilizationData_EngineConvergenceData* Unload(const SEDynamicStabilizationEngineConvergence& src);
protected:
static void Serialize(const cdm::DynamicStabilizationData_EngineConvergenceData& src, SEDynamicStabilizationEngineConvergence& dst);
static void Serialize(const SEDynamicStabilizationEngineConvergence& src, cdm::DynamicStabilizationData_EngineConvergenceData& dst);
public:
virtual SEScalarTime& GetConvergenceTime();
......
......@@ -4,8 +4,6 @@
#include "stdafx.h"
#include "engine/SEDynamicStabilizationLedger.h"
#include "engine/SEDynamicStabilizationEngineConvergence.h"
#include "engine/SEEngineTracker.h"
#include "engine/SEDynamicStabilizationPropertyConvergence.h"
#include "properties/SEScalarTime.h"
......
......@@ -7,6 +7,7 @@ class SEDataRequestScalar;
class CDM_DECL SEDynamicStabilizationPropertyConvergence : public Loggable
{
friend class PBEngine;//friend the serialization class
friend class SEDynamicStabilizationEngineConvergence;
protected:
SEDynamicStabilizationPropertyConvergence(SEDataRequest& dr, Logger* logger);
......
......@@ -15,7 +15,10 @@ public:
virtual void Clear();
virtual bool LoadFile(const std::string& file) = 0;
virtual bool SerializeToString(std::string& output, SerializationMode) const = 0;
virtual bool SerializeToFile(const std::string& filename, SerializationMode) const = 0;
virtual bool SerializeFromString(const std::string& src, SerializationMode) = 0;
virtual bool SerializeFromFile(const std::string& filename, SerializationMode) = 0;
virtual bool StabilizeRestingState(PhysiologyEngine& engine)=0;
virtual bool StabilizeFeedbackState(PhysiologyEngine& engine) = 0;
......
......@@ -8,8 +8,7 @@
#include "scenario/SECondition.h"
#include "utils/TimingProfile.h"
#include "properties/SEScalarTime.h"
#include <google/protobuf/text_format.h>
#include "bind/cdm/Engine.pb.h"
#include "io/protobuf/PBEngine.h"
bool SETimedStabilization::StabilizeRestingState(PhysiologyEngine& engine)
{
......@@ -144,67 +143,21 @@ void SETimedStabilization::Clear()
DELETE_MAP_SECOND(m_ConditionTimes);
}
void SETimedStabilization::Load(const cdm::TimedStabilizationData& src, SETimedStabilization& dst)
bool SETimedStabilization::SerializeToString(std::string& output, SerializationMode m) const
{
SETimedStabilization::Serialize(src, dst);
return PBEngine::SerializeToString(*this, output, m);
}
void SETimedStabilization::Serialize(const cdm::TimedStabilizationData& src, SETimedStabilization& dst)
bool SETimedStabilization::SerializeToFile(const std::string& filename, SerializationMode m) const
{
dst.Clear();
if (src.trackingstabilization() != cdm::eSwitch::NullSwitch)
dst.TrackStabilization((eSwitch)src.trackingstabilization());
if(src.has_restingstabilizationtime())
SEScalarTime::Load(src.restingstabilizationtime(), dst.GetRestingStabilizationTime());
if(src.has_feedbackstabilizationtime())
SEScalarTime::Load(src.feedbackstabilizationtime(), dst.GetFeedbackStabilizationTime());
for (auto itr : src.conditionstabilization())
{
SEScalarTime* time = new SEScalarTime();
SEScalarTime::Load(itr.second, *time);
dst.m_ConditionTimes[itr.first] = time;
}
return PBEngine::SerializeToFile(*this, filename, m);
}
cdm::TimedStabilizationData* SETimedStabilization::Unload(const SETimedStabilization& src)
bool SETimedStabilization::SerializeFromString(const std::string& src, SerializationMode m)
{
cdm::TimedStabilizationData* dst(new cdm::TimedStabilizationData());
SETimedStabilization::Serialize(src,*dst);
return dst;
}
void SETimedStabilization::Serialize(const SETimedStabilization& src, cdm::TimedStabilizationData& dst)
{
dst.set_trackingstabilization((cdm::eSwitch)src.m_TrackingStabilization);
dst.set_allocated_restingstabilizationtime(SEScalarTime::Unload(*src.m_RestingStabilizationTime));
if (src.HasFeedbackStabilizationTime())
dst.set_allocated_feedbackstabilizationtime(SEScalarTime::Unload(*src.m_FeedbackStabilizationTime));
for (auto cc : src.m_ConditionTimes)
{
if (cc.second == nullptr)
continue;
cdm::ScalarTimeData* time = SEScalarTime::Unload(*cc.second);
(*dst.mutable_conditionstabilization())[cc.first] = *time;
delete time;
}
return PBEngine::SerializeFromString(src, *this, m);
}
bool SETimedStabilization::LoadFile(const std::string& file)
bool SETimedStabilization::SerializeFromFile(const std::string& filename, SerializationMode m)
{
try
{
Clear();
std::ifstream input(file);
std::string fmsg((std::istreambuf_iterator<char>(input)), std::istreambuf_iterator<char>());
cdm::TimedStabilizationData ts;
if (!google::protobuf::TextFormat::ParseFromString(fmsg, &ts))
return false;
SETimedStabilization::Load(ts, *this);
return true;
}
catch (std::exception ex)
{
Error("Unable to read file : " + file);
}
return false;
return PBEngine::SerializeFromFile(filename, *this, m);
}
SEScalarTime& SETimedStabilization::GetRestingStabilizationTime()
......
......@@ -2,26 +2,23 @@
See accompanying NOTICE file for details.*/
#pragma once
CDM_BIND_DECL(TimedStabilizationData)
#include "engine/SEEngineStabilization.h"
class CDM_DECL SETimedStabilization : public SEEngineStabilization
{
friend class PBEngine;//friend the serialization class
public:
SETimedStabilization(Logger* logger);
virtual ~SETimedStabilization();
virtual void Clear();
static void Load(const cdm::TimedStabilizationData& src, SETimedStabilization& dst);
static cdm::TimedStabilizationData* Unload(const SETimedStabilization& src);
protected:
static void Serialize(const cdm::TimedStabilizationData& src, SETimedStabilization& dst);
static void Serialize(const SETimedStabilization& src, cdm::TimedStabilizationData& dst);
public:
virtual bool LoadFile(const std::string& file);
bool SerializeToString(std::string& output, SerializationMode m) const;
bool SerializeToFile(const std::string& filename, SerializationMode m) const;
bool SerializeFromString(const std::string& src, SerializationMode m);
bool SerializeFromFile(const std::string& filename, SerializationMode m);
virtual bool StabilizeRestingState(PhysiologyEngine& engine);
virtual bool StabilizeFeedbackState(PhysiologyEngine& engine);
......
set( _cur_dir cpp/io/protobuf)
set( IO_PB_FILES ${_cur_dir}/PBUtils.h
${_cur_dir}/PBUtils.cpp
)
source_group("IO\\Protobuf" FILES ${IO_PB_FILES})
list(APPEND SOURCE ${IO_PB_FILES})
set( IO_PB_CDM_FILES ${_cur_dir}/cdm/PBActions.h
${_cur_dir}/cdm/PBActions.cpp
${_cur_dir}/cdm/PBActionEnums.cpp
${_cur_dir}/cdm/PBAnesthesiaMachine.h
${_cur_dir}/cdm/PBAnesthesiaMachine.cpp
${_cur_dir}/cdm/PBAnesthesiaMachineActions.h
${_cur_dir}/cdm/PBAnesthesiaMachineActions.cpp
${_cur_dir}/cdm/PBAnesthesiaMachineEnums.cpp
${_cur_dir}/cdm/PBCircuit.h
${_cur_dir}/cdm/PBCircuit.cpp
${_cur_dir}/cdm/PBCompartment.h
${_cur_dir}/cdm/PBCompartment.cpp
${_cur_dir}/cdm/PBCompartmentEnums.cpp
${_cur_dir}/cdm/PBConditions.h
${_cur_dir}/cdm/PBConditions.cpp
${_cur_dir}/cdm/PBElectroCardioGram.h
${_cur_dir}/cdm/PBElectroCardioGram.cpp
${_cur_dir}/cdm/PBElectroCardioGramEnums.cpp
${_cur_dir}/cdm/PBEngine.h
${_cur_dir}/cdm/PBEngine.cpp
${_cur_dir}/cdm/PBEnums.cpp
${_cur_dir}/cdm/PBEnvironment.h
${_cur_dir}/cdm/PBEnvironment.cpp
${_cur_dir}/cdm/PBEnvironmentActions.h
${_cur_dir}/cdm/PBEnvironmentActions.cpp
${_cur_dir}/cdm/PBEnvironmentConditions.h
${_cur_dir}/cdm/PBEnvironmentConditions.cpp
${_cur_dir}/cdm/PBEnvironmentEnums.cpp
${_cur_dir}/cdm/PBInhaler.h
${_cur_dir}/cdm/PBInhaler.cpp
${_cur_dir}/cdm/PBInhalerActions.h
${_cur_dir}/cdm/PBInhalerActions.cpp
${_cur_dir}/cdm/PBPatient.h
${_cur_dir}/cdm/PBPatient.cpp
${_cur_dir}/cdm/PBPatientEnums.cpp
${_cur_dir}/cdm/PBPatientActions.cpp
${_cur_dir}/cdm/PBPatientActions.h
${_cur_dir}/cdm/PBPatientActionEnums.cpp
${_cur_dir}/cdm/PBPatientAssessments.cpp
${_cur_dir}/cdm/PBPatientAssessments.h
${_cur_dir}/cdm/PBPatientAssessmentEnums.cpp
${_cur_dir}/cdm/PBPatientConditions.cpp
${_cur_dir}/cdm/PBPatientConditions.h
${_cur_dir}/cdm/PBPatientNutrition.h
${_cur_dir}/cdm/PBPatientNutrition.cpp
${_cur_dir}/cdm/PBPhysiology.h
${_cur_dir}/cdm/PBPhysiology.cpp
${_cur_dir}/cdm/PBPhysiologyEnums.cpp
${_cur_dir}/cdm/PBProperties.h
${_cur_dir}/cdm/PBProperties.cpp
${_cur_dir}/cdm/PBScenario.h
${_cur_dir}/cdm/PBScenario.cpp
${_cur_dir}/cdm/PBScenarioEnums.cpp
${_cur_dir}/cdm/PBSubstance.h
${_cur_dir}/cdm/PBSubstance.cpp
${_cur_dir}/cdm/PBSubstanceEnums.cpp