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/OrientedChainedFrame2Frame.h"
#include"Karana/KCore/LockingBase.h"
#include"Karana/KCore/UsageTrackingMap.h"

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

namespaceKarana::Frame{
classFrame;
classSpiceFrame2Frame;

namespacekc=Karana::Core;

classFrameContainer:publickc::LockingBase{

//foraccessto_edgeOrientation
friendclassFrame2Frame;

//Foraccesstocontainerelementsfordiscard
friendclassFrame;
friendclassEdgeFrame2Frame;
friendclassChainedFrame2Frame;
friendclassOrientedChainedFrame2Frame;

//foraccessto_spce_f2fs_list
friendclassSpiceFrame2Frame;
friendclassSpiceFrame;

public:
FrameContainer();

virtual~FrameContainer();

virtualconststd::string&typeString()constnoexceptoverride;

statickc::ks_ptr<FrameContainer>create(conststd::string&root_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(conststd::string&prefix="",
constBase::dumpOptions*options=nullptr)constoverride;

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

std::vector<kc::ks_ptr<Frame>>lookupFrame(conststd::string&name);

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

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

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

voidtrackUsageEdgeFrame2Frame(constkc::ks_ptr<EdgeFrame2Frame>&f2f);

void
trackUsageOrientedChainedFrame2Frame(constkc::ks_ptr<OrientedChainedFrame2Frame>&of2f);

voidtrackUsageChainedFrame2Frame(constkc::ks_ptr<ChainedFrame2Frame>&cf2f);

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

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

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

std::vector<kc::ks_ptr<EdgeFrame2Frame>>edgeFrame2Frames();

std::vector<kc::ks_ptr<ChainedFrame2Frame>>chainedFrame2Frames();

//voidsetEphemerisTime(conststd::string&utc_time);

voidsetEphemerisTime(doubleephemeris_time);

doublegetEphemerisTime();

boolisUsingSpice();

voiddumpFrameTree(conststd::string&prefix,
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(constFrame2Frame&f2f,
constFrame2Frame&sub_f2f)const;

kc::RegistryList<Frame2Frame>_spice_f2fs_list;

private:
kc::UsageTrackingMap<kc::id_t, Frame>_frame_usage_map;
kc::UsageTrackingMap<kc::id_t, EdgeFrame2Frame>_edge_usage_map;
kc::UsageTrackingMap<std::pair<kc::id_t, kc::id_t>,ChainedFrame2Frame>_chain_usage_map;
kc::UsageTrackingMap<std::pair<kc::id_t, kc::id_t>,OrientedChainedFrame2Frame>
_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