APClass.java

Go to the documentation of this file.

/*
 *   DENOPTIM
 *   Copyright (C) 2022 Marco Foscato <marco.foscato@uib.no>
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published
 *   by the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Affero General Public License for more details.
 *
 *   You should have received a copy of the GNU Affero General Public License
 *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package denoptim.graph;
 
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
 
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
 
import denoptim.constants.DENOPTIMConstants;
import denoptim.exception.DENOPTIMException;
import denoptim.fragspace.FragmentSpace;
import denoptim.graph.Edge.BondType;
import denoptim.graph.rings.RingClosingAttractor;
 
public class APClass implements Cloneable,Comparable<APClass>
{
    private String rule;
    
    private int subClass;
   
    public static Set<APClass> uniqueAPClasses = new HashSet<APClass>();
    
    private final static Object uniqueAPClassesLock = new Object();
 
    public static final String ATPLUS = "ATplus";
    
    public static final String ATMINUS = "ATminus";
    
    public static final String ATNEUTRAL = "ATneutral";
    
    public static final APClass RCACLASSPLUS = getUnique(ATPLUS, 0, 
            BondType.ANY);
    
    public static final APClass RCACLASSMINUS = getUnique(ATMINUS, 0, 
            BondType.ANY);
    
    public static final APClass RCACLASSNEUTRAL = getUnique(ATNEUTRAL, 0, 
            BondType.ANY);
    
    public static final APClass APCAROMBRIDGE2EL = getUnique("2elAromBridge", 0, 
            BondType.SINGLE); //TODO: one day we should introduce AROMATIC type
    
    public static final APClass APCAROMBRIDGE3EL = getUnique("3elAromBridge", 0, 
            BondType.SINGLE); //TODO: one day we should introduce AROMATIC type
    
    public static final APClass APCAROMBRIDGE4EL = getUnique("4elAromBridge", 0, 
            BondType.SINGLE); //TODO: one day we should introduce AROMATIC type
    
    public static final Set<APClass> APCAROMBRIDGES = new HashSet<APClass>(
            Arrays.asList(APCAROMBRIDGE2EL, APCAROMBRIDGE3EL, APCAROMBRIDGE4EL));
    
    private BondType bndTyp = DEFAULTBT; 
    
    public static final BondType DEFAULTBT = BondType.SINGLE;
 
//------------------------------------------------------------------------------
 
    public APClass() 
    {}
 
//------------------------------------------------------------------------------
 
    public static APClass make(String ruleAndSubclass) throws DENOPTIMException 
    { 
        if (!isValidAPClassString(ruleAndSubclass))
        {
            throw new DENOPTIMException("Attempt to use APClass '" 
                        + ruleAndSubclass
                        + "' that does not respect syntax <rule>"
                        + DENOPTIMConstants.SEPARATORAPPROPSCL + "<subClass>.");
        }
        String[] parts = ruleAndSubclass.split(
                DENOPTIMConstants.SEPARATORAPPROPSCL);
        return make(parts[0], Integer.parseInt(parts[1]));
    }
    
//------------------------------------------------------------------------------
 
    public static APClass make(String rule, int subClass) 
            throws DENOPTIMException 
    {
        return make(rule, subClass, DEFAULTBT);
    }
    
//------------------------------------------------------------------------------
 
    public static APClass make(String ruleAndSubclass, BondType bt) 
            throws DENOPTIMException 
    {
        if (!isValidAPClassString(ruleAndSubclass))
        {
            throw new DENOPTIMException("Attempt to use APClass '" 
                        + ruleAndSubclass
                        + "' that does not respect syntax <rule>"
                        + DENOPTIMConstants.SEPARATORAPPROPSCL + "<subClass>.");
        }
        String[] parts = ruleAndSubclass.split(
                DENOPTIMConstants.SEPARATORAPPROPSCL);
        return make(parts[0], Integer.parseInt(parts[1]), bt);
    }
    
//------------------------------------------------------------------------------
 
    public static APClass make(String rule, int subClass, BondType bt) 
            throws DENOPTIMException 
    {
        if (isValidAPRuleString(rule)) {        
            return getUnique(rule, subClass, bt);
        } else {
            throw new DENOPTIMException("Invalid sttempt to make APClass out "
                    + "of '" + rule + "' and '" + subClass + "'.");
        }
    }
    
//------------------------------------------------------------------------------
    
    private static APClass getUnique(String rule, int subClass, BondType bt)
    {
        APClass newApc = new APClass();
        synchronized (uniqueAPClassesLock)
        {
            boolean found = false;
            for (APClass existingApc : uniqueAPClasses)
            {
                if (existingApc.getRule().equals(rule)
                        && existingApc.getSubClass()==subClass)
                {
                    newApc = existingApc;
                    found = true;
                    break;
                }
            }
            if (!found)
            {
                newApc.setRule(rule);
                newApc.setSubClass(subClass);
                newApc.setBondType(bt);
            } else {
                // NB: the default bond type for RCAs must not be changed, but
                // For non-RCA APClasses we do update the bond type.
                if (bt != newApc.bndTyp && !RingClosingAttractor.RCAAPCLASSSET.contains(newApc))
                {
                    System.err.println("WARNING! Changing bond order of "
                            + "APClass " + newApc + ": " + newApc.bndTyp 
                            + " -> " + bt);
                    newApc.setBondType(bt);
                }
            }
            uniqueAPClasses.add(newApc);
        }
        return newApc;
    }
    
//------------------------------------------------------------------------------
    
    private void setBondType(BondType bt) {
        this.bndTyp = bt;
    }
 
//------------------------------------------------------------------------------
    
    private void setRule(String rule) {
        this.rule = rule;
    }
    
//------------------------------------------------------------------------------
    
    private void setSubClass(int sumClass) {
        this.subClass = sumClass;
    }
    
//------------------------------------------------------------------------------
    
    public static List<String> getAllAPClassesAsString()
    {
        List<String> names = new ArrayList<String>();
        for (APClass apc : uniqueAPClasses)
        {
            names.add(apc.toString());
        }
        Collections.sort(names);
        return names;
    }
    
//------------------------------------------------------------------------------
 
    public String getRule() {
        return rule;
    }
    
//------------------------------------------------------------------------------
 
    public int getSubClass() {
        return subClass;
    }
    
//------------------------------------------------------------------------------
    
    public BondType getBondType() {
        return bndTyp;
    }
    
//------------------------------------------------------------------------------
    
    public String toString() {
        return rule + DENOPTIMConstants.SEPARATORAPPROPSCL 
                + Integer.toString(subClass);
    }
    
//------------------------------------------------------------------------------
    
    public String toSDFString() {
        return rule + DENOPTIMConstants.SEPARATORAPPROPSCL 
                + Integer.toString(subClass)
                + DENOPTIMConstants.SEPARATORAPPROPSCL
                + bndTyp;
    }
 
//------------------------------------------------------------------------------
    
    public static boolean isValidAPSubCLassString(String s)
    {
        return s.matches("^[0-9]*$");
    }
    
//------------------------------------------------------------------------------
 
    public static boolean isValidAPRuleString(String s)
    {
        if (s == null)
            return false;
        return s.matches("^[a-zA-Z0-9_-]+$");
    }
 
//------------------------------------------------------------------------------
    
    public static boolean isValidAPClassString(String s)
    {
        if (!s.matches("^[a-z,A-Z,0-9].*"))
            return false;
        
        if (!s.matches(".*[0-9]$"))
            return false;
        
        if (s.contains(" "))
            return false;
        
        if (!s.contains(DENOPTIMConstants.SEPARATORAPPROPSCL))
            return false;
        
        int numSep = 0;
        for (int i=0; i<s.length(); i++)
        {
            if (s.charAt(i) == DENOPTIMConstants.SEPARATORAPPROPSCL.charAt(0))
            {
                numSep++;
            }
        }
        if (numSep != 1)
            return false;
        
        String apRule = s.split(DENOPTIMConstants.SEPARATORAPPROPSCL)[0];
        String sub = s.split(DENOPTIMConstants.SEPARATORAPPROPSCL)[1];
        
        return APClass.isValidAPRuleString(apRule) 
                && APClass.isValidAPSubCLassString(sub);
    }
    
//------------------------------------------------------------------------------
    
    public boolean isCPMapCompatibleWith(APClass other, FragmentSpace fragSpace)
    {
        return fragSpace.getCompatibleAPClasses(this).contains(other);
    }
 
//------------------------------------------------------------------------------
    
    @Override
    public int compareTo(APClass o)
    {
        int ruleComparison = this.rule.compareTo(o.rule);
        if (ruleComparison == 0) {
            return Integer.compare(this.subClass, o.subClass);
        } else {
            return ruleComparison;
        }
    }
    
//------------------------------------------------------------------------------
    
    @Override
    public APClass clone() {
        return this;
    }
    
//------------------------------------------------------------------------------
 
    @Override
    public boolean equals(Object o) {
        if (!(o instanceof APClass)) {
            return false;
        }
        return this.hashCode() == o.hashCode();
    }
    
//------------------------------------------------------------------------------
 
    public static class APClassDeserializer 
    implements JsonDeserializer<APClass>
    {
        @Override
        public APClass deserialize(JsonElement json, Type typeOfT,
                JsonDeserializationContext context) throws JsonParseException
        {
            JsonObject jo = json.getAsJsonObject();
            APClass apc = null;
            if (jo.has("bndTyp"))
            {
                apc = getUnique(jo.get("rule").getAsString(),
                    jo.get("subClass").getAsInt(),
                    context.deserialize(jo.get("bndTyp"),BondType.class));
            } else {
                //Only for conversion to V3
                String rule = jo.get("rule").getAsString();
                int subClass = jo.get("subClass").getAsInt();
                boolean found = false;
                for (APClass existingApc : uniqueAPClasses)
                {
                    if (existingApc.getRule().equals(rule)
                            && existingApc.getSubClass()==subClass)
                    {
                        apc = existingApc;
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    System.out.println("WARNING! Setting " + DEFAULTBT 
                            + " for "+rule+":"+subClass);
                    apc = getUnique(jo.get("rule").getAsString(),
                        jo.get("subClass").getAsInt(), DEFAULTBT);
                }
            }
            return apc;
        }
    }
 
//------------------------------------------------------------------------------
 
}