main page modules namespaces classes files
Gecode/J home

Space.java

Go to the documentation of this file.

/*
 *  Main authors:
 *     Mikael Lagerkvist <lagerkvist@gecode.org>
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Mikael Lagerkvist, 2006
 *     Guido Tack, 2006
 *
 *  Last modified:
 *     $Date: 2006-09-26 16:51:04 +0200 (Tue, 26 Sep 2006) $ by $Author: zayenz $
 *     $Revision: 3706 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

package org.gecode;

import java.lang.reflect.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;


public abstract class Space extends JavaSpace {
    public Space() {
        super();
        this.name = "";
    }
    public Space(String name) {
        super();
        this.name = name;
    }
    protected Space(long cPtr, boolean cMemoryOwn, boolean releaseOwnership) {
        super(cPtr, cMemoryOwn);
        if (releaseOwnership)
            swigReleaseOwnership();
    }
    protected Space(Boolean share, Space s) {
        super(share, s);
        this.name = s.name;
        swigReleaseOwnership();
    }

    public Space copy(boolean share) {
        try {
            Constructor ctors[] = this.getClass().getDeclaredConstructors();
            if (this.getClass().getEnclosingClass() == null) {
                for (int i = 0; i < ctors.length; ++i) {
                    Class<?> args[] = ctors[i].getParameterTypes();
                    if (args.length != 2) continue;
                    if (args[0] != Boolean.class) continue;
                    if (args[1] != this.getClass()) continue;
                    ctors[i].setAccessible(true);
                    return (Space)ctors[i].newInstance(share, this);
                }
            } else {
                throw new FatalException("Nested classes must override " +
                                         "the copy(boolean share) method");
            }
            throw new NoSuchMethodException();
        } catch(NoSuchMethodException ex) {
            throw new FatalException("No suitable copy-constructor defined for " 
                                     + this.getClass().getName(), ex);
        } catch(InstantiationException ex) {
            throw new FatalException("No suitable copy-constructor defined for " 
                                     + this.getClass().getName(), ex);
        } catch(IllegalAccessException ex) {
            throw new FatalException("No suitable copy-constructor defined for " 
                                     + this.getClass().getName(), ex);
        } catch(InvocationTargetException ex) {
            throw new FatalException("No suitable copy-constructor defined for " 
                                     + this.getClass().getName(), ex);
        }
    }
    public final JavaSpace copy_internal(boolean share) {
        JavaSpace ret = null;
        try {
            ret = copy(share);
        } catch (Throwable e) {
            System.err.println("Exception while copying a space:");
            System.err.println(e.getMessage());
            e.printStackTrace();
            System.err.println("Exit.");
            System.exit(2);
        }
        return ret;
    }

    public void constrain(Space s) {}
    public final void constrain_internal(JavaSpace s) {
        try {
            constrain((Space) s);
        } catch (Throwable e) {
            System.err.println("Exception while constraining a space:");
            System.err.println(e.getMessage());
            e.printStackTrace();
            System.err.println("Exit.");
            System.exit(2);
        }
    }

    public Space cloneSpace() {
        Space ret = (Space)super.cloneSpace();
        ret.swigTakeOwnership();
        return ret;
    }

    //
    // Name of this Space
    //
    private String name;
    public String getName() { return name; }
    public void setName(String name) { this.name = name; };
    
    //
    //  Creating a string representation of a field
    //
    private String varToString(Field field, boolean isArray,
                               Class typeClass) {
        try {
            if (typeClass.equals(VarArray.class)) {
                return field.getName() + "="+
                ((VarArray) field.get(this)).toString()+"\n";
            } else if (typeClass.equals(IntVar.class) ||
                       typeClass.equals(SetVar.class) ||
                       typeClass.equals(BoolVar.class)) {
                
                String s = "";
                if (isArray) {
                    s += field.getName();
                    Object a = field.get(this);
                    int length = Array.getLength(a);
                    s += "[]= {";
                    for (int i=0; i<length; i++) {
                        s += Array.get(a, i).toString();
                        if (i!=length-1)
                            s+=",";
                    }
                    s += "}\n";
                } else {
                    GecodeVar var = (GecodeVar) field.get(this);
                    s += var.getName();
                    if (s.equals("")) s += field.getName();
                    s += "="+field.get(this).toString()+"\n";
                }
                return s;
            } else {
                return "";
            }
        } catch (IllegalAccessException e) {
            return "<IllegalAccessException>";
        }
    }

    public String toString() {
        String s = "";
        Class c = this.getClass();

        if (name == "") {
            s = s + ""+c.getName()+":\n";
        } else {
            s = s + ""+name+":\n";          
        }
        
        Field[] publicFields = c.getFields();
        for (int i=0; i<publicFields.length; i++) {
            Class typeClass = publicFields[i].getType();
            if (typeClass.isArray()) {
                Class componentClass = typeClass.getComponentType();
                s += varToString(publicFields[i], true, componentClass);
            } else {
                s+= varToString(publicFields[i], false, typeClass);
            }
        }
        return s;
    }

}