::value, "template argument for P is not a parent class of CPACSFramesAssembly");
if (!IsParent()) {
throw CTiglError("bad parent");
}
@@ -70,7 +73,7 @@ namespace generated
template
const P* GetParent() const
{
- static_assert(std::is_same::value || std::is_same::value, "template argument for P is not a parent class of CPACSFramesAssembly");
+ static_assert(std::is_same::value || std::is_same::value || std::is_same::value, "template argument for P is not a parent class of CPACSFramesAssembly");
if (!IsParent()) {
throw CTiglError("bad parent");
}
diff --git a/src/generated/CPACSFuelTank.cpp b/src/generated/CPACSFuelTank.cpp
new file mode 100644
index 0000000000..9285bb4510
--- /dev/null
+++ b/src/generated/CPACSFuelTank.cpp
@@ -0,0 +1,302 @@
+// Copyright (c) 2020 RISC Software GmbH
+//
+// This file was generated by CPACSGen from CPACS XML Schema (c) German Aerospace Center (DLR/SC).
+// Do not edit, all changes are lost when files are re-generated.
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include
+#include "CCPACSFuelTanks.h"
+#include "CPACSFuelTank.h"
+#include "CTiglError.h"
+#include "CTiglLogging.h"
+#include "CTiglUIDManager.h"
+#include "TixiHelper.h"
+
+namespace tigl
+{
+namespace generated
+{
+ CPACSFuelTank::CPACSFuelTank(CCPACSFuelTanks* parent, CTiglUIDManager* uidMgr)
+ : m_uidMgr(uidMgr)
+ , m_transformation(reinterpret_cast(this), m_uidMgr)
+ , m_vessels(reinterpret_cast(this), m_uidMgr)
+ {
+ //assert(parent != NULL);
+ m_parent = parent;
+ }
+
+ CPACSFuelTank::~CPACSFuelTank()
+ {
+ if (m_uidMgr) m_uidMgr->TryUnregisterObject(m_uID);
+ if (m_uidMgr) {
+ if (m_parentUID && !m_parentUID->empty()) m_uidMgr->TryUnregisterReference(*m_parentUID, *this);
+ }
+ }
+
+ const CCPACSFuelTanks* CPACSFuelTank::GetParent() const
+ {
+ return m_parent;
+ }
+
+ CCPACSFuelTanks* CPACSFuelTank::GetParent()
+ {
+ return m_parent;
+ }
+
+ const CTiglUIDObject* CPACSFuelTank::GetNextUIDParent() const
+ {
+ if (m_parent) {
+ return m_parent->GetNextUIDParent();
+ }
+ return nullptr;
+ }
+
+ CTiglUIDObject* CPACSFuelTank::GetNextUIDParent()
+ {
+ if (m_parent) {
+ return m_parent->GetNextUIDParent();
+ }
+ return nullptr;
+ }
+
+ CTiglUIDManager& CPACSFuelTank::GetUIDManager()
+ {
+ if (!m_uidMgr) {
+ throw CTiglError("UIDManager is null");
+ }
+ return *m_uidMgr;
+ }
+
+ const CTiglUIDManager& CPACSFuelTank::GetUIDManager() const
+ {
+ if (!m_uidMgr) {
+ throw CTiglError("UIDManager is null");
+ }
+ return *m_uidMgr;
+ }
+
+ void CPACSFuelTank::ReadCPACS(const TixiDocumentHandle& tixiHandle, const std::string& xpath)
+ {
+ // read attribute uID
+ if (tixi::TixiCheckAttribute(tixiHandle, xpath, "uID")) {
+ m_uID = tixi::TixiGetAttribute(tixiHandle, xpath, "uID");
+ if (m_uID.empty()) {
+ LOG(WARNING) << "Required attribute uID is empty at xpath " << xpath;
+ }
+ }
+ else {
+ LOG(ERROR) << "Required attribute uID is missing at xpath " << xpath;
+ }
+
+ // read attribute symmetry
+ if (tixi::TixiCheckAttribute(tixiHandle, xpath, "symmetry")) {
+ m_symmetry = stringToTiglSymmetryAxis(tixi::TixiGetAttribute(tixiHandle, xpath, "symmetry"));
+ }
+
+ // read element name
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/name")) {
+ m_name = tixi::TixiGetElement(tixiHandle, xpath + "/name");
+ if (m_name.empty()) {
+ LOG(WARNING) << "Required element name is empty at xpath " << xpath;
+ }
+ }
+ else {
+ LOG(ERROR) << "Required element name is missing at xpath " << xpath;
+ }
+
+ // read element description
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/description")) {
+ m_description = tixi::TixiGetElement(tixiHandle, xpath + "/description");
+ if (m_description->empty()) {
+ LOG(WARNING) << "Optional element description is present but empty at xpath " << xpath;
+ }
+ }
+
+ // read element parentUID
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/parentUID")) {
+ m_parentUID = tixi::TixiGetElement(tixiHandle, xpath + "/parentUID");
+ if (m_parentUID->empty()) {
+ LOG(WARNING) << "Optional element parentUID is present but empty at xpath " << xpath;
+ }
+ if (m_uidMgr && !m_parentUID->empty()) m_uidMgr->RegisterReference(*m_parentUID, *this);
+ }
+
+ // read element transformation
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/transformation")) {
+ m_transformation.ReadCPACS(tixiHandle, xpath + "/transformation");
+ }
+ else {
+ LOG(ERROR) << "Required element transformation is missing at xpath " << xpath;
+ }
+
+ // read element vessels
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/vessels")) {
+ m_vessels.ReadCPACS(tixiHandle, xpath + "/vessels");
+ }
+ else {
+ LOG(ERROR) << "Required element vessels is missing at xpath " << xpath;
+ }
+
+ if (m_uidMgr && !m_uID.empty()) m_uidMgr->RegisterObject(m_uID, *this);
+ }
+
+ void CPACSFuelTank::WriteCPACS(const TixiDocumentHandle& tixiHandle, const std::string& xpath) const
+ {
+ const std::vector childElemOrder = { "name", "description", "parentUID", "transformation", "vessels" };
+
+ // write attribute uID
+ tixi::TixiSaveAttribute(tixiHandle, xpath, "uID", m_uID);
+
+ // write attribute symmetry
+ if (m_symmetry) {
+ tixi::TixiSaveAttribute(tixiHandle, xpath, "symmetry", TiglSymmetryAxisToString(*m_symmetry));
+ }
+ else {
+ if (tixi::TixiCheckAttribute(tixiHandle, xpath, "symmetry")) {
+ tixi::TixiRemoveAttribute(tixiHandle, xpath, "symmetry");
+ }
+ }
+
+ // write element name
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/name", childElemOrder);
+ tixi::TixiSaveElement(tixiHandle, xpath + "/name", m_name);
+
+ // write element description
+ if (m_description) {
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/description", childElemOrder);
+ tixi::TixiSaveElement(tixiHandle, xpath + "/description", *m_description);
+ }
+ else {
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/description")) {
+ tixi::TixiRemoveElement(tixiHandle, xpath + "/description");
+ }
+ }
+
+ // write element parentUID
+ if (m_parentUID) {
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/parentUID", childElemOrder);
+ tixi::TixiSaveElement(tixiHandle, xpath + "/parentUID", *m_parentUID);
+ }
+ else {
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/parentUID")) {
+ tixi::TixiRemoveElement(tixiHandle, xpath + "/parentUID");
+ }
+ }
+
+ // write element transformation
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/transformation", childElemOrder);
+ m_transformation.WriteCPACS(tixiHandle, xpath + "/transformation");
+
+ // write element vessels
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/vessels", childElemOrder);
+ m_vessels.WriteCPACS(tixiHandle, xpath + "/vessels");
+
+ }
+
+ const std::string& CPACSFuelTank::GetUID() const
+ {
+ return m_uID;
+ }
+
+ void CPACSFuelTank::SetUID(const std::string& value)
+ {
+ if (m_uidMgr && value != m_uID) {
+ if (m_uID.empty()) {
+ m_uidMgr->RegisterObject(value, *this);
+ }
+ else {
+ m_uidMgr->UpdateObjectUID(m_uID, value);
+ }
+ }
+ m_uID = value;
+ }
+
+ const boost::optional& CPACSFuelTank::GetSymmetry() const
+ {
+ return m_symmetry;
+ }
+
+ void CPACSFuelTank::SetSymmetry(const boost::optional& value)
+ {
+ m_symmetry = value;
+ }
+
+ const std::string& CPACSFuelTank::GetName() const
+ {
+ return m_name;
+ }
+
+ void CPACSFuelTank::SetName(const std::string& value)
+ {
+ m_name = value;
+ }
+
+ const boost::optional& CPACSFuelTank::GetDescription() const
+ {
+ return m_description;
+ }
+
+ void CPACSFuelTank::SetDescription(const boost::optional& value)
+ {
+ m_description = value;
+ }
+
+ const boost::optional& CPACSFuelTank::GetParentUID() const
+ {
+ return m_parentUID;
+ }
+
+ void CPACSFuelTank::SetParentUID(const boost::optional& value)
+ {
+ if (m_uidMgr) {
+ if (m_parentUID && !m_parentUID->empty()) m_uidMgr->TryUnregisterReference(*m_parentUID, *this);
+ if (value && !value->empty()) m_uidMgr->RegisterReference(*value, *this);
+ }
+ m_parentUID = value;
+ }
+
+ const CCPACSTransformation& CPACSFuelTank::GetTransformation() const
+ {
+ return m_transformation;
+ }
+
+ CCPACSTransformation& CPACSFuelTank::GetTransformation()
+ {
+ return m_transformation;
+ }
+
+ const CCPACSVessels& CPACSFuelTank::GetVessels() const
+ {
+ return m_vessels;
+ }
+
+ CCPACSVessels& CPACSFuelTank::GetVessels()
+ {
+ return m_vessels;
+ }
+
+ const CTiglUIDObject* CPACSFuelTank::GetNextUIDObject() const
+ {
+ return this;
+ }
+
+ void CPACSFuelTank::NotifyUIDChange(const std::string& oldUid, const std::string& newUid)
+ {
+ if (m_parentUID && *m_parentUID == oldUid) {
+ m_parentUID = newUid;
+ }
+ }
+
+} // namespace generated
+} // namespace tigl
diff --git a/src/generated/CPACSFuelTank.h b/src/generated/CPACSFuelTank.h
new file mode 100644
index 0000000000..a49fd649eb
--- /dev/null
+++ b/src/generated/CPACSFuelTank.h
@@ -0,0 +1,120 @@
+// Copyright (c) 2020 RISC Software GmbH
+//
+// This file was generated by CPACSGen from CPACS XML Schema (c) German Aerospace Center (DLR/SC).
+// Do not edit, all changes are lost when files are re-generated.
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include "CTiglUIDObject.h"
+#include "ITiglUIDRefObject.h"
+#include "tigl_internal.h"
+
+namespace tigl
+{
+class CTiglUIDManager;
+class CCPACSFuelTanks;
+
+namespace generated
+{
+ // This class is used in:
+ // CPACSFuelTanks
+
+ /// @brief Fuel tank
+ ///
+ ///
+ class CPACSFuelTank : public CTiglReqUIDObject, public ITiglUIDRefObject
+ {
+ public:
+ TIGL_EXPORT CPACSFuelTank(CCPACSFuelTanks* parent, CTiglUIDManager* uidMgr);
+
+ TIGL_EXPORT virtual ~CPACSFuelTank();
+
+ TIGL_EXPORT CCPACSFuelTanks* GetParent();
+
+ TIGL_EXPORT const CCPACSFuelTanks* GetParent() const;
+
+ TIGL_EXPORT virtual CTiglUIDObject* GetNextUIDParent();
+ TIGL_EXPORT virtual const CTiglUIDObject* GetNextUIDParent() const;
+
+ TIGL_EXPORT CTiglUIDManager& GetUIDManager();
+ TIGL_EXPORT const CTiglUIDManager& GetUIDManager() const;
+
+ TIGL_EXPORT virtual void ReadCPACS(const TixiDocumentHandle& tixiHandle, const std::string& xpath);
+ TIGL_EXPORT virtual void WriteCPACS(const TixiDocumentHandle& tixiHandle, const std::string& xpath) const;
+
+ TIGL_EXPORT virtual const std::string& GetUID() const;
+ TIGL_EXPORT virtual void SetUID(const std::string& value);
+
+ TIGL_EXPORT virtual const boost::optional& GetSymmetry() const;
+ TIGL_EXPORT virtual void SetSymmetry(const boost::optional& value);
+
+ TIGL_EXPORT virtual const std::string& GetName() const;
+ TIGL_EXPORT virtual void SetName(const std::string& value);
+
+ TIGL_EXPORT virtual const boost::optional& GetDescription() const;
+ TIGL_EXPORT virtual void SetDescription(const boost::optional& value);
+
+ TIGL_EXPORT virtual const boost::optional& GetParentUID() const;
+ TIGL_EXPORT virtual void SetParentUID(const boost::optional& value);
+
+ TIGL_EXPORT virtual const CCPACSTransformation& GetTransformation() const;
+ TIGL_EXPORT virtual CCPACSTransformation& GetTransformation();
+
+ TIGL_EXPORT virtual const CCPACSVessels& GetVessels() const;
+ TIGL_EXPORT virtual CCPACSVessels& GetVessels();
+
+ protected:
+ CCPACSFuelTanks* m_parent;
+
+ CTiglUIDManager* m_uidMgr;
+
+ std::string m_uID;
+
+ boost::optional m_symmetry;
+
+ /// Name
+ std::string m_name;
+
+ /// Description
+ boost::optional m_description;
+
+ /// Parent component
+ boost::optional m_parentUID;
+
+ CCPACSTransformation m_transformation;
+
+ CCPACSVessels m_vessels;
+
+ private:
+ TIGL_EXPORT const CTiglUIDObject* GetNextUIDObject() const final;
+ TIGL_EXPORT void NotifyUIDChange(const std::string& oldUid, const std::string& newUid) final;
+
+ CPACSFuelTank(const CPACSFuelTank&) = delete;
+ CPACSFuelTank& operator=(const CPACSFuelTank&) = delete;
+
+ CPACSFuelTank(CPACSFuelTank&&) = delete;
+ CPACSFuelTank& operator=(CPACSFuelTank&&) = delete;
+ };
+} // namespace generated
+
+// CPACSFuelTank is customized, use type CCPACSFuelTank directly
+} // namespace tigl
diff --git a/src/generated/CPACSFuelTankVolume.cpp b/src/generated/CPACSFuelTankVolume.cpp
new file mode 100644
index 0000000000..c0c81cb9ff
--- /dev/null
+++ b/src/generated/CPACSFuelTankVolume.cpp
@@ -0,0 +1,239 @@
+// Copyright (c) 2020 RISC Software GmbH
+//
+// This file was generated by CPACSGen from CPACS XML Schema (c) German Aerospace Center (DLR/SC).
+// Do not edit, all changes are lost when files are re-generated.
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include
+#include "CCPACSVessel.h"
+#include "CPACSFuelTankVolume.h"
+#include "CTiglError.h"
+#include "CTiglLogging.h"
+#include "CTiglUIDObject.h"
+#include "TixiHelper.h"
+
+namespace tigl
+{
+namespace generated
+{
+ CPACSFuelTankVolume::CPACSFuelTankVolume(CCPACSVessel* parent)
+ : m_optimalVolume(0)
+ {
+ //assert(parent != NULL);
+ m_parent = parent;
+ }
+
+ CPACSFuelTankVolume::~CPACSFuelTankVolume()
+ {
+ }
+
+ const CCPACSVessel* CPACSFuelTankVolume::GetParent() const
+ {
+ return m_parent;
+ }
+
+ CCPACSVessel* CPACSFuelTankVolume::GetParent()
+ {
+ return m_parent;
+ }
+
+ const CTiglUIDObject* CPACSFuelTankVolume::GetNextUIDParent() const
+ {
+ return m_parent;
+ }
+
+ CTiglUIDObject* CPACSFuelTankVolume::GetNextUIDParent()
+ {
+ return m_parent;
+ }
+
+ void CPACSFuelTankVolume::ReadCPACS(const TixiDocumentHandle& tixiHandle, const std::string& xpath)
+ {
+ // read element optimalVolume
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/optimalVolume")) {
+ m_optimalVolume = tixi::TixiGetElement(tixiHandle, xpath + "/optimalVolume");
+ }
+ else {
+ LOG(ERROR) << "Required element optimalVolume is missing at xpath " << xpath;
+ }
+
+ // read element usableVolume
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/usableVolume")) {
+ m_usableVolume_choice1 = tixi::TixiGetElement(tixiHandle, xpath + "/usableVolume");
+ }
+
+ // read element realVolume
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/realVolume")) {
+ m_realVolume_choice1 = tixi::TixiGetElement(tixiHandle, xpath + "/realVolume");
+ }
+
+ // read element useableVolumeFactor
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/useableVolumeFactor")) {
+ m_useableVolumeFactor_choice2 = tixi::TixiGetElement(tixiHandle, xpath + "/useableVolumeFactor");
+ }
+
+ // read element realVolumeFactor
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/realVolumeFactor")) {
+ m_realVolumeFactor_choice2 = tixi::TixiGetElement(tixiHandle, xpath + "/realVolumeFactor");
+ }
+
+ if (!ValidateChoices()) {
+ LOG(ERROR) << "Invalid choice configuration at xpath " << xpath;
+ }
+ }
+
+ void CPACSFuelTankVolume::WriteCPACS(const TixiDocumentHandle& tixiHandle, const std::string& xpath) const
+ {
+ const std::vector childElemOrder = { "optimalVolume", "usableVolume", "realVolume", "useableVolumeFactor", "realVolumeFactor" };
+
+ // write element optimalVolume
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/optimalVolume", childElemOrder);
+ tixi::TixiSaveElement(tixiHandle, xpath + "/optimalVolume", m_optimalVolume);
+
+ // write element usableVolume
+ if (m_usableVolume_choice1) {
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/usableVolume", childElemOrder);
+ tixi::TixiSaveElement(tixiHandle, xpath + "/usableVolume", *m_usableVolume_choice1);
+ }
+ else {
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/usableVolume")) {
+ tixi::TixiRemoveElement(tixiHandle, xpath + "/usableVolume");
+ }
+ }
+
+ // write element realVolume
+ if (m_realVolume_choice1) {
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/realVolume", childElemOrder);
+ tixi::TixiSaveElement(tixiHandle, xpath + "/realVolume", *m_realVolume_choice1);
+ }
+ else {
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/realVolume")) {
+ tixi::TixiRemoveElement(tixiHandle, xpath + "/realVolume");
+ }
+ }
+
+ // write element useableVolumeFactor
+ if (m_useableVolumeFactor_choice2) {
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/useableVolumeFactor", childElemOrder);
+ tixi::TixiSaveElement(tixiHandle, xpath + "/useableVolumeFactor", *m_useableVolumeFactor_choice2);
+ }
+ else {
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/useableVolumeFactor")) {
+ tixi::TixiRemoveElement(tixiHandle, xpath + "/useableVolumeFactor");
+ }
+ }
+
+ // write element realVolumeFactor
+ if (m_realVolumeFactor_choice2) {
+ tixi::TixiCreateSequenceElementIfNotExists(tixiHandle, xpath + "/realVolumeFactor", childElemOrder);
+ tixi::TixiSaveElement(tixiHandle, xpath + "/realVolumeFactor", *m_realVolumeFactor_choice2);
+ }
+ else {
+ if (tixi::TixiCheckElement(tixiHandle, xpath + "/realVolumeFactor")) {
+ tixi::TixiRemoveElement(tixiHandle, xpath + "/realVolumeFactor");
+ }
+ }
+
+ }
+
+ bool CPACSFuelTankVolume::ValidateChoices() const
+ {
+ return
+ (
+ (
+ (
+ // mandatory elements of this choice must be there
+ true // m_usableVolume_choice1 is optional in choice
+ &&
+ true // m_realVolume_choice1 is optional in choice
+ &&
+ // elements of other choices must not be there
+ !(
+ m_useableVolumeFactor_choice2.is_initialized()
+ ||
+ m_realVolumeFactor_choice2.is_initialized()
+ )
+ )
+ +
+ (
+ // mandatory elements of this choice must be there
+ true // m_useableVolumeFactor_choice2 is optional in choice
+ &&
+ true // m_realVolumeFactor_choice2 is optional in choice
+ &&
+ // elements of other choices must not be there
+ !(
+ m_usableVolume_choice1.is_initialized()
+ ||
+ m_realVolume_choice1.is_initialized()
+ )
+ )
+ == 1
+ )
+ )
+ ;
+ }
+
+ const double& CPACSFuelTankVolume::GetOptimalVolume() const
+ {
+ return m_optimalVolume;
+ }
+
+ void CPACSFuelTankVolume::SetOptimalVolume(const double& value)
+ {
+ m_optimalVolume = value;
+ }
+
+ const boost::optional