Commit: f82455fb9478f929e27626b07c89ef6ae193ea82 - joestar (git)

programming language

Commit MetaInfo

• Révision: f82455fb9478f929e27626b07c89ef6ae193ea82 (tree)
• l'heure: 2020-11-22 21:53:44
• Auteur: dhrname <dhrname@user...>
• Commiter: dhrname

Message de Log

Add the insertBefore method

Change Summary

• modified: main.cpp

Modification

--- a/main.cpp
+++ b/main.cpp
@@ -23,6 +23,8 @@
 
 #include <iostream>
 #include <string>
+#include <typeinfo>
+#include <stdexcept>
 
 /*Nodeの抽象クラス
  * 5方向リンクのリスト
@@ -31,13 +33,24 @@ class Node
 {
 public:
   virtual Node* getParent() = 0;
+  virtual void  setParent(Node*) = 0;
+  
   virtual Node* getNext() = 0;
+  virtual void  setNext(Node*) = 0;
+  
   virtual Node* getPrev() = 0;
+  virtual void  setPrev(Node*) = 0;
+  
   virtual Node* getFirstChild() = 0;
+  virtual void  setFirstChild(Node*) = 0;
+  
   virtual Node* getLastChild() = 0;
+  virtual void  setLastChild(Node*) = 0;
+  
   virtual Node* removeChild(Node* const) = 0;
   virtual Node* insertBefore(Node* const, Node* const) = 0;
   virtual Node* appendChild(Node* const) = 0;
+  
   virtual bool isNode() = 0;
 };
 
@@ -45,11 +58,16 @@ public:
 class EmptyNode: public Node
 {
 public:
-  Node* getParent(){return this;};
-  Node* getNext(){return this;};
-  Node* getPrev(){return this;};
-  Node* getFirstChild(){return this;};
-  Node* getLastChild(){return this;};
+  Node* getParent() {return this;};
+  Node* getNext() {return this;};
+  Node* getPrev() {return this;};
+  Node* getFirstChild() {return this;};
+  Node* getLastChild() {return this;};
+  void setParent(Node* node){};
+  void setNext(Node* node){};
+  void setPrev(Node* node){};
+  void setFirstChild(Node* node){};
+  void setLastChild(Node* node){};
   Node* removeChild(Node*){return this;};
   Node* insertBefore(Node*, Node*){return this;};
   Node* appendChild(Node*){return this;};
@@ -59,13 +77,13 @@ public:
   }
 };
 
-Node* const emptynode = new EmptyNode();
+EmptyNode* const emptynode = new EmptyNode();
 
 /*BaseNodeの基底クラス
  * Node抽象クラスに対する内部実装*/
 class BaseNode: public EmptyNode
 {
-private:
+protected:
   Node* parentNode;
   Node* nextSibling;
   Node* previousSibling;
@@ -83,46 +101,87 @@ public:
 
   virtual ~BaseNode(){}
   
-  virtual void throwArgumentError(Node* const node, const std::string& str);
-  virtual void setParent(Node* node);
-  virtual void setNext(Node* node);
-  virtual void setPrev(Node* node);
-  virtual void setFirstChild(Node* node);
-  virtual void setLastChild(Node* node);
+  virtual void throwNULLArgumentError(Node* const, const std::string&);
+  virtual void throwArgumentError(Node* const, const std::string&);
+  
+  virtual void setParent(Node*);
+  virtual void setNext(Node*);
+  virtual void setPrev(Node*);
+  virtual void setFirstChild(Node*);
+  virtual void setLastChild(Node*);
+  
   virtual Node* getParent();
   virtual Node* getNext();
   virtual Node* getPrev();
   virtual Node* getFirstChild();
   virtual Node* getLastChild();
+  
   virtual Node* removeChild(Node*);
   virtual Node* insertBefore(Node*, Node*);
   virtual Node* appendChild(Node*);
-  virtual bool isNode()
+  
+  virtual bool isNode() const
   {
       return true;
   }
 };
 
-inline void BaseNode::throwArgumentError(Node* const node, const std::string& str)
+/*throwNULLArgumentError 関数
+ * 引数のNULLチェックをして、nullptrだったら例外を投げる
+ * @param node 木構造の節
+ * @param name 引数の例外が発生したメンバ関数名*/
+inline void BaseNode::throwNULLArgumentError(Node* const node, const std::string& name)
+{
+  if (nullptr == node)
+  {
+    /*バグの放置を防ぐため、例外を投げる前に、エラーを出力して報告*/
+    std::cerr << "NULL Argument Error on the member " << name << std::endl;
+    throw std::invalid_argument("error!");
+  }
+}
+
+/*throwArgumentError 関数
+ * 引数のチェックをして、nullptrか、emptynode(空ノード)だったら例外を投げる
+ * @param node 木構造の節
+ * @param str 引数の例外が発生したメンバ関数名*/
+inline void BaseNode::throwArgumentError(Node* const node, const std::string& name)
 {
-  /*例外を投げる前に、エラーを出力して報告*/
-  std::cout << "Argument Error on the member " << str << std::endl;
-  throw;
+  this->throwNULLArgumentError(node, name);
+  if ( !node->isNode() )
+  {
+    /*バグの放置を防ぐため、例外を投げる前に、エラーを出力して報告*/
+    std::cerr << "Argument Error on the member " << name << std::endl;
+    throw std::invalid_argument("error!");
+  }
 }
 
