DFAgent.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#include "FactoryItem.h"

#ifndef ADF_DFAgent
#include "DFAgent.h"
#endif
#ifndef ADF_KeyFactory
#include "KeyFactory.h"
#endif 
#ifndef ADF_ConfigurationFrame
#include "ConfigurationFrame.h"
#endif

#include <ctime>
#include <fstream>
#include <cstdlib>

using namespace ADF;
using namespace std;

DFAgent::DFAgent(const Char_t *rid, const Char_t *srid, Bool_t is_record, Bool_t global) : 
        DotConf(rid,srid,is_record),
        fModel(ConfAgent::kStrict), 
        fEndian(BaseBuffer::kLittle),
        fPrimaryKey("Default","FS",Version(0,1)) ,
        fAutoConf(),
        fListOfFrames(),
        fListOfRequiredKeyFactories(),
        fListOfRequiredFrameFactories(),
        fListOfKeyFactories(),
        fListOfFrameFactories()
{ 
        fLog.GetProcessName() = "ADF::DFAgent"; 
        SetMaxVersion(1);
        
        // keep a list of reference to the global factories by default.
        LinkFactories(global);
        
        // frame for automatic reconfiguration
        fAutoConf.first  = FactoryItem("NONE","NONE",Version(0,0));     
        fAutoConf.second = FactoryItem("NONE","NONE",Version(0,0));
} 

DFAgent::~DFAgent() 
{
        fListOfFrames.clear(); fListOfRequiredKeyFactories.clear(); fListOfRequiredFrameFactories.clear(); fListOfKeyFactories.clear(); fListOfFrameFactories.clear(); 
}

void DFAgent::LinkFactories(Bool_t global)
{
        if ( global ) {
                // Collect the list of key and frame factories from the MainFactories
                for (UInt_t i = 0u; i < MainKeyFactory::theMainFactory().ListOfFactories().size(); i++) {
                        // keep the pointer
                        fListOfKeyFactories.push_back(MainKeyFactory::theMainFactory().ListOfFactories()[i]);
                }
        }
        else 
                MainKeyFactory::theMainFactory().Clone(fListOfKeyFactories);
        // now add they back as configurable objects
        std::list< KeyFactory * >::iterator 
                key_listed_item; 
        for ( key_listed_item = fListOfKeyFactories.begin() ; key_listed_item != fListOfKeyFactories.end() ; key_listed_item++ ) {
                // add it the list of reconfigurable objects
                AddConf((*key_listed_item));
        }       
        
        if ( global ) {
                for (UInt_t i = 0u; i < MainFrameFactory::theMainFactory().ListOfFactories().size(); i++) {
                        // keep the pointer
                        fListOfFrameFactories.push_back(MainFrameFactory::theMainFactory().ListOfFactories()[i]);
                }                       
        }
        else
                MainFrameFactory::theMainFactory().Clone(fListOfFrameFactories);
        // now add as configurable objects
        std::list< FrameFactory * >::iterator 
                frame_listed_item; 
        for ( frame_listed_item = fListOfFrameFactories.begin() ; frame_listed_item != fListOfFrameFactories.end() ; frame_listed_item++ ) {
                // add it the list of reconfigurable objects
                AddConf((*frame_listed_item));
        }       
}

KeyFactory *DFAgent::GetKeyFactory(const FactoryItem &item) 
{
        KeyFactory *fact = 0x0;
        
        std::list< KeyFactory * >::iterator 
                listed_item; 
        for ( listed_item = fListOfKeyFactories.begin(); listed_item != fListOfKeyFactories.end() ; listed_item++ ) {
                if ( ((*listed_item)->GetName() == item.GetFactoryName()) && ((*listed_item)->GetMaxVersion() >= item.GetFactoryVersion()) ) {
                        fact = (*listed_item);
                }
        }       
        return fact;
}

FrameFactory *DFAgent::GetFrameFactory(const FactoryItem &item)
{
        FrameFactory *fact = 0x0;
        
        std::list< FrameFactory * >::iterator 
                listed_item; 
        for ( listed_item = fListOfFrameFactories.begin(); listed_item != fListOfFrameFactories.end() ; listed_item++ ) {
                if ( (*listed_item)->GetName() == item.GetFactoryName() && (*listed_item)->GetMaxVersion() >= item.GetFactoryVersion() ) {
                        fact = (*listed_item);
                }
        }       
        return fact;
}

