view release on metacpan or  search on metacpan

lib/SPVM/Eg/Node.spvm  view on Meta::CPAN

      case &TYPE_COMMENT_NODE :
      case &TYPE_TEXT_NODE :
      {
        my $node_value_buffer = $self->{node_value_buffer};
        
        if ($node_value_buffer) {
          $node_value = $node_value_buffer->to_string;
        }
      }
      case &TYPE_ELEMENT_NODE :
      case &TYPE_ATTRIBUTE_NODE :
      case &TYPE_DOCUMENT_NODE :
      case &TYPE_DOCUMENT_TYPE_NODE :
      case &TYPE_DOCUMENT_FRAGMENT_NODE :
      {
        # undef
      }
      case &TYPE_PROCESSING_INSTRUCTION_NODE : {
        die "ProcessingInstruction is not supported.";
      }
      default : {
        die "The type of the node is unexpected type";
      }
    }
    
    return $node_value;
  }
  
  method get_root_node : Eg::Node () {
    
    my $current_node = $self;
    
    my $root_node = (Eg::Node)undef;
    
    while (1) {
      my $parent_node = $current_node->{parent_node};
      
      if ($parent_node) {
        $current_node = $parent_node;
      }
      else {
        $root_node = $current_node;
        last;
      }
    }
    
    return $root_node;
  }
  
  method node_name : string () {
    
    my $node_type = $self->{node_type};
    
    my $node_name = (string)undef;
    
    switch ($node_type) {
      case &TYPE_ATTRIBUTE_NODE: {
        $node_name = $self->(Eg::Node::Attr)->name;
      }
      case &TYPE_CDATA_SECTION_NODE: {
        $node_name = "#cdata-section";
      }
      case &TYPE_COMMENT_NODE: {
        $node_name = "#comment";
      }
      case &TYPE_DOCUMENT_NODE: {
        $node_name = "#document";
      }
      case &TYPE_DOCUMENT_FRAGMENT_NODE: {
        $node_name = "#document-fragment";
      }
      case &TYPE_DOCUMENT_TYPE_NODE: {
        $node_name = $self->(Eg::Node::DocumentType)->name;
      }
      case &TYPE_ELEMENT_NODE: {
        $node_name = $self->(Eg::Node::Element)->tag_name;
      }
      case &TYPE_PROCESSING_INSTRUCTION_NODE: {
        $node_name = $self->(Eg::Node::ProcessingInstruction)->target;
      }
      case &TYPE_TEXT_NODE: {
        $node_name = "#text";
      }
      default: {
        die "[Unexpected Error]Unknown node type.";
      }
    }
    
    return $node_name;
  }
  
  method remove_child : Eg::Node ($child_node : Eg::Node) {
    unless ($child_node) {
      die "\$child_node must be defined.";
    }
    
    my $node_root = (Eg::Node)$self;
    my $node_cur = $node_root;
    my $finish = 0;
    while ($node_cur) {
      
      # [START]Preorder traversal position
      
      if ($node_cur->first_child) {
        $node_cur = (Eg::Node)$node_cur->first_child;
      }
      else {
        while (1) {
          # [START]Postorder traversal position
          unless ($node_cur == $self) {
            if ($node_cur == $child_node) {
              my $parent = $child_node->{parent_node};
              
              $child_node->{parent_node} = undef;
              
              my $next_sibling = $child_node->{next_sibling};
              
              my $previous_sibling = $child_node->{previous_sibling};
              
              if ($next_sibling) {
                $next_sibling->{previous_sibling} = $child_node->{previous_sibling};