CombinatoricScenario.h

/*
 * Copyright 2003 Michael A. Marsh, Cornell University. All rights reserved.
 * This software is released under the modified BSD license.
 * See the file LICENSE in the top-level directory for details.
 */
//
// $Id: CombinatoricScenario.h,v 1.3 2004/05/19 15:57:00 mmarsh Exp $
//
// $Log: CombinatoricScenario.h,v $
// Revision 1.3  2004/05/19 15:57:00  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:23:07  mmarsh
// General code cleanup.
//
//

#ifndef __CODEX_VSS_COMBINATORICSCENARIO_H__
#define __CODEX_VSS_COMBINATORICSCENARIO_H__

#include <vector>

#include "CODEX_Exceptions/ExceptionBase.h"
#include "CODEX_Exceptions/Check.h"

namespace CODEX_VSS
{
   class DynamicCombinatoricScenario
   {
      public :
         DynamicCombinatoricScenario( unsigned int numServ,
                                      unsigned int numFaults ) :
            m_numServ( numServ ),
            m_numFaults( numFaults )
         {
            for ( unsigned int i = 0 ; i < m_numServ ; ++i )
            {
               m_masks.push_back( 1 << i );
            }
            setScenarios(0,0,m_numFaults);
         }

         virtual ~DynamicCombinatoricScenario() {}

         bool inScenario( unsigned int host, unsigned int scenario ) const
         {
            if ( ( host >= m_numServ ) || ( scenario >= m_scenarios.size() ) )
            {
               throw CODEX_Exceptions::IllegalIndexException( __FILE__ ,
                                                              __LINE__ );
            }
            return ( m_masks[host] & m_scenarios[scenario] );
         }

      private :
         void setScenarios( unsigned int first,
                            unsigned int mask,
                            unsigned int t )
         {
            if ( 0 == t )
            {
               m_scenarios.push_back(mask);
               return;
            }
            unsigned int current = first;
            for( ; current != m_numServ ; ++current )
            {
               unsigned int newmask = mask | m_masks[current];
               setScenarios( current+1, newmask, t-1 );
            }
         }

         const unsigned int  m_numServ;
         const unsigned int  m_numFaults;

         vector< unsigned int >  m_masks;
         vector< unsigned int >  m_scenarios;
   };

   template< unsigned int NumT , unsigned int FaultT >
   class CombinatoricScenario : public DynamicCombinatoricScenario
   {
      public :
         static CombinatoricScenario* instance()
         {
            if ( 0 == m_instance )
            {
               m_instance = new CombinatoricScenario;
            }
            return m_instance;
         }

         static void destroy()
         {
            if ( 0 != m_instance )
            {
               delete m_instance;
               m_instance = 0;
            }
         }

      private :
         static CombinatoricScenario*  m_instance;

         CombinatoricScenario() :
            DynamicCombinatoricScenario( NumT , FaultT )
         {
            // Make sure the parameters are sensible.
            CODEX_Exceptions::Check< ( NumT > FaultT ) >();
         }

         virtual ~CombinatoricScenario() {}

   };

   template< unsigned int NumT, unsigned int FaultT >
   CombinatoricScenario< NumT, FaultT >*
   CombinatoricScenario< NumT, FaultT >::m_instance = 0;

}

#endif /* __CODEX_VSS_COMBINATORICSCENARIO_H__ */

---