Bool_t DFAgent::SetKnownKeyFactory(const FactoryItem &factory_item)
{       
        // check the asked factory is known and compatible with the current version
        KeyFactory *factory = GetKeyFactory(factory_item);
        if ( factory == 0x0 )
                return false;

        // -1 : new, +1 already in the list and modified for the new conditions, 0 remove because of incompatible version #
        Short_t what = -1;

        // if already in the list, just change the version or remove it if incompatible versions
        std::list< FactoryItem >::iterator 
                listed_item; 
        for ( listed_item = fListOfRequiredKeyFactories.begin() ; listed_item != fListOfRequiredKeyFactories.end() ; listed_item++ ) {
                if ( (*listed_item).GetFactoryName() == factory_item.GetFactoryName() ) {
                        // already in the list
                        if ( (*listed_item).GetFactoryVersion() >= factory_item.GetFactoryVersion() ) {
                                (*listed_item).SetFactoryVersion(factory_item.GetFactoryVersion());
                                (*listed_item).SetFactoryPtr(factory);
                                //
                                what = 1;
                        }
                        else { // incompatible ==> remove from the list
                                fListOfRequiredKeyFactories.remove((*listed_item));
                                //
                                what = 0;
                        }
                        break;
                }
        }       
        
        if ( what == -1 ) { // not yet known, add a new item in the list
                FactoryItem l_item(factory_item); 
                //
                l_item.SetFactoryPtr(factory);
                fListOfRequiredKeyFactories.push_back(l_item);
        }
        
        return what != 0;
}
 
Bool_t DFAgent::SetKnownFrameFactory(const FactoryItem &factory_item)
{       
        // check the asked factory is known and compatible with the current version
        FrameFactory *factory = GetFrameFactory(factory_item);
        if ( factory == 0x0 )
                return false;
        
        // -1 : new, +1 already in the list and modified for the new conditions, 0 remove because of incompatible version #
        Short_t what = -1;
        
        // if already in the list, just change the version or remove it if incompatible versions 
        std::list< FactoryItem >::iterator 
                listed_item; 
        for ( listed_item = fListOfRequiredFrameFactories.begin() ; listed_item != fListOfRequiredFrameFactories.end() ; listed_item++ ) {
                if ( (*listed_item).GetFactoryName() == factory_item.GetFactoryName() ) {
                        // already in the list
                        if ( (*listed_item).GetFactoryVersion() >= factory_item.GetFactoryVersion() ) {
                                (*listed_item).SetFactoryVersion(factory_item.GetFactoryVersion());
                                (*listed_item).SetFactoryPtr(factory);
                                //
                                what = 1;
                        }
                        else { // incompatible ==> remove from the list
                                fListOfRequiredFrameFactories.remove((*listed_item));
                                //
                                what = 0;
                        }
                        break;
                }
        }       
        
        if ( what == -1 ) { // not yet known, add a new item in the list
                FactoryItem l_item(factory_item); 
                //
                l_item.SetFactoryPtr(factory);
                fListOfRequiredFrameFactories.push_back(l_item);
        }
        
        return what != 0;
}

Bool_t DFAgent::SetAsCompatibleKeyItem(FactoryItem &factory_item) const
{
        Bool_t ok = false;
        
        std::list< FactoryItem >::iterator 
                listed_item; 
        for ( listed_item = fListOfRequiredKeyFactories.begin() ; listed_item != fListOfRequiredKeyFactories.end() ; listed_item++ ) {  
                if ( (*listed_item).GetFactoryName() == factory_item.GetFactoryName() ) {
                        
                        factory_item.SetFactoryVersion((*listed_item).GetFactoryVersion());
                        factory_item.SetFactoryPtr((*listed_item).GetFactoryPtr());                             
                        
                        ok = true;
                        
                        break;
                }
        }
        return ok;
}

