LatticeLink.cxx

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     Lattice
// Module:      LatticeLink
// 
// Description: See LatticeLink.h and Lattice.h
//
// Implementation:
//  Data access:
//   linkData  Returns a reference to the link data.
//   vLeftID      "         "       "  "  vector of left  IDs.
//   vRightID     "         "       "  "     "      right  "
//   leftID       "      pointer to the one left ID (==0 is error).
//   leftID       "         "     "  "   "  right "   "   "   "
//
// Author:      Jon Thaler
// Created:     Sat Apr  4 07:03:03 EST 1998
// $Id: LatticeLink.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
#include "Lattice/LatticeNode.h"

//

//
//

//-------------+
// Environment |
//-------------+

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

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

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

//-------------+
// STL classes |
//-------------+
#include <vector>
using namespace std;

//-------------------+
// static definition |
//-------------------+
const char* const kLLLString = "Lattice.LatticeLink";

//-----------------------------+
// Constructors and destructor |
//-----------------------------+
//---------------------------------------------------+
// Given leftNode, rightNode, and linkData:          |
// * Copy the link data into this link               |
// * Construct a new LNodeTable and RNodeTable,      |
//   and add the node IDs to the vectors.            |
// * LinkData must have default & copy constructors. |
//---------------------------------------------------+ 
LatticeLink::
LatticeLink(LeftNode* lNode, RightNode* rNode)
     : m_LinkData(*new LinkData),
       m_VLeftID (*new VectorLeftID),
       m_VRightID(*new VectorRightID)
{
  m_VLeftID .push_back(lNode->identifier());
  m_VRightID.push_back(rNode->identifier());
}
 
LatticeLink::
LatticeLink(LeftNode* lNode, RightNode* rNode, const LinkData& linkData)
     : m_LinkData(*new LinkData(linkData)),
       m_VLeftID (*new VectorLeftID),
       m_VRightID(*new VectorRightID)
{
  m_VLeftID .push_back(lNode->identifier());
  m_VRightID.push_back(rNode->identifier());
}

LatticeLink::
~LatticeLink()
{
  delete &m_LinkData;
  delete &m_VLeftID;
  delete &m_VRightID;
}

//-----------------------------------------------------------------+
// Data access:                                                    |
//  linkData  Returns a reference to the link data.                |
//  vLeftID      "         "       "  "  vector of left  IDs.      |
//  vRightID     "         "       "  "     "      right  "        |
//  leftID       "      pointer to the one left ID (==0 is error). |
//  leftID       "         "     "  "   "  right "   "   "   "     |
//-----------------------------------------------------------------+  
LatticeDef::LinkData& 
LatticeLink::
linkData()
{
  return m_LinkData;
}
 
const LatticeDef::LinkData& 
LatticeLink::
linkData() const
{
  return m_LinkData;
}
 
const LatticeLink::VectorLeftID& 
LatticeLink      ::vLeftID() const
{
  return m_VLeftID;
}
   
const LatticeLink::VectorRightID& 
LatticeLink      ::vRightID() const 
{
  return m_VRightID;
}
   
const LatticeLink::LeftID*
LatticeLink      ::leftID() const 
{
  return (1 != m_VLeftID.size()) ?  0 : &(m_VLeftID.front());
}
   
const LatticeLink::RightID*
LatticeLink      ::rightID() const 
{
  return (1 != m_VRightID.size()) ?  0 : &(m_VRightID.front());
}

//-----------------+
// Display:        |
//  show(ostream&) |
//-----------------+   
void
LatticeLink::
show(ostream& os) const
{
  typedef LatticeLink::VectorLeftID
                                        VectorLeftID;
  typedef LatticeLink::VectorRightID
                                        VectorRightID;
  typedef VectorLeftID ::const_iterator LeftItr;
  typedef VectorRightID::const_iterator RightItr;

  const VectorLeftID&  ld = vLeftID();
  const VectorRightID& rd = vRightID();
  os << "  Link " << ld.size() << " left data items to "
                  << rd.size() << " right data items." <<endl 
     << "   Left  IDs:";
  for (LeftItr i = ld.begin();  i != ld.end();  ++i)
  {
    os << " " << *i;
  }
  os << endl << "   Right IDs:";
  for (RightItr j = rd.begin();  j != rd.end();  ++j)
  {
    os << " " << *j;
  }
  os << endl;
}

---