Family tree model in GORM / Grails?

Question

I have problems with the family tree model in GORM / Grails. I know that to model such a structure, it is recommended to use a direct acyclic graph.

I started with the Person class:

class Persion {
  String name 
}

A person may have the following relationships:

• 0 to n children
• from 0 to n brothers and sisters (these may be sisters or brothers).
• from 0 to n partners (these can be spouses or spouses)
• 0 from Russian parents (this can be a mother or father).

1. How do I create such a relationship structure?

2. How to insert or remove people from this structure?

3. How to ensure that the final schedule has no cycles?

Edit:

Suppose we have person A:

• Children attitude:

  • If you add child B to A, then child B must receive A as a parent.

• :

  • C A, C A

• :

  • D A, D A

Answer 1

. , ..

class TreeNode  

    {


     String name





     /**
      * This method deletes a node and all the relations that are bound to this node.
      * @return
      */
     def deleteNode() {

      // delete all child relations
      def myChildren = getChildren()
      println "myChildren: "+myChildren*.name

      myChildren.each { child ->
       println "child: "+child.name
       removeFromChildren(child)
      }

      // delete all parent relations
      def myParents = getParents()
      println "myParents: "+myParents*.name
      myParents.each { parent ->
       println "parent: "+parent.name
       removeFromParents(parent)
      }


      delete(flush:true)
     }


     TreeSet<TreeNode> getChildren() {
       TreeNodeChild.executeQuery("select tnc.child from TreeNodeChild tnc where tnc.node = :node", [node: this])
     }


     TreeNode removeFromChildren(TreeNode child) {
      TreeNodeChild.findByNodeAndChild(this, child).delete(flush: true)
      this
     }

     /**
      * Add a node as type (i.e. child) to another node.
      * @param child
      * @return
      */
     TreeNode addToChildren(TreeNode child) {
      TreeNodeChild tnc = new TreeNodeChild(node: this, child: child)
      if (tnc.validate()) {

       if (!isCyclic(child, "type")) {
        println ">>>>>>>> no cycle"
        tnc.save(flush: true)
       }
       else {
        println ">>>>>>>> !!!!!!! cycle found"
       }
      }
      this
     }


     TreeSet<TreeNode> getParents() {
      TreeNodeChild.executeQuery("select tnc.node from TreeNodeChild tnc where tnc.child = :child", [child: this])
     }

     TreeNode removeFromParents(TreeNode parent) {
      TreeNodeChild.findByNodeAndChild(parent, this).delete(flush: true)
      this
     }

     TreeNode addToParents(TreeNode parent) {
      TreeNodeChild tnc = new TreeNodeChild(node: parent, child: this)
      if (tnc.validate()) {

       if (!parent.isCyclic(this, "type")) {
        println ">>>>>>>> no cycle"
        tnc.save(flush: true)
       }
       else {
        println ">>>>>>>> !!!!!!! cycle found"
       }
      }
      this
     }







     private boolean isCyclic(node) {
      boolean cyclic = false
      def myParents = this.getParents()

      // if there are parents of this node
      if (myParents.size() != 0) {

       // if the new node is in the parents set of this node
       if (myParents.contains(node)) {
        cyclic = true
        return cyclic
       }
       else {
        // go into each parent of this node and test if new node is contained in their parents
        myParents.each { parent ->
         if (cyclic) {
          return cyclic
         }
         cyclic = parent.isCyclic(node)
        }
       }
      }

      return cyclic
     }





    }

Answer 2

, . , , - :

class Persion {
  Person mother
  Person father
  String name 

  //The methods for the other collections would be the same
  Set<Person> getChildren() {
    PersonChild.executeQuery("select pc.child from PersonChild pc where pc.person = :person", [person: this])
  }

  Person removeFromChildren(Person child) {
      PersonChild.findByPersonAndChild(this, child).delete()
      this
  }

  Person addToChildren(Person child) {
    //Something like this to prevent recursion
    //Save should fail if the person already has that person as a child

    List<Person> others = [mother, father]
    others += siblings
    others += partners

    PersonChild pc = new PersonChild(person: this, child: child)
    if (pc.validate()) {
      if (!others.contains(child)) {
        pc.save()
      }  
    }
    this
  }
}

class PersionChild {
  Person person
  Person child
}

class PersionSibling {
  Person person
  Person sibling
}

class PersonPartner {
  Person person
  Person partner
}

Person * UserRole , Spring.

Answer 3

GORM/Grails. , Java.

, Java.

A Person , (, getSiblings, ).

Set, , ( ).

factory. enum .

. .

, , , . , .