Bool_t DFAgent::SetAsCompatibleFrameItem(FactoryItem &factory_item) const
{
        Bool_t ok = false;

        std::list< FactoryItem >::iterator 
                listed_item; 
        for ( listed_item = fListOfRequiredFrameFactories.begin() ; listed_item != fListOfRequiredFrameFactories.end() ; listed_item++ ) {      
                if ( (*listed_item).GetFactoryName() == factory_item.GetFactoryName() ) {
                        
                        factory_item.SetFactoryVersion((*listed_item).GetFactoryVersion());
                        factory_item.SetFactoryPtr((*listed_item).GetFactoryPtr());     
                        
                        ok = true;
                        
                        break;
                }
        }
        return ok;
}

const FactoryItem &DFAgent::GetPrimaryKey() const
{ 
        return fPrimaryKey;
}

void DFAgent::SetPrimaryKey(const FactoryItem &item)
{
        fPrimaryKey = item;     
}
        
void DFAgent::AddKnownFrame(const FactoryItem &item_key, const FactoryItem &item_frame, const Char_t opt)
{               
        // in case reset of the known frame is asked
        if ( opt == 'r' ) 
                fListOfFrames.clear();

        Bool_t ok = false;
        //
        std::list< std::pair<FactoryItem,FactoryItem> >::iterator 
                listed_item; 
        for ( listed_item = fListOfFrames.begin() ; listed_item != fListOfFrames.end() ; listed_item++ ) {
                if ( (*listed_item).first.IsAVersion(item_key) && (*listed_item).second.IsAVersion(item_frame) ) {
                        if ( opt == '-' )
                                fListOfFrames.remove((*listed_item));
                        else {
                                (*listed_item).first.SetVersion(item_key.GetVersion());
                                (*listed_item).second.SetVersion(item_frame.GetVersion());                              
                                ok = true;
                        }
                        break;
                }
        }       
        if ( !ok ) {
                pair <FactoryItem,FactoryItem> p;
                p.first  = item_key;
                p.second = item_frame;
        
                fListOfFrames.push_back(p);
        }
}

void DFAgent::AddKnownFrame(const Frame *frame, const Char_t opt)
{
        if ( frame ) 
                AddKnownFrame(frame->GetKey()->GetSignature(),frame->GetSignature(),opt);
}

void DFAgent::Reset(const Char_t *opt)
{
        // Reset only this not the list of factories associated !
        std::string option = opt;

        /*fComment = "Reset"; */ SetLastModif();
        
        fEndian = BaseBuffer::kLittle;  
        fPrimaryKey  = FactoryItem("Default","FS",Version(0,1));
        
        fAutoConf.first  = FactoryItem("NONE","NONE",Version(0,0));     
        fAutoConf.second = FactoryItem("NONE","NONE",Version(0,0));     
                
        fListOfFrames.clear(); fListOfRequiredKeyFactories.clear(); fListOfRequiredFrameFactories.clear();  
}

void DFAgent::SetEndian(BaseBuffer::EEndian e)
{
        if ( fEndian == e )
                return;
        
        // change local 
        fEndian = BaseBuffer::kLittle;
        // and apply modification to all the key factories related to this agent
        std::list< KeyFactory * >::iterator 
        listed_item; 
        for ( listed_item = fListOfKeyFactories.begin(); listed_item != fListOfKeyFactories.end() ; listed_item++ ) {
                (*listed_item)->SetEndian(e);
        }       
}
 
UShort_t DFAgent::IsAKnownFrame (const FactoryItem &to_key, const FactoryItem &to_frame, PF_FactoryItemChange pfk, PF_FactoryItemChange pff) const
{
        UShort_t ok; Bool_t ok_key, ok_frame; FactoryItem l_to_key(to_key), l_to_frame(to_frame);
        
        // set version and factory instance for the items as known by the Agent
        SetAsCompatibleItems(l_to_key, l_to_frame);
        // now look if pure item part is known under the required changes
        ok = 0u;
        std::list< std::pair<FactoryItem,FactoryItem> >::iterator 
                listed_item; 
        for ( listed_item = fListOfFrames.begin() ; listed_item != fListOfFrames.end() ; listed_item++ ) {
                ok_key   = pfk ( (*listed_item).first  , l_to_key );     
                ok_frame = pff ( (*listed_item).second , l_to_frame );  
                if ( ok_key && ok_frame )
                        { ok++; }       
        }
        return ok;
}

