midnode.h

编译器

#include "afx.h"
#include "string.h"
#include "assert.h"
#include "iostream.h"
#ifndef SADF 
#define SADF 
class SFW;
class SelList;
class FromList;
class ConditionList;
class Attri;
class Relation;
class Query;
class Operator;
class DigAttri;
class Condition;
class Cop;
class sellistlect;
class touYing;
class Connection;
class Descartes;
class Table;
class Visitor
{
public:
	 virtual void visit()=0;
	 virtual void visitSFW(SFW *sfw)=0;
	 virtual void visitSelList(SelList* list)=0;
	 virtual void visitFromList(FromList* list)=0;
     virtual void visitConditionList(ConditionList* list)=0;
     virtual void visitAttri(Attri* attri)=0;
	 virtual void visitRelation(Relation* relation)=0;
	 virtual void visitQuery(Query* query)=0;
	 virtual void visitOperator(Operator* operator1)=0;
     virtual void visitDigattri(DigAttri* digattri)=0;
	 virtual void visitCondition(Condition* condition)=0;
};

class Visiter
{
public:
    virtual	void visit(Visiter* visiter)=0;
    virtual	void visitDescartes(Descartes* desc)=0;
    virtual	void visitConnection(Connection* con)=0;
	virtual void visittouYing(touYing* pro)=0;
	virtual void visitsellistlect(sellistlect* sel)=0;
	virtual void visitTable(Table* tab)=0;
	virtual void visitCop(Cop* cond)=0;
};
class ParNode:public CObject
{
public:
	virtual void accept(Visitor *visitor)=0;
	virtual void visit(Visitor *visitor)=0;
	virtual ParNode* add(ParNode *node)=0;
	virtual void count(int i,int *p)=0;
	virtual void drawTree(int p[20],CDC*pDC,int j,int k[21])=0;
};
 
class MidNode :public ParNode
{
	
public:
	CObList *pNode;
	int order;
	MidNode()
	{
	    order=0;
		pNode=new CObList();
	}
    void accept(Visitor *visitor);
	ParNode* add(ParNode *node);
	void remove(ParNode *node);
	virtual void visit(Visitor* visitor)=0;
	void count(int i,int *p);
	void drawTree(int p[20],CDC*pDC,int j,int k[21]);
 
};

class Leaf:public ParNode
{
   
public:
   char *value;
   int type;
   int order;
   void setValue(char *p)
   {
	   value=p;
   }
   char *getValue()
   {
	   return value;
   }
   void setType(int s)
   {
	   type=s;
   }
   int getType()
   {
	   return type;
   }
   void accept(Visitor *visitor)
   {
	   visit(visitor);
   }
   ParNode* add(ParNode* node)
   {
	   return node;
   }
   virtual void visit(Visitor *visitor)=0;
   
   void count(int i,int *p)
   {
      // *(p+i-1)=*(p+i-1)+1;
   }
   void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
   
   }

};

class Query :public MidNode//////////////query
{
public:
    void visit(Visitor *visitor)
	{
		visitor->visitQuery(this);
    }
	void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
	   int jie=p[j-1]+1;
	   if(j==1)
	   {
		pDC->MoveTo(220,65);
	    pDC->TextOut(200,50*j,"Query");
	    order=200;
	   }
	   else 
	   {
		 pDC->LineTo(k[19]+15,50*j-15);
		 pDC->TextOut(k[19],50*j,"Query");
	     order=k[19];
	   }
	   k[j]++;
	   MidNode::drawTree(p,pDC,j,k);
    }
    
};

class SFW :public MidNode
{
public:
	 
    void visit(Visitor* visitor)
	{
		visitor->visitSFW(this);
	}
	void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
	   int jie=p[j-1]+1;
       pDC->LineTo(k[18]+15,50*j);
	   pDC->TextOut(k[18],50*j,"SFW");
	   order=k[18];
	   k[j]++;
	   MidNode::drawTree(p,pDC,j,k);
   }
 
 
};
class Operator :public Leaf
{
public:
    void visit(Visitor* visitor)
	{
		visitor->visitOperator(this);
	}
     void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
       int jie=p[j-1]+1;
	   pDC->LineTo(k[20]+15,50*j);
	   pDC->TextOut(k[20],50*j,value);
       order=k[20];
	   k[j]++;
   }
 
 
};
class SelList :public MidNode
{
public:
    void visit(Visitor* visitor)
	{
		visitor->visitSelList(this);
	}
    	void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
	   int jie=p[j-1]+1;
	 //  pDC->LineTo(k[19],50*j);
	   if(j>3&&p[j-1]!=3){pDC->TextOut(k[19],50*j,"SelList");
	   order=k[19];
	   pDC->LineTo(k[19]+15,50*j);}
	   else 
	   {  pDC->TextOut(k[18],50*j,"SelList");
			 order=k[18];
	   pDC->LineTo(k[18]+15,50*j);}
	   k[j]++;
	   MidNode::drawTree(p,pDC,j,k);
   }
 
};

