---

DictNode.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/xmlUtil/xmlUtil/id/DictNode.h,v 1.10 2002/04/05 18:28:44 jrb Exp $
#ifndef XMLUTIL_DICTNODE_H
#define XMLUTIL_DICTNODE_H

#include <dom/DOM_Element.hpp>
#include "xmlUtil/id/DictObject.h"
#include "xmlUtil/id/DictField.h"
#include "xmlUtil/id/DictConstraints.h"
#include "xmlUtil/id/NamedId.h"

#include <vector>
#include <algorithm>
#include <iterator>
#include <iostream>

namespace xmlUtil {

  class DictFieldMan;

  class DictNode : public DictObject {
  public:
    DictNode(DOM_Element elt, DictNode* parent, DictFieldMan *fieldMan); 
    /* IN PROGRESS */
    ~DictNode();  // similarly, delete all children recursively /* TO DO */
    const DictField& getField() const {return *m_field;};

    // Following should be changed or add new function which
    //  returns local constraints if there are any,
    //  else if field has associated constraints, return pointer to that
    //  else return 0
    const DictConstraints& getValueConstraints() const { 
      return *m_myConstraints;};
    const DictConstraints& getParentConstraints() const {
      return *m_parConstraints;};
    bool accept(DictVisitor* vis);

    bool  consistentChildren();          

    bool  consistentParent();

    bool  consistentValues();

    // Maybe also need function to check that field ref points
    // to actual field definition?

    // Perhaps need to add validity functions here to check
    //    parent constraints, if any, make sense
    //    own constraints, if any, make sense
    bool  allowed(const unsigned value) const;  
    bool  allowedChild(std::string childField, unsigned childValue, 
                       unsigned myValue) const;
    bool  allowedChild(unsigned childValue, unsigned myValue) const;

    bool allowIdentifier(const Identifier& id, NamedId* named = 0);

    bool allowNamedId(const NamedId& nId);

    bool allowNameSeq(const NameSeq& seq) const;

    class No_Assignment {};

  private:
    friend class IdDict;
    friend class IdConverter;   //maybe
    friend struct POrder;

    // Might want to use some other form of collection for 
    // child DictNodes
    typedef std::vector<DictNode*> Nodes;
    typedef std::vector<DictNode*>::iterator NodeIterator;
    typedef std::vector<DictNode*>::const_iterator ConstNodeIterator;

    // Nested class allowing sorting of child nodes by m_minValue of
    // parent constraint
    struct POrder {
      bool operator()(DictNode* a, DictNode* b) {
        return ((a->getParentConstraints()).getMin() <
                (b->getParentConstraints()).getMin()   ); }
    }; 

    const Nodes&     getChildren() const {return m_children;}

    static void   setOstream(std::ostream* out) {m_err = out;}

    // More constructor, for when dictionary is built dynamically
    // rather than from xml file
    /*    DictNode(DictField& field);                             TO DO
    DictNode(DictField& field, DictConstraints& parConstraints);  TO DO
    DictNode(DictField& field, DictConstraints& parConstraints,   TO DO
             DictConstraints& myConstraints);                     TO DO */


    bool  allowedChild(const DictNode* const thisChild, unsigned childValue,
                       unsigned myValue) const;


    bool allowIdentifier(Identifier::const_iterator idIt, 
                         Identifier::const_iterator end,
                         NamedId* named=0);

    bool allowNamedId(NamedId::FieldIt nIdIt,
                      NamedId::FieldIt end);


    bool allowNameSeq(NameSeq::const_iterator seqIt,
                      NameSeq::const_iterator end) const;

    bool  addChild(DictNode* child);


    bool  valuesDisjoint(ConstNodeIterator start, 
                         ConstNodeIterator last); 


    DictNode(const DictNode& toCopy);

    // Assignment of nodes is not allowed
    DictNode& operator=(const DictNode&); 
    void deepCopy(const DictNode& toCopy);

    DictNode() {};   

    Nodes            m_children;      
    const DictField* m_field;         
    const DictNode*  m_parent;        
    DictConstraints* m_parConstraints;
    DictConstraints* m_myConstraints; 
    static std::ostream* m_err;

  };       // end DictNode class definition
}          // end namespace xmlUtil
#endif

---