FactoryItem DFAgent::WhichKnownKey (const FactoryItem &to_key, const FactoryItem &to_frame, PF_FactoryItemChange pfk, PF_FactoryItemChange pff) const
{
        FactoryItem ok; Bool_t ok_key, ok_frame;
        
        std::list< pair<FactoryItem,FactoryItem> >::iterator 
                listed_item; 
        for ( listed_item = fListOfFrames.begin() ; listed_item != fListOfFrames.end() ; listed_item++ ) {
                ok_key   = pfk ( (*listed_item).first  , to_key );       
                ok_frame = pff ( (*listed_item).second , to_frame );    
                if ( ok_key && ok_frame ) { 
                        ok = (*listed_item).first; 
                        break; 
                }
        }
        return ok;
}

FactoryItem DFAgent::WhichKnownFrame (const FactoryItem &to_key, const FactoryItem &to_frame, PF_FactoryItemChange pfk, PF_FactoryItemChange pff) const
{
        FactoryItem ok; Bool_t ok_key, ok_frame;
        
        std::list< pair<FactoryItem,FactoryItem> >::iterator 
        listed_item; 
        for ( listed_item = fListOfFrames.begin() ; listed_item != fListOfFrames.end() ; listed_item++ ) {
                ok_key   = pfk ( (*listed_item).first  , to_key );       
                ok_frame = pff ( (*listed_item).second , to_frame );    
                if ( ok_key && ok_frame ){
                        ok = (*listed_item).second; 
                        break; 
                }
        }
        return ok;
}