class FromList :public MidNode
{
public:
    void visit(Visitor* visitor)
	{
		visitor->visitFromList(this);
	}
	void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
	   int jie=p[j-1]+1;
     //  pDC->LineTo((k[j]+1)*800/jie,50*j);
	    if(j>3&&p[j-1]!=3)
		{pDC->TextOut(k[19],50*j,"FromList");
		order=k[19];
		pDC->LineTo(k[19]+15,50*j);}
		else {pDC->TextOut(k[20],50*j,"FromList");
		order=k[20];
		pDC->LineTo(k[20]+15,50*j);}
	   k[j]++;
	   MidNode::drawTree(p,pDC,j,k);
   }
 
};
class ConditionList :public MidNode
{
public:
    void visit(Visitor* visitor)
	{
		visitor->visitConditionList(this);
	}
		void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
	   int jie=p[j-1]+1;
//	   pDC->LineTo((k[j]+1)*800/jie,50*j);
	   if(j==3){
		   pDC->TextOut(k[19]-50,50*j,"ConditionList");
		   order=k[19]-50;
	   pDC->LineTo(k[19]-35,50*j);}
	   else{ pDC->TextOut(k[19]+20,50*j,"ConditionList");
	   order=k[19]+20;
	   pDC->LineTo(k[19]+35,50*j);}
	   k[j]++;
	   MidNode::drawTree(p,pDC,j,k);
   }
 
};
class Condition :public MidNode
{
public:
    void visit(Visitor* visitor)
	{
		visitor->visitCondition(this);
	}
   	void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
	    int jie;
		 jie=p[j-1]+1;
//	   pDC->LineTo((k[j]+1)*800/jie,50*j);
		pDC->TextOut(k[18]-20,50*j,"Condition");
		order=k[18]-20;
		pDC->LineTo(k[18]-5,50*j);
		k[j]++;
	    MidNode::drawTree(p,pDC,j,k);
   }
};

class Attri :public Leaf
{
public:
    void visit(Visitor* visitor)
	{
		visitor->visitAttri(this);
	}
    void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
       int jie=p[j-1]+1;
	 // pDC->LineTo((k[j]+1)*800/jie,50*j);
	   pDC->TextOut(k[18],50*j,value);
	   order=k[18];
	   pDC->LineTo(k[18]+15,50*j);
       k[j]++;
   }
 
};
class DigAttri:public Leaf
{
public:
    void visit(Visitor* visitor)
	{
		visitor->visitDigattri(this);
	}
    void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
       int jie=p[j-1]+1;
	    
//	   pDC->LineTo((k[j]+1)*800/jie,50*j);
	   pDC->TextOut(k[19],50*j,value);
       order=k[19];
	   pDC->LineTo(k[19]+15,50*j);
       k[j]++;
   }
 
};
class Relation:public Leaf
{
public:
    void visit(Visitor* visitor)
	{
		visitor->visitRelation(this);
	}
	void drawTree(int p[20],CDC*pDC,int j,int k[21])
   {
       int jie=p[j-1]+1;
	    
//	   pDC->LineTo((k[j]+1)*800/jie,50*j);
	   pDC->TextOut(k[18],50*j,value);
	   order=k[18];
	   pDC->LineTo(k[18]+15,50*j);
       k[j]++;
   }
   
};

class keyWord:public CObject
{
public :
	char *p;
};

class jieDian:public CObject
{
public:
	virtual void accept(Visiter *visiter)=0;
	virtual void visit(Visiter *visiter)=0;
    virtual void  drawlog(int k,CDC*pDC,int j)=0;
    virtual void result(int &k,CDC*pDC,int &j)=0;

};

