Scope.java :  » Rule-Engine » zilonis » org » zilonis » scope » Java Open Source

package org.zilonis.scope;

/**
 * Copyright (c) 2005 Elie Levy <elie.levy@zilonis.org>
 * All rights reserved
 * 
 * This License governs use of the accompanying Software, and your use of the
 * Software constitutes acceptance of this license.
 * 
 * You may use this Software for any non-commercial purpose, subject to the
 * restrictions in this license. Some purposes which can be non-commercial are
 * teaching, academic research, and personal experimentation. You may also
 * distribute this Software with books or other teaching materials, or publish
 * the Software on websites, that are intended to teach the use of the 
 * Software.
 * 
 * 
 * You may not use or distribute this Software or any derivative works in any
 * form for commercial purposes. Examples of commercial purposes would be
 * running business operations, licensing, leasing, or selling the Software, or
 * distributing the Software for use with commercial products.
 * 
 * You may modify this Software and distribute the modified Software for
 * non-commercial purposes, however, you may not grant rights to the Software 
 * or derivative works that are broader than those provided by this License. 
 * For example, you may not distribute modifications of the Software under
 * terms that would permit commercial use, or under terms that purport to 
 * require the Software or derivative works to be sublicensed to others.
 * 
 * You may use any information in intangible form that you remember after
 * accessing the Software. However, this right does not grant you a license to
 * any of the copyrights or patents for anything you might create using such
 * information.
 * 
 * In return, we simply require that you agree:
 * 
 * Not to remove any copyright or other notices from the Software.
 * 
 * 
 * That if you distribute the Software in source or object form, you will
 * include a verbatim copy of this license.
 * 
 * 
 * That if you distribute derivative works of the Software in source code form
 * you do so only under a license that includes all of the provisions of this
 * License, and if you distribute derivative works of the Software solely in
 * object form you do so only under a license that complies with this License.
 * 
 * 
 * That if you have modified the Software or created derivative works, and
 * distribute such modifications or derivative works, you will cause the
 * modified files to carry prominent notices so that recipients know that they
 * are not receiving the original Software. Such notices must state: (i) that
 * you have changed the Software; and (ii) the date of any changes.
 * 
 * 
 * THAT THE SOFTWARE COMES "AS IS", WITH NO WARRANTIES. THIS MEANS NO EXPRESS,
 * IMPLIED OR STATUTORY WARRANTY, INCLUDING WITHOUT LIMITATION, WARRANTIES OF
 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE OR ANY WARRANTY OF TITLE
 * OR NON-INFRINGEMENT. ALSO, YOU MUST PASS THIS DISCLAIMER ON WHENEVER YOU
 * DISTRIBUTE THE SOFTWARE OR DERIVATIVE WORKS.
 * 
 * 
 * THAT NEITHER ZILONIS NOR THE AUTHOR WILL BE LIABLE FOR ANY DAMAGES RELATED
 * TO THE SOFTWARE OR THIS LICENSE, INCLUDING DIRECT, INDIRECT, SPECIAL,
 * CONSEQUENTIAL OR INCIDENTAL DAMAGES, TO THE MAXIMUM EXTENT THE LAW PERMITS,
 * NO MATTER WHAT LEGAL THEORY IT IS BASED ON. ALSO, YOU MUST PASS THIS
 * LIMITATION OF LIABILITY ON WHENEVER YOU DISTRIBUTE THE SOFTWARE OR 
 * DERIVATIVE WORKS.
 * 
 * 
 * That if you sue anyone over patents that you think may apply to the Software
 * or anyone's use of the Software, your license to the Software ends
 * automatically.
 * 
 * 
 * That your rights under the License end automatically if you breach it in any
 * way.
 * 
 * 
 * Elie Levy reserves all rights not expressly granted to you in this 
 * license.
 *  
 */

import java.util.LinkedList;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.Iterator;
import org.zilonis.util.MultiList;
import org.zilonis.network.WME;

public class Scope {

  private ReentrantReadWriteLock lock;

  private Scope parent;

  private LinkedList<Scope> children;

  private int level;

  private long lastId;

  private MultiList wmeInScope;

  public final static Scope ROOT = new Scope();

  private Scope(Scope parent) {
    this();
    this.parent = parent;
    level = parent.getLevel() + 1;
    getReadLock();
    parent.addChild(this);
    releaseReadLock();
  }

  private Scope() {
    children = new LinkedList<Scope>();
    lock = new ReentrantReadWriteLock();
    wmeInScope = new MultiList(WME.SCOPE);
  }

  public Iterator<WME> getWMEIterator() {
    return wmeInScope.iterator();
  }
  
  public void addWME(WME wme) {
    wmeInScope.add(wme);    
  }

  public void terminate() {
    wmeInScope.removeAll();
  }

  public Scope getParent() {
    return parent;
  }

  public synchronized long getNextId() {
    return lastId++;
  }

  public LinkedList<Scope> getChildren() {
    return children;
  }

  public int getLevel() {
    return level;
  }

  public int compareTo(Scope scope) {
    return level - scope.getLevel();
  }

  public Scope createChild() {
    return new Scope(this);
  }

  private void addChild(Scope child) {
    children.add(child);
  }

  public void lock() {
    if (parent != null)
      parent.getReadLock();
    getWriteLock();
  }

  public void unlock() {
    if (parent != null)
      parent.releaseReadLock();
    releaseWriteLocks();
  }

  private void releaseReadLock() {
    if (parent != null)
      parent.releaseReadLock();
    lock.readLock().unlock();
  }

  private void releaseWriteLocks() {
    lock.writeLock().unlock();
    for (Scope child : children)
      child.releaseWriteLocks();
  }

  private void getReadLock() {
    if (parent != null)
      parent.getReadLock();
    lock.readLock().lock();
  }

  private void getWriteLock() {
    lock.writeLock().lock();
    for (Scope child : children)
      child.getWriteLock();
  }

}