cattle_tree.cpp

//NAME: Ignacio Jimenez
//RED ID: 826019175
#include "cattle_tree.h"
#include <cstring>
//Constructor definition
CattleNode::CattleNode(const std::string &cattleID, int level, const std::vector<int> &maxCattlePerLevel){
  this->cattleID = cattleID;
  this->level = level;
  this->maxCattlePerLevel = maxCattlePerLevel;

  children = new CattleNode*[maxCattlePerLevel[level]];//Alocate space for node's new children
    for (int i = 0; i < maxCattlePerLevel[level]; i++) {
      children[i] = nullptr; //initializing child pointers to null
    }
 }

//AddCattle Definition
 bool CattleNode::addCattle(const char* CattlePath){
  if (strncmp(CattlePath, "s_", 2) != 0) {
    return false;  // Verify cattle path starts with "s_"
  }
  CattleNode *current = this;
  bool lastCharWasUnderscore = true;
  //bool lastCharWasUnderscore = true; //changed so we start checking from the third char

  for(int i = 2; CattlePath[i] != '\0'; ++i){
    if (CattlePath[i] == '_' && CattlePath[i - 1] != '_') {
      lastCharWasUnderscore = true;
      continue;
    }
    if(!isdigit(CattlePath[i]) || !lastCharWasUnderscore){
      break; //Stop if not a digit or more than one
    }
    int index = CattlePath[i] - '0';// Make it an int
    if(index < 0 || index >= maxCattlePerLevel[current->level]){
      return false; // if index is not within the allowed range break (0-indexed)
    }

    if (current->children[index] == nullptr) {
      // Create node if still not created
      std::string newCattleID = "s_" + std::to_string(index);
      current->children[index] = new CattleNode(newCattleID, current->level + 1, maxCattlePerLevel);
    }

    current = current->children[index]; // Update current node
    lastCharWasUnderscore = false;
  }
  return true;
 }


int CattleNode::findCattle(const char* CattlePath){
  if (strncmp(CattlePath, "s_", 2) != 0) {
    return 0;  // Verify cattle path starts with "s_"
  }
  CattleNode *current = this;
  bool lastCharWasUnderscore = true;

  for(int i = 2; CattlePath[i] != '\0'; ++i){
    if (CattlePath[i] == '_') {
      lastCharWasUnderscore = true;
      continue;
    }
    if(!isdigit(CattlePath[i]) || !lastCharWasUnderscore){
      return 0; //Stop if not a digit or more than one
    }
    int index = CattlePath[i] - '0';// Make it an int
    if(index < 0 || index >= current->maxCattlePerLevel[current->level]){
      return 0; // if index is not within the allowed range break (0-indexed)
    }
    if (current->children[index] == nullptr) {
      return 0;  //Cattle not found
    }

    current = current->children[index]; // Update current node
    lastCharWasUnderscore = false;
  }
  return countCattle(current);
}

int CattleNode::countCattle(CattleNode *node){
  //DFS implementation to count nodes
  if (node == nullptr){
    return 0;
  }
  int count = 1;
  for (int i = 0; i < node->maxCattlePerLevel[node->level]; i++) {
      if(node->children[i] != nullptr){
        count += countCattle(node->children[i]);
      }
  }
  return count;
}

//RemoveCattle Definition
bool CattleNode::removeCattle(const char* CattlePath){
  if (strncmp(CattlePath, "s_", 2) != 0) {
    return false;  // Verify cattle path starts with "s_"
  }
  
  CattleNode *current = this;
  CattleNode *parent = nullptr;
  int childIndex = -1;
  bool lastCharWasUnderscore = true;

  for(int i = 2; CattlePath[i] != '\0'; ++i){
    if (CattlePath[i] == '_' && CattlePath[i - 1] != '_') {
      lastCharWasUnderscore = true;
      continue;
    }
    if(!isdigit(CattlePath[i]) || !lastCharWasUnderscore){
      return false; //Stop if not a digit or more than one
    }
    int index = CattlePath[i] - '0';// Make it an int
    if(index < 0 || index >= maxCattlePerLevel[current->level]){
      return false; // if index is not within the allowed range break (0-indexed)
    }
    
    parent = current;
    childIndex = index;
    current = current->children[index];
    
    if (current == nullptr) {
      return false;  //Cattle not found
    }
    lastCharWasUnderscore = false;
  }
  
  // Found the node to delete
  if (parent != nullptr && childIndex >= 0) {
    // Check if this node has any children
    bool hasChildren = false;
    for (int i = 0; i < current->maxCattlePerLevel[current->level]; i++) {
      if (current->children[i] != nullptr) {
        hasChildren = true;
        break;
      }
    }
    
    // Only delete if no children (leaf node)
    if (!hasChildren) {
      delete current;
      parent->children[childIndex] = nullptr;
      return true;
    } else {
      return false; // Cannot delete node with children
    }
  }
  
  return false; // Cannot delete root node
}

//SetAnnotation Definition
bool CattleNode::setAnnotation(const char* CattlePath, const char* annotation){
  if (strncmp(CattlePath, "s_", 2) != 0) {
    return false;  // Verify cattle path starts with "s_"
  }
  
  CattleNode *current = this;
  bool lastCharWasUnderscore = true;

  for(int i = 2; CattlePath[i] != '\0'; ++i){
    if (CattlePath[i] == '_' && CattlePath[i - 1] != '_') {
      lastCharWasUnderscore = true;
      continue;
    }
    if(!isdigit(CattlePath[i]) || !lastCharWasUnderscore){
      return false; //Stop if not a digit or more than one
    }
    int index = CattlePath[i] - '0';// Make it an int
    if(index < 0 || index >= maxCattlePerLevel[current->level]){
      return false; // if index is not within the allowed range break (0-indexed)
    }
    
    if (current->children[index] == nullptr) {
      return false;  //Cattle not found
    }
    
    current = current->children[index];
    lastCharWasUnderscore = false;
  }
  
  // Found the node, set annotation
  current->annotation = std::string(annotation);
  return true;
}

//GetAnnotation Definition
std::string CattleNode::getAnnotation(const char* CattlePath){
  if (strncmp(CattlePath, "s_", 2) != 0) {
    return "";  // Verify SKU path starts with "s_"
  }
  
  CattleNode *current = this;
  bool lastCharWasUnderscore = true;

  for(int i = 2; CattlePath[i] != '\0'; ++i){
    if (CattlePath[i] == '_' && CattlePath[i - 1] != '_') {
      lastCharWasUnderscore = true;
      continue;
    }
    if(!isdigit(CattlePath[i]) || !lastCharWasUnderscore){
      return ""; //Stop if not a digit or more than one
    }
    int index = CattlePath[i] - '0';// Make it an int
    if(index < 0 || index >= maxCattlePerLevel[current->level]){
      return ""; // if index is not within the allowed range break (0-indexed)
    }
    
    if (current->children[index] == nullptr) {
      return "";  //Cattle not found
    }
    
    current = current->children[index];
    lastCharWasUnderscore = false;
  }
  
  // Found the node, return annotation
  return current->annotation;
}