Program Listing for File FrameContainer.h

↰ Return to documentation for file (include/Karana/Frame/FrameContainer.h)

/*
*Copyright(c)2024-2025KaranaDynamicsPtyLtd.Allrightsreserved.
*
*NOTICETOUSER:
*
*Thissourcecodeand/ordocumentation(the"LicensedMaterials")is
*theconfidentialandproprietaryinformationofKaranaDynamicsInc.
*UseoftheseLicensedMaterialsisgovernedbythetermsandconditions
*ofaseparatesoftwarelicenseagreementbetweenKaranaDynamicsandthe
*Licensee("LicenseAgreement").Unlessexpresslypermittedunderthat
*agreement,anyreproduction,modification,distribution,ordisclosure
*oftheLicensedMaterials,inwholeorinpart,toanythirdparty
*withoutthepriorwrittenconsentofKaranaDynamicsisstrictlyprohibited.
*
*THELICENSEDMATERIALSAREPROVIDED"ASIS"WITHOUTWARRANTYOFANYKIND.
*KARANADYNAMICSDISCLAIMSALLWARRANTIES,EXPRESSORIMPLIED,INCLUDING
*BUTNOTLIMITEDTOWARRANTIESOFMERCHANTABILITY,NON-INFRINGEMENT,AND
*FITNESSFORAPARTICULARPURPOSE.
*
*INNOEVENTSHALLKARANADYNAMICSBELIABLEFORANYDAMAGESWHATSOEVER,
*INCLUDINGBUTNOTLIMITEDTOLOSSOFPROFITS,DATA,ORUSE,EVENIF
*ADVISEDOFTHEPOSSIBILITYOFSUCHDAMAGES,WHETHERINCONTRACT,TORT,
*OROTHERWISEARISINGOUTOFORINCONNECTIONWITHTHELICENSEDMATERIALS.
*
*U.S.GovernmentEndUsers:TheLicensedMaterialsarea"commercialitem"
*asdefinedat48C.F.R.2.101,andareprovidedtotheU.S.Government
*onlyasacommercialenditemunderthetermsofthislicense.
*
*AnyuseoftheLicensedMaterialsinindividualorcommercialsoftwaremust
*include,intheuserdocumentationandinternalsourcecodecomments,
*thisNotice,Disclaimer,andU.S.GovernmentUseProvision.
*/


#pragmaonce

#include<memory>
#include<string>

#include"Karana/Frame/OrientedChainedFrameToFrame.h"
#include"Karana/KCore/LockingBase.h"
#include"Karana/KCore/UsageTrackingMap.h"

#include"Karana/Frame/EdgeFrameToFrame.h"
#include"Karana/Frame/Frame.h"
#include"Karana/KCore/Tree.h"

namespaceKarana::Frame{
classFrame;
classSpiceFrameToFrame;

namespacekc=Karana::Core;

classFrameContainer:publickc::LockingBase{

//foraccessto_edgeOrientation
friendclassFrameToFrame;

//Foraccesstocontainerelementsfordiscard
friendclassFrame;
friendclassEdgeFrameToFrame;
friendclassChainedFrameToFrame;
friendclassOrientedChainedFrameToFrame;

//foraccessto_spce_f2fs_list
friendclassSpiceFrameToFrame;
friendclassSpiceFrame;

//foraccesstotrackUsagemethods
friendclassPrescribedFrameToFrame;

public:
FrameContainer();

virtual~FrameContainer();

statickc::ks_ptr<FrameContainer>create(std::string_viewroot_frame_name);

structDumpOptions:LockingBase::DumpOptions{

boolframes=false;
booledges=false;
booloriented=false;
boolchains=false;

DumpOptions&operator=(constDumpOptions&p){
if(this!=&p){
LockingBase::DumpOptions::operator=(p);//Callbaseclassassignmentoperator
//AssignDerived-specificmembershere
frames=p.frames;
edges=p.edges;
oriented=p.oriented;
chains=p.chains;
}

return*this;
}
};

std::stringdumpString(std::string_viewprefix="",
constBase::DumpOptions*options=nullptr)constoverride;

constkc::ks_ptr<Frame>&root()const;

std::vector<kc::ks_ptr<Frame>>lookupFrame(std::string_viewname);

boolisAncestorOf(constFrame&oframe,constFrame&pframe,boolstrict);

constkc::ks_ptr<Frame>&getAncestor(constFrame&frame1,constFrame&frame2);

public:
/*thesearepublicforusebySOADyn*/

voidtrackUsageFrame(constkc::ks_ptr<Frame>&frame);

voidtrackUsageEdgeFrameToFrame(constkc::ks_ptr<EdgeFrameToFrame>&f2f);

void
trackUsageOrientedChainedFrameToFrame(constkc::ks_ptr<OrientedChainedFrameToFrame>&of2f);

voidtrackUsageChainedFrameToFrame(constkc::ks_ptr<ChainedFrameToFrame>&cf2f);

std::vector<kc::ks_ptr<ChainedFrameToFrame>>chainedFrameToFrames();

public:
std::vector<kc::ks_ptr<Frame>>frames();

std::vector<kc::ks_ptr<EdgeFrameToFrame>>edgeFrameToFrames();

voidfreezeUpstream(constkc::ks_ptr<Frame>&frame);

voidunfreezeUpstream(constkc::ks_ptr<Frame>&frame);

voidsetEphemerisTime(doubleephemeris_time);

doublegetEphemerisTime();

boolisUsingSpice();

voiddumpFrameTree(std::string_viewprefix,
constFrame&f,
conststd::function<std::string(constFrame&)>&callback)const;

conststd::unique_ptr<constkc::Tree<kc::id_t>>&tree(){return_tree;}

protected:
void_discard(kc::ks_ptr<Base>&base)override;

//void_ensureTree();
void_makeStale()override;
void_makeCurrent()override;

std::optional<bool>_subchainOrientation(constFrameToFrame&f2f,
constFrameToFrame&sub_f2f)const;

kc::RegistryList<FrameToFrame>_spice_f2fs_list;

private:
kc::UsageTrackingMap<kc::id_t, Frame>_frame_usage_map;
kc::UsageTrackingMap<kc::id_t, EdgeFrameToFrame>_edge_usage_map;
kc::UsageTrackingMap<std::pair<kc::id_t, kc::id_t>,ChainedFrameToFrame>_chain_usage_map;
kc::UsageTrackingMap<std::pair<kc::id_t, kc::id_t>,OrientedChainedFrameToFrame>
_oriented_chain_usage_map;
mutablestd::unique_ptr<constkc::Tree<kc::id_t>>_tree;

kc::ks_ptr<Frame>_root_frame;
double_ephemeris_time=km::uninitializedNaN;
};
}//namespaceKarana::Frame