Bool_t DFAgent::ProcessLine(const string &aline)
{
        string tmp1, tmp2, tmp3, tmp4, tmp5; UInt_t ui1, ui2, ui3, ui4, ui5; FactoryItem factory_item;
        
        // true unless something wrong
        Bool_t ok_decode = true;
                
        //endian of the data flow
        if ( aline.find("Endian:") == 0 ) { 
        // keyword : endian - actions : change local data member and apply modifications to all the factories linked with this
                istringstream decode(aline);
                // just to be sure ...
                decode.clear(); 
                decode >> tmp1 >> tmp2;
                if ( decode.good() ) { // expected format
                        if ( tmp2 == "kLittle" ) {
                                SetEndian(BaseBuffer::kLittle);
                        }
                        if ( tmp2 == "kBig" ) { 
                                SetEndian(BaseBuffer::kBig);    
                        }
                        
                }
                else ok_decode = false;
        }       
        
        // check if needed Key factories exist
        if ( aline.find("KeyFactory:") == 0 ) { 
        // keyword : Keyfactory - action : check the factory exists and in case add it to the list of known factories
                istringstream decode(aline);
                // just to be sure ...
                decode.clear();                         
                decode >> tmp1 >> tmp2 ;
                if ( decode.good() ) { // expected format
                        // now check for KeyFactory version and add to the known list of factory only if the version number is not greater that the registered one
                        Short_t factory_version; decode >> factory_version;
                        //
                        if ( ! decode.good() ) 
                                factory_version = -1; // if not given means unversionned
                        //
                        factory_item.SetItem(tmp2.data(),factory_version,"",Version(0,0));
                        if ( ! SetKnownKeyFactory(factory_item) ) {
                                fLog << error 
                                     << "The KeyFactory " << factory_item << " is not registered !! \n";
                        }
                }
                else ok_decode = false;
        }// tmp.find("KeyFactory:") == 0 check if needed factories exist

        // check needed Frame factories exist
        if ( aline.find("FrameFactory:") == 0 ) { // keyword : Framefactory - action : check the factory exists and in case add it to the list of known factories
                istringstream decode(aline);
                // just to be sure ...
                decode.clear(); 
                decode >> tmp1 >> tmp2 ;
                if ( decode.good() ) { // expected format
                        // now check for Factory version and add to the known list of factory only if the version number is not greater that the registered one
                        Short_t factory_version; decode >> factory_version;
                        //
                        if ( ! decode.good() ) 
                                factory_version = -1; // if not given means unversionned
                        
                        factory_item.SetItem(tmp2.data(),factory_version,"",Version(0,0));
                        if ( ! SetKnownFrameFactory(factory_item) ) {
                                fLog << error 
                                         << "The Frame Factory " << factory_item << " is not registered !! \n";
                        }                       
                }
                else ok_decode = false;
        }// tmp.find("FrameFactory:") == 0 check needed factories exist

        if ( aline.find("PrimaryKey:") == 0 ) { 
        // Keyword : PrimaryKey - action : check if the key exist. this should be a simple key, that exists whatever the factory versions and configuration, so check if it exists before changes
                istringstream decode(aline);
                // just to be sure ...
                decode.clear(); 
                decode >> tmp1 >> tmp2 >> tmp3 >> ui1 >> ui2;
        
                if ( decode.good() ) { // expected format
                        // get the factory version for this particular key
                        FactoryItem factory_item(tmp2.data(),-1,tmp3.data(),Version(ui1,ui2));
                        SetAsCompatibleKeyItem(factory_item);
                        //
                        Key *tmpkey = 0x0;
                        tmpkey =
                          MainKeyFactory::theMainFactory().New(factory_item); // thanks to reference the request goes to the right factory
                
                        // valid key, otherwise does not change defaults
                        if ( tmpkey ) { 
                                fPrimaryKey = factory_item; 
                                delete tmpkey;
                        }
                        else {
                                fLog << error 
                                        << "PrimaryKey " << factory_item << " is not known \n";
                        } 
                }
                else ok_decode = false;
        } // this is the primary key (input)
        
        if ( aline.find("AutoConf:") == 0 ) { 
        // Keyword : autoconf - action : check if the frame could be created - Autoconf trigs reconfiguration so cannot depend on reconf of factories => must exist as this level
                //
                FactoryItem itemkey, itemframe; 
                //
                istringstream decode(aline);
                // just to be sure ...
                decode.clear();                 
                decode >> tmp1 >> tmp2 >> tmp3 >> ui2 >> ui3 >> tmp4 >> tmp5 >> ui4 >> ui5 ;
                //
                if ( decode.good() ) { // expected format
                        // item of key & frame
                        itemkey.SetItem(tmp2.data(),-1,tmp3.data(),Version(ui2,ui3)); itemframe.SetItem(tmp4.data(),-1,tmp5.data(),Version(ui4,ui5));
                        // prepare they to be compatible with the current definition of the data flow ...
                        SetAsCompatibleItems(itemkey,itemframe);
                        // ... and ask main factory to do the job of allocation 
                        SharedFP *tmpframe =
                                MainFrameFactory::theMainFactory().NewSharedFrame(itemkey,itemframe);            
                        if ( tmpframe ) { 
                                fAutoConf.first  = itemkey; 
                                fAutoConf.second = itemframe; 
                        }
                        else {
                                fLog << warning 
                                        << "AutoConf " << itemkey << itemframe << " is not known by the system @ this level " << nline;
                        } 
                        if ( tmpframe ) {
                                delete tmpframe;
                        }
                }
                else ok_decode = false;
        }// this is the primary key (for output)        
        
        if ( aline.find("Frame:") == 0 ) { 
        // Keyword : Frame - action : check compatible with known factories: if yes add to the list of frame with its version #. it is unique ! 
        // so if a frame with the same factory and type already exists, it changes its version #
        // As well, a frame with a unknown factory is not added or removed
                //
                std::istringstream decode(aline);
                // just to be sure ...
                decode.clear(); 
                decode >> tmp1 >> tmp2 >> tmp3 >> ui2 >> ui3 >> tmp4 >> tmp5 >> ui4 >> ui5 ;
                // factory version from the given factories
                FactoryItem itemkey, itemframe;
                itemkey.SetItem(tmp2.data(),-1,tmp3.data(),Version(ui2,ui3)); itemframe.SetItem(tmp4.data(),-1,tmp5.data(),Version(ui4,ui5));
                //
                if ( decode.good() ) { // expected format and compatible factories 
                        if ( SetAsCompatibleItems(itemkey,itemframe) )
                                AddKnownFrame(itemkey, itemframe, '+'); // add or change
                        else {
                                AddKnownFrame(itemkey, itemframe, '-'); // remove
                                fLog << warning 
                                         << " Frame " << itemkey << itemframe << " is not known by the system, so not added to the DFAgent " << nline;                          
                        }
                }
                else 
                        ok_decode = false;

        } // if ( tmp.find("Frame:") == 0 )
        
        return ok_decode;
}