class JiDian:public jieDian
{
public:
	int guanjian;
	jieDian *left;
	jieDian*right;
	jieDian* parent;
	bool isleft,isright;
	void accept(Visiter *visiter)
	{
		if(left!=NULL)
			isleft=false;
		else 
			isleft=true;
		if(right!=NULL)
			isright=false;
		else
			isright=true;
		if(!isleft)
		{
             visit(visiter);
			 if(isright)
			((JiDian*)(this->left))->accept(visiter);
		}
	}
	void drawlog(int k,CDC*pDC,int j)
	{
		  int k1,k2;
       if(this->left&&this->right)
	   {
		 k1=k-50;
	     k2=k+50;
	   } 
	   else
	   {
		   k1=k;
		   k2=k;
	   }
	  if(this->left)
	  { 
		  pDC->MoveTo(k+5,50*(j-1)+10); 
		 ((JiDian*)this->left)->drawlog(k1,pDC,j);
	  }
       if(this->right)
	   {
		 pDC->MoveTo(k+5,50*(j-1)+10);
	     ((JiDian*)this->right)->drawlog(k2,pDC,j);
	   }
	}
	void result(int &k,CDC*pDC,int &j)
	{
       if(this->left)
	   {  
		   ((JiDian*)this->left)->result(k,pDC,j);
		   j++;
	   }
		  if(this->right)
		{
		  ((JiDian*)this->right)->result(k,pDC,j);
		  j++;
		} 
	}
};
class touYing:public JiDian
{
public:
    CObList *list1;
    char *keys;
	touYing()
	{
		list1=new CObList();
		keys=NULL;
	}
	void add(char *p)
	{
	   keyWord *key=new keyWord();
	   key->p=new char[strlen(p)];
	   strcpy(key->p,p);
	   list1->AddTail(key);
	}
	void remove(char *p)
	{
		POSITION pos=list1->GetHeadPosition();
		while(pos)
		{
			keyWord *key=(keyWord *)list1->GetNext(pos);
			if(key->p==p)
			{
				list1->RemoveAt(pos);
				break;
			}
		}
	}

   void visit(Visiter *visiter)
   {
	   visiter->visittouYing(this);
   }
   void drawlog(int k,CDC*pDC,int j)
   {
      if(j==1)
	  {
		pDC->TextOut(400,50-3,"π");
	//    pDC->MoveTo(405,55);
	    k=400;
	  }
	  else 
	  {
          pDC->LineTo(k+5,50*j-5);
		  pDC->TextOut(k,50*j-3,"π");
	//    pDC->MoveTo(k,50*j+5);
 
	  }
	  POSITION pos=list1->GetHeadPosition();
	  int z=30;
	  int i=0;
	  while(pos)
	  {
        keyWord *key=(keyWord *)list1->GetNext(pos);
		pDC->TextOut(k+20+i*z,50*j,key->p);
		i++;
		
	  }
	  j++;
	  JiDian::drawlog(k,pDC,j);
   }
   void result(int &k,CDC*pDC,int &j)
   {
	   JiDian::result(k,pDC,j);
	   guanjian=k;
	   char *g="result";
	   pDC->TextOut(50,50*k,g);
	   int v=k;
	   char *t=new char[10];
	   itoa(v,t,10);
       pDC->TextOut(90,50*k,t);
	   pDC->TextOut(150,50*k,"投影");
       POSITION pos=list1->GetHeadPosition();
	   int z=30;
	   int i=0;
	   while(pos)
	   {
        keyWord *key=(keyWord *)list1->GetNext(pos);
		pDC->TextOut(200+40*i,50*k,key->p);
		i++;
	   }
	   k++;
   }

};

class Cop
{
   
public:
   char *progl;
   char *progr;
   char *op;
   bool ispure;
   Cop()
   {
        //progl=NULL;
		//delete progl;
   }
   void setprogl(char *p)
   {
	 
	   progl=new char[strlen(p)+1];
       assert(progl!=0);
       strcpy(progl,p);
	}
    void setprogr(char *p)
   {
	  progr=new char[strlen(p)+1];
      assert(progr!=0);
      strcpy(progr,p);
   }
    void setop(char *p)
   {
	   op=new char[strlen(p)+1];
       assert(op!=0);
       strcpy(op,p);
   }
   char* getprogl( )
   {
	  return  progl; 
   }
    char * getprogr( )
   {
	   return progr;
   }
    char* getop( )
   {
	   return op;
   }
   void setType(bool ispur)
   {
	   ispure=ispur;
   }
   bool getType()
   {
	   return ispure;
   }
   void visit(Visiter *visiter)
   {
	   visiter->visitCop(this);
   }
   

};
class sellistlect:public JiDian
{
public:
   Cop *cond;
    sellistlect()
	{
	 cond=new Cop();
	// cond->setprogl("");
	}
   void setcond(Cop *condcop)
   {
	   cond=condcop;
   }
   Cop* getcond()
   {
	   return cond;
   }
   void visit(Visiter *visiter)
   {
	   visiter->visitsellistlect(this);
   }
   void drawlog(int k,CDC*pDC,int j)
   {
      Cop*p=this->getcond();
	  pDC->LineTo(k+5,50*j-5);
	  pDC->TextOut(k,50*j-3,"б");
	  pDC->TextOut(k+20,50*j-3,p->getprogl());
      pDC->TextOut(k+50,50*j-3,p->getop());
	  pDC->TextOut(k+70,50*j-3,p->getprogr());