-void BaseNode::setParent(Node* node){
+void BaseNode::setParent(Node* node)
+{
+  this->throwNULLArgumentError(node, "setParent");
   this->parentNode = node;
 }
-void BaseNode::setNext(Node* node){
+
+void BaseNode::setNext(Node* node)
+{
+  this->throwNULLArgumentError(node, "setNext");
   this->nextSibling = node;
 }
-void BaseNode::setPrev(Node* node){
+
+void BaseNode::setPrev(Node* node)
+{
+  this->throwNULLArgumentError(node, "setPrev");
   this->previousSibling = node;
 }
-void BaseNode::setFirstChild(Node* node){
+
+void BaseNode::setFirstChild(Node* node)
+{
+  this->throwNULLArgumentError(node, "setFirstChild");
   this->firstChild = node;
 }
-void BaseNode::setLastChild(Node* node){
+
+void BaseNode::setLastChild(Node* node)
+{
+  this->throwNULLArgumentError(node, "setLastChild");
   this->lastChild = node;
 }
 
@@ -130,6 +189,7 @@ Node* BaseNode::getParent()
 {
   return this->parentNode;
 }
+
 Node* BaseNode::getNext()
 {
   return this->nextSibling;
@@ -146,14 +206,109 @@ Node* BaseNode::getLastChild()
 {
   return this->lastChild;
 }
-Node* BaseNode::removeChild(Node* const node)
+
+/*removeChild メンバ関数
+ *自分からchildノードを引き離して、子ノードとして扱わないようにさせる
+ *@param child 引き離される子ノード
+ *@return 引き離された子ノード
+ **/
+Node* BaseNode::removeChild(Node* const child)
 {
-  this->throwArgumentError(node, "removeChild");
-  return this->parentNode;
+  this->throwArgumentError(child, "removeChild");
+  
+  child->setParent(emptynode);
+  
+  if (this->lastChild == child)
+  {
+      /*末子ノードがchildである場合は自分のlastChildメンバを書きかえておく*/
+      this->setLastChild(child->getPrev());
+  }
+  if (this->firstChild == child)
+  {
+      /*長子ノードがchildである場合は自分のfirstChildメンバを書きかえておく*/
+      this->setFirstChild(child->getNext());
+  }
+  
+  /*nodeが抜けた後、隣接ノードに関するメンバは書き換えておく*/
+  if (child->getPrev()->isNode())
+  {
+      child->getPrev()->setNext(child->getNext());
+  }
+  if (child->getNext()->isNode())
+  {
+      child->getNext()->setPrev(child->getPrev());
+  }
+      
+  child->setNext(emptynode);
+  child->setPrev(emptynode);
+
+  return child;
 }
 Node* BaseNode::insertBefore(Node* const node, Node* const prev)
 {
-  return this->parentNode;
+  this.throwArgumentError(node, "insertBefore");
+  
+  /*prevはemptynodeの可能性が含まれる*/
+  this.throwNULLArgumentError(prev, "insertBefore");
+  
+   /*祖先ノードの中に、今挿入しつつあるnodeと一致するものがあれば、参照エラー
+   *　というのは、循環参照を引き起こすため*/
+  Node* p = this;
+
+  while (p.isNode())
+  {
+      if (p == node)
+      {
+          throw std::invalid_argument("Reference error on the insertBefore");
+      }
+      
+      p = p->getParent(p);
+  }
+
+  Node* pnode = node->getParent();
+  
+  if (pnode->isNode())
+  {
+      /*nodeがすでに、他の枝に挿入されていた（子ノードであった）場合、引き離しておく*/
+      pnode->removeChild(node);
+  }
+  
+  node->setParent(this);
+  
+  if (!prev->isNode())
+  {        
+      /*prevノードがemptynodeの場合、末子ノードとしてnodeが追加される
+       *末子ノードが存在するときは、そのノードのメンバも書きかえておく*/
+      Node* lastChild = this->getLastChild();
+      if (lastChild->isNode())
+      {
+          lastChild->setNext(node);
+          node->setPrev(lastChild);
+      }
+      /*末子ノードとして挿入*/
+      this->setLastChild(node);
+  }
+  else
+  {        
+      Node* prevOfPrev = prev->getPrev();
+      if (prevOfPrev->isNode())
+      {
+          /*prevの隣接ノードのnextSiblingメンバを書きかえておく*/
+          prevOfPrev->setNext(node);
+      }
+      node->setPrev(prevOfPrev);
+      prev->setPrev(node);
+      node->setNext(prev);
+  }
+  
+  if (this->getFirstChild() == prev)
+  {
+    /*長子ノードがprevの場合、firstChildメンバをnodeに書きかえておく
+     *これはprevがemptynodeの場合でも同様*/
+    this->setFirstChild(node);
+  }
+  
+  return node;
 }
 Node* BaseNode::appendChild(Node* const node)
 {
@@ -162,7 +317,14 @@ Node* BaseNode::appendChild(Node* const node)
 
 int main(int argc, char **argv)
 {
-	std::string str1 = "ABCD";
+	std::string str1 = "ABC";
     std::cout << "A" << str1 << std::endl;
+  try
+  {
+  }
+  catch(std::invalid_argument e)
+  {
+  }
+  delete emptynode;
 	return 0;
 }