bigraphvertex.h

这是一个从音频信号里提取特征参量的程序

  //
  BiGraphArc<TObject>* getFirstChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).getFirst();    
  }

  // method: getLastChild
  //
  BiGraphArc<TObject>* getLastChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).getLast();    
  }

  // method: getNextChild
  //
  BiGraphArc<TObject>* getNextChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).getNext();    
  }  

  // method: getPrevChild
  //
  BiGraphArc<TObject>* getPrevChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).getPrev();    
  }

  // method: getMarkChild
  //
  BiGraphArc<TObject>* getMarkChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).getMark();    
  }

  // method: getCurrChild
  //
  BiGraphArc<TObject>* getCurrChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).getCurr();    
  }  

  // method: getFirstParent
  //
  BiGraphArc<TObject>* getFirstParent() {
    return parents_d.getFirst();    
  }

  // method: getLastParent
  //
  BiGraphArc<TObject>* getLastParent() {
    return parents_d.getLast();    
  }

  // method: getNextParent
  //
  BiGraphArc<TObject>* getNextParent() {
    return parents_d.getNext();    
  }  

  // method: getPrevParent
  //
  BiGraphArc<TObject>* getPrevParent() {
    return parents_d.getPrev();    
  }

  // method: getMarkParent
  //
  BiGraphArc<TObject>* getMarkParent() {
    return parents_d.getMark();    
  }

  // method: getCurrParent
  //
  BiGraphArc<TObject>* getCurrParent() {
    return parents_d.getCurr();    
  }

  // method: getFirstParent
  //
  BiGraphArc<TObject>* getFirstParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).getFirst();    
  }

  // method: getLastParent
  //
  BiGraphArc<TObject>* getLastParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).getLast();    
  }

  // method: getNextParent
  //
  BiGraphArc<TObject>* getNextParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).getNext();    
  }  

  // method: getPrevParent
  //
  BiGraphArc<TObject>* getPrevParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).getPrev();    
  }

  // method: getMarkParent
  //
  BiGraphArc<TObject>* getMarkParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).getMark();    
  }

  // method: getCurrParent
  //
  BiGraphArc<TObject>* getCurrParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).getCurr();    
  }  

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  adjacency list insert-remove methods
  //
  //--------------------------------------------------------------------------

  // method: insertChild
  //
  boolean insertChild(BiGraphArc<TObject>* arg) {
    return children_d.insert(arg);
  }

  // method: insertChild
  //
  boolean insertChild(DoubleLinkedList<BiGraphArc<TObject> >& arg) {
    return children_d.insert(arg);
  }

  // method: removeChild
  //
  boolean removeChild(BiGraphArc<TObject>*& arg) {
    return children_d.remove(arg);
  }  

  // method: removeChild
  //
  boolean removeChild() {
    return children_d.remove();
  }      

  // method: insertFirstChild
  //
  boolean insertFirstChild(BiGraphArc<TObject>* arg) {
    return children_d.insertFirst(arg);
  }

  // method: insertFirstChild
  //
  boolean insertFirstChild(DoubleLinkedList<BiGraphArc<TObject> >& arg) {
    return children_d.insertFirst(arg);    
  }

  // method: removeFirstChild
  //
  boolean removeFirstChild(BiGraphArc<TObject>*& arg) {
    return children_d.removeFirst(arg);    
  }

  // method: removeFirstChild
  //
  boolean removeFirstChild() {
    return children_d.removeFirst();    
  }

  // method: insertLastChild
  //
  boolean insertLastChild(BiGraphArc<TObject>* arg) {
    return children_d.insertLast(arg);
  }
  
  // method: insertLastChild
  //
  boolean insertLastChild(DoubleLinkedList<BiGraphArc<TObject> >& arg) {
    return children_d.insertLast(arg);    
  }

  // method: removeLastChild
  //
  boolean removeLastChild(BiGraphArc<TObject>*& arg) {
    return children_d.removeLast(arg);    
  }

  // method: removeLastChild
  //
  boolean removeLastChild() {
    return children_d.removeLast();    
  }

  // method: insertParent
  //
  boolean insertParent(BiGraphArc<TObject>* arg) {
    return parents_d.insert(arg);
  }

  // method: insertParent
  //
  boolean insertParent(DoubleLinkedList<BiGraphArc<TObject> >& arg) {
    return parents_d.insert(arg);
  }  

  // method: removeParent
  //
  boolean removeParent(BiGraphArc<TObject>*& arg) {
    return parents_d.remove(arg);
  }  

  // method: removeParent
  //
  boolean removeParent() {
    return parents_d.remove();
  }      

  // method: insertFirstParent
  //
  boolean insertFirstParent(BiGraphArc<TObject>* arg) {
    return parents_d.insertFirst(arg);
  }

  // method: insertFirstParent
  //
  boolean insertFirstParent(DoubleLinkedList<BiGraphArc<TObject> >& arg) {
    return parents_d.insertFirst(arg);    
  }

  // method: removeFirstParent
  //
  boolean removeFirstParent(BiGraphArc<TObject>*& arg) {
    return parents_d.removeFirst(arg);    
  }

  // method: removeFirstParent
  //
  boolean removeFirstParent() {
    return parents_d.removeFirst();    
  }

  // method: insertLastParent
  //
  boolean insertLastParent(BiGraphArc<TObject>* arg) {
    return parents_d.insertLast(arg);
  }
  
  // method: insertLastParent
  //
  boolean insertLastParent(DoubleLinkedList<BiGraphArc<TObject> >& arg) {
    return parents_d.insertLast(arg);    
  }

  // method: removeLastParent
  //
  boolean removeLastParent(BiGraphArc<TObject>*& arg) {
    return parents_d.removeLast(arg);    
  }

  // method: removeLastParent
  //
  boolean removeLastParent() {
    return parents_d.removeLast();    
  }  

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  adjacency list property methods
  //
  //--------------------------------------------------------------------------

  // method: isEmptyChild
  //
  boolean isEmptyChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).isEmpty();
  }

  // method: isFirstChild
  //
  boolean isFirstChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).isFirst();
  }

  // method: isLastChild
  //
  boolean isLastChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).isLast();
  }

  // method: lengthChild
  //
  long lengthChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).length();
  }

  // method: findChild
  //
  boolean findChild(const BiGraphArc<TObject>* arg) {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).find(arg);
  }

  // method: containsChild
  //
  boolean containsChild(const BiGraphArc<TObject>* arg) const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).contains(arg);
  }

  // method: isEmptyParent
  //
  boolean isEmptyParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).isEmpty();
  }

  // method: isFirstParent
  //
  boolean isFirstParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).isFirst();
  }

  // method: isLastParent
  //
  boolean isLastParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).isLast();
  }

  // method: lengthParent
  //
  long lengthParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).length();
  }

  // method: findParent
  //
  boolean findParent(const BiGraphArc<TObject>* arg) {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).find(arg);
  }

  // method: containsParent
  //
  boolean containsParent(const BiGraphArc<TObject>* arg) const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).contains(arg);
  }

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  adjacency list ordering methods  
  //
  //-------------------------------------------------------------------------- 

  // method: sortChild
  //
  boolean sortChild(Integral::ORDER sort_order = Integral::ASCENDING,
	       DstrBase::SORT_ALGO = DstrBase::DEF_SORT_ALGO) {
    children_d.sort(sort_order);
  }

  // method: reverseChild
  //
  boolean reverseChild() {
    children_d.reverse();
  }

  // method: swapChild
  //
  boolean swapChild(long i, long j) {
    children_d.swap(i, j);
  }

  // method: sortParent
  //
  boolean sortParent(Integral::ORDER sort_order = Integral::ASCENDING,
	       DstrBase::SORT_ALGO = DstrBase::DEF_SORT_ALGO) {
    parents_d.sort(sort_order);
  }

  // method: reverseParent
  //
  boolean reverseParent() {
    parents_d.reverse();
  }

  // method: swapParent
  //
  boolean swapParent(long i, long j) {
    parents_d.swap(i, j);
  }  

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  adjacency list allocation methods
  //
  //--------------------------------------------------------------------------

  // method: getAllocationModeChild
  //
  DstrBase::ALLOCATION getAllocationModeChild() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (children_d).getAllocationMode();
  }

  // method: setAllocationModeChild
  //
  boolean setAllocationModeChild(DstrBase::ALLOCATION arg) {
    return children_d.setAllocationMode(arg);
  }


  // method: getAllocationModeParent
  //
  DstrBase::ALLOCATION getAllocationModeParent() const {
    return const_cast<DoubleLinkedList<BiGraphArc<TObject> >& >
      (parents_d).getAllocationMode();
  }

  // method: setAllocationModeParent
  //
  boolean setAllocationModeParent(DstrBase::ALLOCATION arg) {
    return parents_d.setAllocationMode(arg);
  }  
  
  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:

  // friend class
  //
  template <class TObject_diagnose> 
  friend class BiGraphVertexDiagnose;
};

// in order to allow BiGraph to reference BiGraphVertex's constants, it
// must be included after the class definition.
//
#ifndef ISIP_BI_GRAPH
#include <BiGraph.h>
#endif

#ifndef ISIP_BIGRAPH_ARC
#include <BiGraphArc.h>
#endif

//-----------------------------------------------------------------------------
//
// we define non-integral constants at the end of class definition for
// templates (for non-templates these are defined in the default constructor)
//      
//-----------------------------------------------------------------------------

// constants: required constants such as the class name
//
template <class TObject>
const String BiGraphVertex<TObject>::CLASS_NAME(L"BiGraphVertex");

template <class TObject>
const String BiGraphVertex<TObject>::DEF_PARAM(L"vertex");

// static instantiations: the memory manager
//
template <class TObject>
MemoryManager BiGraphVertex<TObject>::mgr_d(sizeof(BiGraphVertex<TObject>),
					  CLASS_NAME);

// below are all the methods for the BiGraphVertex template class
//      

// ---------------------------------------------------------------------
//
// required static methods
//
//----------------------------------------------------------------------

// method: name
//
// arguments: none
//
// return: a static String& containing the class name
//
// this method returns the class name