LatticeNode.cxx

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     Lattice
// Module:      LatticeNode
// 
// Description: See Lattice.h and LatticeNode.h
//
// Implementation:
//   Two classes: LatticeLeftNode & LatticeRightNode
//   See the header files.
//
// Author:      Jon Thaler
// Created:     Sat Apr  4 07:03:03 EST 1998
// $Id: LatticeNode.cxx,v 1.3 2001/08/14 20:42:21 messier Exp $
//
//  Minos Revision History
//  
//  This file has been converted automatically from the corresponding CLEO
//  Lattice code by Nick West on: 14/03/2000 08:38:07
//  
//  It is being used to explore the possibility that a modified Lattice
//  can be used in MINOS.  The main changes are:-
//  
//      1)  The removal Lattice templates classes:-
//  
//           a)  LinkData is dummy
//           b)  Left and Right ID types are void*
//  
//      2)  Conversion of CLEO types and includes to MINOS equivalents
//          e.g.:-
//  
//           a)  DABoolean -> Bool_t
//           b)  report    -> MSG

//

//
//


//----------------------+
// system include files |
//----------------------+
#if defined(AMBIGUOUS_STRING_FUNCTIONS_BUG)
#include <string>
#endif             
#include <iostream>

#if defined(STL_TEMPLATE_DEFAULT_PARAMS_FIRST_BUG)
#include <vector>
#include <algorithm>
#endif /* STL_TEMPLATE_DEFAULT_PARAMS_FIRST_BUG */

//--------------------+
// user include files |
//--------------------+
#include "Lattice/LatticeNode.h"

//-------------+
// STL classes |
//-------------+
#include <vector>
#include <algorithm>

//-------------------+
// static definition |
//-------------------+
const char* const kLLLNString = "Lattice.LatticeLeftNode";
const char* const kLLRNString = "Lattice.LatticeRightNode";

//-----------------------------+
// constructors and destructor |
//-----------------------------+
//------+
// Left |
//------+ 
LatticeLeftNode::
LatticeLeftNode(const LatticeDef::StoreType& data)
  : m_Links   (*new Links),
    m_VLeftID (*new VectorLeftID),
    m_VRightID(*new VectorRightID),
    m_ID      (data.identifier())
{
}
 
LatticeLeftNode::
LatticeLeftNode(LeftID id)
  : m_Links   (*new Links),
    m_VLeftID (*new VectorLeftID),
    m_VRightID(*new VectorRightID),
    m_ID      (id)
{
}
 
LatticeLeftNode::
~LatticeLeftNode()
{
  delete &m_Links;
  delete &m_VLeftID;
  delete &m_VRightID;
}

//-------+
// Right |
//-------+  
LatticeRightNode::
LatticeRightNode(const LatticeDef::StoreType& data)
  : m_Links   (*new Links),
    m_VRightID(*new VectorRightID),
    m_VLeftID (*new VectorLeftID),
    m_ID      (data.identifier())
{ 
}
  
LatticeRightNode::
LatticeRightNode(RightID id)
  : m_Links   (*new Links),
    m_VRightID(*new VectorRightID),
    m_VLeftID (*new VectorLeftID),
    m_ID      (id)
{ 
}
  
LatticeRightNode::
~LatticeRightNode()
{ delete &m_Links;
  delete &m_VLeftID;
  delete &m_VRightID;
}

//--------+
// show() |
//--------+ 
void
LatticeLeftNode::
show(ostream& os) const
{
  os << " Left data ID "       << identifier()      << ":"
     << endl
     << "   has              " << links().size()    << " links,"
     << endl
     << "   connecting it to " << m_VRightID.size() << " right data: ";

  // Right data.
  typedef LatticeLeftNode::RightItr Ritr;
  Ritr i    = m_VRightID.begin();
  Ritr iEnd = m_VRightID.end();
  for ( ; i != iEnd; ++i)
  {
    os << " " << *i;
  }
  os << endl
     << "   and shared with  " << m_VLeftID.size() << " left data:";

  // Left data.
  typedef LatticeLeftNode::LeftItr Litr;
  Litr  j    = m_VLeftID.begin();
  Litr  jEnd = m_VLeftID.end();
  for ( ; j != jEnd; ++j)
  {
    os << " " << *j;
  }
  os << endl;
}
  
void
LatticeRightNode::
show(ostream& os) const
{
  os << " Right data ID "      << identifier()     << ":"
     << endl
     << "   has              " << links().size()   << " links,"
     << endl
     << "   connecting it to " << m_VLeftID.size() << " left data: ";

  // Left data.
  typedef LatticeRightNode::LeftItr Litr;
  Litr m    = m_VLeftID.begin();
  Litr mEnd = m_VLeftID.end();
  for ( ; m != mEnd; ++m)
  {
    os << " " << *m;
  }
  os << endl
     << "   and shared with  " << m_VRightID.size() << " right data:";
  // Right data.
  typedef LatticeRightNode::RightItr Ritr;
  Ritr n    = m_VRightID.begin();
  Ritr nEnd = m_VRightID.end();
  for ( ; n != nEnd; ++n)
  {
    os << " " << *n;
  }
  os << endl;
}

//------------------+
// member functions |
//------------------+
//------+
// Left |
//------+
//--- links() ------------------------------------------------------------       
const LatticeLeftNode::
Links&
LatticeLeftNode      ::
links() const
{
  return m_Links;
}

//--- isLinkedTo(id) ---------------------------------------------------- 
Bool_t
LatticeLeftNode::
isLinkedTo(RightID id) const
{
  return (find(m_VRightID.begin(),m_VRightID.end(),id) == m_VRightID.end()) ?
          0 : 1;
}

//--- sharesLinksWith(id) ----------------------------------------------- 
Bool_t
LatticeLeftNode::
sharesLinksWith(LeftID id) const
{
  return (find(m_VLeftID.begin(),m_VLeftID.end(),id) == m_VLeftID.end()) ?
          0 : 1;
}

//--- identifier() ------------------------------------------------------ 
LatticeLeftNode::LeftID
LatticeLeftNode::
identifier() const
{
  return m_ID;
}

//-------+
// Right |
//-------+
//--- links() ------------------------------------------------------------        
const LatticeRightNode::
Links&
LatticeRightNode      ::
links() const
{
  return m_Links;
}

//--- isLinkedTo(id) ----------------------------------------------------  
Bool_t
LatticeRightNode::
isLinkedTo(LeftID id) const
{
  return (find(m_VLeftID.begin(),m_VLeftID.end(),id) == m_VLeftID.end()) ?
          0 : 1;
}

//--- sharesLinksWith(id) -----------------------------------------------  
Bool_t
LatticeRightNode::
sharesLinksWith(RightID id) const
{
  return (find(m_VRightID.begin(),m_VRightID.end(),id) == m_VRightID.end()) ?
          0 : 1;
}

//--- identifier() ------------------------------------------------------  
LatticeRightNode::RightID 
LatticeRightNode::
identifier() const
{
  return m_ID;
}

---