public class Person {
  // Using HashSet to limit possibilities of cycles - we can assume no person exists twice in each.
  private final Set<Person> parents = new HashSet<>();
  private final Set<Person> partners = new HashSet<>();
  private final Set<Person> children = new HashSet<>();
  // Person details.
  private final String name;

  // Constructor.
  public Person(String name) {
    this.name = name;
  }

  // Extract all siblings as all children of all parents.
  public Set<Person> getSiblings() {
    Set<Person> siblings = new HashSet<>();
    for (Person parent : parents) {
      siblings.addAll(parent.children);
    }
    return siblings;
  }

}

// A factory to handle family connections.
public enum Connection {
  ParentOf {
            @Override
            void connect(Person a, Person b) {
              // Connect through a children and b parents.
              connect(a.children, b, b.parents, a);
            }

            @Override
            void disconnect(Person a, Person b) {
              // Connect through a children and b parents.
              disconnect(a.children, b, b.parents, a);
            }

          },
  PartnerOf {
            @Override
            void connect(Person a, Person b) {
              // Connect through a children and b parents.
              connect(a.partners, b, b.partners, a);
            }

            @Override
            void disconnect(Person a, Person b) {
              // Connect through a children and b parents.
              disconnect(a.partners, b, b.partners, a);
            }

          },
  ChildOf {
            @Override
            void connect(Person a, Person b) {
              // The opposit of parent.
              ParentOf.connect(b, a);
            }

            @Override
            void disconnect(Person a, Person b) {
              // The opposit of parent.
              ParentOf.disconnect(b, a);
            }

          };

  abstract void disconnect(Person a, Person b);

  abstract void connect(Person a, Person b);

  /**
   * Connect b to a through aSet and a to b through bSet
   *
   * @param aSet The set in person a
   * @param b The b person
   * @param bSet The set in person b
   * @param a The a person
   */
  void connect(Set<Person> aSet, Person b, Set<Person> bSet, Person a) {
    aSet.add(b);
    bSet.add(a);
  }

  /**
   * Reverse of connect.
   *
   * @param aSet The set in person a
   * @param b The b person
   * @param bSet The set in person b
   * @param a The a person
   */
  void disconnect(Set<Person> aSet, Person b, Set<Person> bSet, Person a) {
    aSet.remove(b);
    bSet.remove(a);
  }

}

public class Tree {
  // Safe version - ensuring relationships are maintained.
  public void connect(Person a, Connection c, Person b) {
    c.connect(a, b);
  }

  public void test() {
    Person adam = new Person("Adam");
    Person eve = new Person("Eve");
    Person cain = new Person("Cain");
    Person abel = new Person("Abel");
    connect(adam, Connection.PartnerOf, eve);
    connect(adam, Connection.ParentOf, cain);
    connect(eve, Connection.ParentOf, cain);
    connect(adam, Connection.ParentOf, abel);
    connect(eve, Connection.ParentOf, abel);
  }

}

:

• , ?

- - ! , , , . . - , , , .

, .

Answer 4

class Children {
String childrenName
static belongsTo = [person:Person]  
}
class Parent {
String parentName
static belongsTo = [person:Person]
}
class Partner {
String partnerName
static belongsTo = [person:Person]
}
class Person {
String personName
static hasMany = [childrens: Children,
                    parents: Parent,
                    partners: Partner,
                    siblings: Sibiling]
}
class Sibiling {
 String sibilingName
static belongsTo = [person:Person]
}

stdandard,

def person = new Person();
person.personName = "Suganthan"
def children = new Children()
children.childrenName = "SuganthanchilName"
def parent = new Parent()
parent.parentName = "SuganthanParentName"
def partner = new Partner()
partner.partnerName = "SuganthanPartnerName"
def sibling = new Sibiling()
sibling.sibilingName = "SuganthanSibiligsName"

person.addToChildrens(children)
person.addToParents(parent)
person.addToPartners(partner)
person.addToSiblings(sibling)
person.save()

,

def criteria = Children.createCriteria();
Children children = criteria.get {
eq('id',1 as long)
}

def criteria1 = Parent.createCriteria();
Parent parent = criteria1.get {
eq('id',1 as long)
}

def criteria2 = Partner.createCriteria();
Partner partner = criteria2.get {
eq('id',1 as long)
}

def criteria3 = Sibiling.createCriteria();
Sibiling sibiling = criteria3.get {
eq('id',1 as long)
}

    println(children.person.personName)
    println(parent.person.personName)
    println(partner.person.personName)
    println(sibiling.person.personName)

Suganthan

Suganthan

Suganthan

Suganthan

, ,