Bool_t DFAgent::DoConfigure (ostream &out)
{
        out.clear();

        // add a start record
        AddRecord(out,'b');
        
        out << "# Endian type  \n";
        out << "Endian: ";
        if ( fEndian == BaseBuffer::kLittle )
                out << "kLittle \n";
        else
                out << "kBig \n";
        out << "# Factories (and version) for Frames & Keys \n" ;       
        // loop on required factories
        std::list< FactoryItem >::iterator 
                listed_item;
        for (listed_item = fListOfRequiredKeyFactories.begin(); listed_item != fListOfRequiredKeyFactories.end() ; listed_item++ ){     
                out << "KeyFactory: " << (*listed_item).GetFactoryName() << " " << (*listed_item).GetFactoryVersion() << " \n";
        }
        for (listed_item = fListOfRequiredFrameFactories.begin(); listed_item != fListOfRequiredFrameFactories.end() ; listed_item++ ){ 
                out << "FrameFactory: " << (*listed_item).GetFactoryName() << " " << (*listed_item).GetFactoryVersion() << " \n";
        }
        out << "# Version of the primary keys that structure the data flow \n";
        out << "PrimaryKey: " << fPrimaryKey.GetFactoryName() << " " << fPrimaryKey.GetItemName() << " " << fPrimaryKey.GetVersion().GetMajor() << " " << fPrimaryKey.GetVersion().GetMinor() << " \n";
        out << "AutoConf: "     <<  fAutoConf.first.GetFactoryName() << " " <<  fAutoConf.first.GetItemName() << " " <<  fAutoConf.first.GetVersion().GetMajor() << " " <<  fAutoConf.first.GetVersion().GetMinor() << " "  
                                                << fAutoConf.second.GetFactoryName() << " " << fAutoConf.second.GetItemName() << " " << fAutoConf.second.GetVersion().GetMajor() << " " << fAutoConf.second.GetVersion().GetMinor() << " \n";
        out << "# Current Frames going through the data flow \n";
        // loop on frames defining the data flow
        std::list< pair<FactoryItem,FactoryItem> >::iterator 
                listed_fitem;
        for (listed_fitem = fListOfFrames.begin(); listed_fitem != fListOfFrames.end(); listed_fitem++ ){
                out << "Frame: " << (*listed_fitem).first.GetFactoryName() << " " <<  (*listed_fitem).first.GetItemName() << " " <<  (*listed_fitem).first.GetVersion().GetMajor() << " " <<  (*listed_fitem).first.GetVersion().GetMinor() << " "
                                 << (*listed_fitem).second.GetFactoryName() << " " <<  (*listed_fitem).second.GetItemName() << " " <<  (*listed_fitem).second.GetVersion().GetMajor() << " " <<  (*listed_fitem).second.GetVersion().GetMinor() << " " << std::endl;
        }
        // add an end of record
        AddRecord(out,'e');
        
        // now call it for the list of DotConf if any i.e in this case for the referenced factories
        DotConf::DoConfigure(out); 

        out << "# \n"; 
        
        /*
        {
                KeyFactory *fact = 0x0;
                
                std::list< KeyFactory * >::iterator 
                        listed_item; 
                for ( listed_item = fListOfKeyFactories.begin(); listed_item != fListOfKeyFactories.end() ; listed_item++ ) {
                                fact = (*listed_item);
                                std::cout << fact->GetName() << " " << (void*)fact << std::endl;
                }       
                return fact;
        }
        
        {
                FrameFactory *fact = 0x0;
                
                std::list< FrameFactory * >::iterator 
                listed_item; 
                for ( listed_item = fListOfFrameFactories.begin(); listed_item != fListOfFrameFactories.end() ; listed_item++ ) {
                                fact = (*listed_item);
                                std::cout << fact->GetName() << " " << (void*)fact << std::endl;
                }       
                return fact;
        }
         */
        
                
        return out.good(); 
}