// $Header: /cvs/gled-1.2/GledCore/Glasses/ZGlass.cxx,v 1.5 2004/06/03 12:23:39 matevz Exp $
// Copyright (C) 1999-2004, Matevz Tadel. All rights reserved.
// This file is part of GLED, released under GNU General Public License version 2.
// For the licensing terms see $GLEDSYS/LICENSE or http://www.gnu.org/.
//______________________________________________________________________
// ZGlass
//
// Base of Gled enabled classes.
// Provides infrastructure for integration with the Gled system.
//
// mGlassBits: collection of flags that allow (optimised) handling of lenses.
#include "ZGlass.h"
#include "ZGlass.c7"
#include <Ephra/Saturn.h>
#include <Glasses/ZList.h>
#include <Glasses/ZQueen.h>
#include <Glasses/ZKing.h>
#include <Glasses/ZMirFilter.h>
#include <Stones/ZMIR.h>
#include <Stones/ZComet.h>
/**************************************************************************/
namespace ZGlassBits {
UShort_t kFixedName = 0x1;
UShort_t kDying = 0x2;
}
/**************************************************************************/
ClassImp(ZGlass)
/**************************************************************************/
void ZGlass::_init()
{
mSaturn = 0; mQueen = 0; mMir = 0;
mGlassBits = 0; mSaturnID=0;
mGuard = 0;
bMIRActive = true; bAcceptRefs = true;
mRefCount = mMoonRefCount = mSunRefCount = mFireRefCount = 0;
mTimeStamp = mStampReqTring = 0;
pSetYNameCBs = 0;
mStamp_CB=mStampLink_CB=0; mStamp_CBarg=mStampLink_CBarg=0;
}
/**************************************************************************/
void ZGlass::reference_all() {
lppZGlass_t link_refs;
CopyLinkRefs(link_refs);
for(lppZGlass_i i=link_refs.begin(); i!=link_refs.end(); ++i) {
if(**i) {
try {
(**i)->IncRefCount(this);
}
catch(string exc) {
**i = 0;
}
}
}
}
void ZGlass::unreference_all() {
lppZGlass_t link_refs;
CopyLinkRefs(link_refs);
for(lppZGlass_i i=link_refs.begin(); i!=link_refs.end(); ++i) {
if(**i) {
(**i)->DecRefCount(this);
}
}
}
/**************************************************************************/
void ZGlass::remove_references_to(ZGlass* lens)
{
// Removes all references to *lens*.
// Heavily virtual ... lists overrirde it but also call the ZGlass version
// for unreferencing of links.
// Calls DecRefCount and emits Rays.
lppZGlass_t link_refs;
CopyLinkRefs(link_refs);
int n = 0;
for(lppZGlass_i i=link_refs.begin(); i!=link_refs.end(); ++i) {
if(**i == lens) {
(**i)->DecRefCount(this);
**i = 0;
++n;
}
}
if(n) StampLink();
}
/**************************************************************************/
string ZGlass::Identify() const
{
return string(GForm("'%s'[%d]", mName.Data(), mSaturnID));
}
/**************************************************************************/
void ZGlass::WriteLock()
{
if(mQueen) mQueen->SubjectWriteLock();
ReadLock();
}
void ZGlass::WriteUnlock()
{
ReadUnlock();
if(mQueen) mQueen->SubjectWriteUnlock();
}
/**************************************************************************/
void ZGlass::assert_MIR_presence(const string& header, int what)
{
if(mMir == 0) {
throw(header + "must be called via a MIR.");
}
if((what & MC_IsFlare) && mMir->HasRecipient()) {
throw(header + "must be called via a flared MIR.");
}
if((what & MC_IsBeam) && !mMir->HasRecipient()) {
throw(header + "must be called via a beamed MIR.");
}
if((what & MC_HasResultReq) && !mMir->HasResultReq()) {
throw(header + "must be called with result request set.");
}
}
/**************************************************************************/
// YNameChangeCB
typedef set<ZGlass::YNameChangeCB*> spYNameChangeCB_t;
typedef set<ZGlass::YNameChangeCB*>::iterator spYNameChangeCB_i;
void ZGlass::register_name_change_cb(ZGlass::YNameChangeCB* rec)
{
if(mGlassBits & ZGlassBits::kFixedName) return;
ReadLock();
if(pSetYNameCBs == 0)
pSetYNameCBs = new set<YNameChangeCB*>;
pSetYNameCBs->insert(rec);
ReadUnlock();
}
void ZGlass::unregister_name_change_cb(ZGlass::YNameChangeCB* rec)
{
ReadLock();
if(pSetYNameCBs != 0)
pSetYNameCBs->erase(rec);
ReadUnlock();
}
/**************************************************************************/
void ZGlass::SetName(const Text_t* n)
{
if(mGlassBits & ZGlassBits::kFixedName) {
Stamp(LibID(), ClassID());
throw(string("ZGlass::SetName lens has FixedName bit set"));
}
string name(n);
WriteLock();
if(pSetYNameCBs != 0) {
for(set<YNameChangeCB*>::iterator i=pSetYNameCBs->begin(); i!=pSetYNameCBs->end(); ++i) {
(*i)->y_name_change_cb(this, name);
}
}
mName = name.c_str();
Stamp(LibID(), ClassID());
WriteUnlock();
if(mMir && mQueen == this && ! mMir->HasRecipient()) {
mQueen->BasicQueenChange(*mMir);
}
}
void ZGlass::SetTitle(const Text_t* t)
{
WriteLock();
mTitle = t;
Stamp(LibID(), ClassID());
WriteUnlock();
if(mMir && mQueen == this && ! mMir->HasRecipient()) {
mQueen->BasicQueenChange(*mMir);
}
}
/**************************************************************************/
ZMirFilter* ZGlass::GetGuard() const
{
ReadLock();
ZMirFilter* _ret = mGuard;
ReadLock();
return _ret;
}
void ZGlass::SetGuard(ZMirFilter* guard)
{
WriteLock();
try { set_link_or_die((ZGlass*&)mGuard, guard, LibID(), ClassID()); }
catch(...) { WriteUnlock(); throw; }
WriteUnlock();
}
/**************************************************************************/
ZGlass::~ZGlass()
{
// !!!!! Should unref all links; check zlist, too
delete pSetYNameCBs;
}
/**************************************************************************/
void ZGlass::UpdateGlassView()
{
if(mQueen) {
Ray r(Ray::RQN_change, mTimeStamp, this, LibID(), ClassID());
mQueen->EmitRay(r, true);
}
if(mStamp_CB) mStamp_CB(this, mStamp_CBarg);
}
void ZGlass::UpdateAllViews()
{
if(mQueen) {
Ray r(Ray::RQN_change, mTimeStamp, this, LID_t(0), CID_t(0));
mQueen->EmitRay(r, true);
}
if(mStamp_CB) mStamp_CB(this, mStamp_CBarg);
}
/**************************************************************************/
bool ZGlass::IsSunSpace()
{
// Returns true if this lens is in local Saturn's sun-space.
ZKing* sk = mSaturn->GetKing();
return (mSaturnID >= sk->GetMinID() && mSaturnID <= sk->GetMaxID());
}
bool ZGlass::IsSunOrFireSpace()
{
// Returns true if this lens is in local Saturn's sun or fire-space.
return (mSaturnID >= mSaturn->GetKing()->GetMinID());
}
/**************************************************************************/
Short_t ZGlass::IncRefCount(ZGlass* from)
{
// Called to notify *this* that *from* desires to reference it.
// Throws an exception if the reference is not allowed by *this*
// lens or its queen.
static const string _eh("ZGlass::IncRefCount ");
if(mQueen && from->mQueen) {
mQueen->SubjectRefCntLock();
// !!! Here ask queen if it's OK
if(!bAcceptRefs) {
mQueen->SubjectRefCntUnlock();
throw(_eh + "lens not accepting references.");
}
switch(from->mQueen->GetKing()->GetLightType()) {
case ZKing::LT_Moon:
++mMoonRefCount; ++mRefCount; mReverseRefs.push_front(from);
break;
case ZKing::LT_Sun:
++mSunRefCount; ++mRefCount; mReverseRefs.push_back(from);
break;
case ZKing::LT_Fire:
++mFireRefCount; ++mRefCount; mReverseRefs.push_back(from);
break;
default:
mQueen->SubjectRefCntUnlock();
throw(_eh + "King in undefined state. Ignoring.");
}
mQueen->SubjectRefCntUnlock();
// Stamp(LibID(), ClassID());
}
return mRefCount;
}
Short_t ZGlass::DecRefCount(ZGlass* from)
{
// Called to notify *this* that it is no longer referenced by lens from.
if(mQueen && from->mQueen) {
mQueen->SubjectRefCntLock();
switch(from->mQueen->GetKing()->GetLightType()) {
case ZKing::LT_Moon: {
lpZGlass_i i = find(mReverseRefs.begin(), mReverseRefs.end(), from);
if(i != mReverseRefs.end()) {
--mMoonRefCount; --mRefCount;
mReverseRefs.erase(i);
}
break;
}
case ZKing::LT_Sun: {
lpZGlass_ri i = find(mReverseRefs.rbegin(), mReverseRefs.rend(), from);
if(i != mReverseRefs.rend()) {
--mSunRefCount; --mRefCount;
mReverseRefs.erase((++i).base());
}
break;
}
case ZKing::LT_Fire: {
lpZGlass_ri i = find(mReverseRefs.rbegin(), mReverseRefs.rend(), from);
if(i != mReverseRefs.rend()) {
--mFireRefCount; --mRefCount;
mReverseRefs.erase((++i).base());
}
break;
}
default:
ISerr("ZGlass::IncRefCount King in undefined state");
}
if(mRefCount == 0 && mQueen) mQueen->ZeroRefCount(this);
mQueen->SubjectRefCntUnlock();
// Stamp(LibID(), ClassID());
}
return mRefCount;
}
/**************************************************************************/
void ZGlass::ClearLinks()
{
lppZGlass_t link_refs;
CopyLinkRefs(link_refs);
int n = 0;
for(lppZGlass_i i=link_refs.begin(); i!=link_refs.end(); ++i) {
if(**i) {
(**i)->DecRefCount(this);
**i = 0;
++n;
}
}
if(n) StampLink();
}
void ZGlass::ClearAllReferences()
{
ClearLinks();
}
/**************************************************************************/
ZGlass* ZGlass::GetLinkByName(const Text_t* link_name)
{ return GetLinkByName(string(link_name)); }
ZGlass* ZGlass::GetLinkByName(const string& link_name)
{
// Returns glass pointed to by link with name link_name.
// Attempts link_name == LinkMemberName and
// link_name == Class::LinkMemberName.
// Throws an exception (string) if link does not exist.
// In principle could have a map link-name->link-specs.
// Should go in reverse direction !!!!
// Locking doesn't make much sense.
lLinkSpec_t ls; CopyLinkSpecs(ls);
for(lLinkSpec_i i=ls.begin(); i!=ls.end(); ++i) {
if(link_name == i->fLinkName || link_name == i->full_name())
return i->fLinkRef;
}
throw(string(GForm("ZGlass::GetLinkByName link '%s' does not exist in '%s' (id=%u)",
link_name.c_str(), GetName(), GetSaturnID())));
}
ZGlass* ZGlass::FindLensByPath(const Text_t* url)
{ return FindLensByPath(string(url)); }
ZGlass* ZGlass::FindLensByPath(const string& url)
{
static const string _eh("ZGlass::FindLensByPath ");
using namespace GledNS;
list<url_token> l;
tokenize_url(url, l);
ZGlass* g = this;
try {
for(list<url_token>::iterator i=l.begin(); i!=l.end(); ++i) {
if(g == 0) {
// !!! give more details
throw(_eh + "null lens; probably a link is not set");
}
switch (i->type()) {
case url_token::link_sel: {
g = g->GetLinkByName(*i);
break;
}
case url_token::list_sel: {
ZList* l = dynamic_cast<ZList*>(g);
if(l == 0) {
// !!! give more details
throw(_eh + "url element is not a list");
}
g = l->GetElementByName(*i);
break;
}
default:
ISerr(_eh + "unknown token type. Attempting to ignore ...");
break;
}
}
}
catch(string exc) {
ISerr(exc);
throw;
}
return g;
}
/**************************************************************************/
// All stamp functions should be *inline*!!
TimeStamp_t ZGlass::Stamp(LID_t lid, CID_t cid)
{
++mTimeStamp;
if(mQueen) {
Ray r(Ray::RQN_change, mTimeStamp, this, lid, cid);
mQueen->EmitRay(r);
}
if(mStamp_CB) mStamp_CB(this, mStamp_CBarg);
return mTimeStamp;
}
TimeStamp_t ZGlass::StampLink(LID_t lid, CID_t cid)
{
++mTimeStamp;
if(mQueen) {
Ray r(Ray::RQN_link_change, mTimeStamp, this, lid, cid);
mQueen->EmitRay(r);
}
if(mStampLink_CB) mStampLink_CB(this, mStampLink_CBarg);
return mTimeStamp;
}
void ZGlass::SetStamp_CB(zglass_stamp_f foo, void* arg)
{
mStamp_CB = foo; mStamp_CBarg = arg;
}
void ZGlass::SetStampLink_CB(zglass_stamp_f foo, void* arg)
{
mStampLink_CB = foo; mStampLink_CBarg = arg;
}
/**************************************************************************/
Int_t ZGlass::RebuildAll(An_ID_Demangler* idd)
{
return RebuildLinks(idd);
}
ROOT page - Home page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.