EmptyVertex.java

Go to the documentation of this file.

package denoptim.graph;
 
/*
 *   DENOPTIM
 *   Copyright (C) 2019 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/>.
 */
 
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;
 
import org.openscience.cdk.AtomContainer;
import org.openscience.cdk.interfaces.IAtomContainer;
 
import com.google.gson.Gson;
 
import denoptim.constants.DENOPTIMConstants;
import denoptim.json.DENOPTIMgson;
import denoptim.utils.GraphUtils;
import denoptim.utils.MutationType;
import denoptim.utils.Randomizer;
 
 
public class EmptyVertex extends Vertex
{
    private List<AttachmentPoint> lstAPs;
 
    private List<SymmetricAPs> lstSymAPs;
 
//------------------------------------------------------------------------------
 
    public EmptyVertex()
    {
        super(VertexType.EmptyVertex, GraphUtils.getUniqueVertexIndex());
        lstAPs = new ArrayList<AttachmentPoint>();
        lstSymAPs = new ArrayList<SymmetricAPs>();
    }
 
//------------------------------------------------------------------------------
 
      public EmptyVertex(BBType type)
      {
          super(VertexType.EmptyVertex);
          lstAPs = new ArrayList<AttachmentPoint>();
          lstSymAPs = new ArrayList<SymmetricAPs>();
          buildingBlockType = type;
      }
    
//------------------------------------------------------------------------------
 
    public EmptyVertex(long id)
    {
        super(VertexType.EmptyVertex, id);
        lstAPs = new ArrayList<AttachmentPoint>();
        lstSymAPs = new ArrayList<SymmetricAPs>();
    }
 
//------------------------------------------------------------------------------
 
    public EmptyVertex(long id, ArrayList<AttachmentPoint> lstAPs,
            ArrayList<SymmetricAPs> lstSymAPs, boolean isRCV)
    {
        super(VertexType.EmptyVertex, id);
        this.lstAPs = lstAPs;
        this.lstSymAPs = lstSymAPs;
        setAsRCV(isRCV);
    }
 
//------------------------------------------------------------------------------
 
    public List<AttachmentPoint> getAttachmentPoints()
    {
        return lstAPs;
    }
 
//------------------------------------------------------------------------------
 
    public void setSymmetricAP(List<SymmetricAPs> sAPs)
    {
        lstSymAPs = sAPs;
    }
 
//------------------------------------------------------------------------------
 
    public List<SymmetricAPs> getSymmetricAP()
    {
        return lstSymAPs;
    }
 
//------------------------------------------------------------------------------
 
    @Override
    public SymmetricAPs getSymmetricAPs(AttachmentPoint ap)
    {
        for (SymmetricAPs symmetricSet : lstSymAPs)
        {
            if (symmetricSet.contains(ap))
            {
                return symmetricSet;
            }
        }
        return null;
    }
 
//------------------------------------------------------------------------------
 
    public int getNumberOfAPs()
    {
        return lstAPs.size();
    }
 
//------------------------------------------------------------------------------
 
    public ArrayList<Integer> getFreeAPList()
    {
        ArrayList<Integer> lstAvailableAP = new ArrayList<>();
        for (int i=0; i<lstAPs.size(); i++)
        {
            if (lstAPs.get(i).isAvailable())
                lstAvailableAP.add(i);
        }
        return lstAvailableAP;
    }
 
//------------------------------------------------------------------------------
 
    public int getFreeAPCount()
    {
        int n = 0;
        for (AttachmentPoint denoptimAttachmentPoint : lstAPs) {
            if (denoptimAttachmentPoint.isAvailable())
                n++;
        }
        return n;
    }
 
//------------------------------------------------------------------------------
 
    public boolean hasFreeAP()
    {
        for (AttachmentPoint denoptimAttachmentPoint : lstAPs) {
            if (denoptimAttachmentPoint.isAvailable())
                return true;
        }
        return false;
    }
 
//------------------------------------------------------------------------------
 
    public boolean hasSymmetricAP()
    {
        return !lstSymAPs.isEmpty();
    }
 
//------------------------------------------------------------------------------
 
    @Override
    public String toString()
    {
        return getVertexId() + "_EmptyVertex";
    }
 
//------------------------------------------------------------------------------
 
    public void cleanup()
    {
        if (lstSymAPs != null)
        {
            lstSymAPs.clear();
        }
        if (lstAPs != null)
        {
            lstAPs.clear();
        }
    }
 
//------------------------------------------------------------------------------
 
    @Override
    public EmptyVertex clone()
    {
        EmptyVertex c = new EmptyVertex(getVertexId());
        c.setAsRCV(this.isRCV());
        c.setBuildingBlockId(this.getBuildingBlockId());
        c.setBuildingBlockType(this.getBuildingBlockType());
        
        c.setMutationTypes(this.getUnfilteredMutationTypes());
        
        for (AttachmentPoint ap : lstAPs)
        {
            AttachmentPoint cAp = new AttachmentPoint(c, -1, null, 
                    ap.getAPClass());
            cAp.setCutId(ap.getCutId());
            cAp.setID(ap.getID());
            c.lstAPs.add(cAp);
        }
 
        List<SymmetricAPs> cLstSymAPs = new ArrayList<SymmetricAPs>();
        for (SymmetricAPs symAPs : lstSymAPs)
        {
            SymmetricAPs cSymAPs = new SymmetricAPs();
            for (AttachmentPoint ap : symAPs)
            {
                cSymAPs.add(c.getAP(ap.getIndexInOwner()));
            }
            cLstSymAPs.add(cSymAPs);
        }
        
        c.setSymmetricAPSets(cLstSymAPs);
        c.setProperties(this.copyStringBasedProperties());
        if (uniquefyingPropertyKeys!=null)
            c.uniquefyingPropertyKeys.addAll(uniquefyingPropertyKeys);
        return c;
    }
    
//------------------------------------------------------------------------------
 
    public void addAP() {
        AttachmentPoint ap = new AttachmentPoint(this);
        getAttachmentPoints().add(ap);
    }
      
//------------------------------------------------------------------------------
 
      public void addAP(APClass apClass) {
          AttachmentPoint ap = new AttachmentPoint(this,
                  -1, null, apClass);
          getAttachmentPoints().add(ap);
      }
      
//------------------------------------------------------------------------------
 
    public boolean sameAs(EmptyVertex other, StringBuilder reason)
    {
        if (this.uniquefyingPropertyKeys.size()!=0
                || other.uniquefyingPropertyKeys.size()!=0)
        {
            if (!this.uniquefyingPropertyKeys.equals(other.uniquefyingPropertyKeys))
                return false;
            
            for (String k : this.uniquefyingPropertyKeys)
            {
                if (!this.properties.get(k).equals(other.properties.get(k)))
                    return false;
            }
        }
        return sameVertexFeatures(other, reason);
    }
    
//------------------------------------------------------------------------------
 
    public int getHeavyAtomsCount()
    {
        return 0;
    }
 
//------------------------------------------------------------------------------
 
    public boolean containsAtoms()
    {
        return false;
    }
 
//-----------------------------------------------------------------------------
 
    @Override
    public IAtomContainer getIAtomContainer()
    {
        IAtomContainer iac = new AtomContainer();
        iac.setProperty(DENOPTIMConstants.APSTAG, "");
        iac.setProperty(DENOPTIMConstants.VERTEXJSONTAG,this.toJson());
        
        return iac;
    }
    
//------------------------------------------------------------------------------
    
    @Override
    public IAtomContainer getIAtomContainer(Logger logger, 
            Randomizer rng, boolean removeUsedRCAs, boolean rebuild)
    {
        return getIAtomContainer();
    }
    
//------------------------------------------------------------------------------
    
    public String toJson()
    {    
        Gson gson = DENOPTIMgson.getWriter();
        String jsonOutput = gson.toJson(this);
        return jsonOutput;
    }
    
//------------------------------------------------------------------------------
    
    public static EmptyVertex fromJson(String json)
    {   
        Gson gson = DENOPTIMgson.getReader();
        EmptyVertex ev = gson.fromJson(json, EmptyVertex.class);
        for (AttachmentPoint ap : ev.getAttachmentPoints())
        {
            ap.setOwner(ev);
        }
        return ev;
    }
 
//-----------------------------------------------------------------------------
 
    public ArrayList<APClass> getAllAPClasses()
    {
        ArrayList<APClass> lst = new ArrayList<APClass>();
        for (AttachmentPoint ap : lstAPs)
        {
            APClass apCls = ap.getAPClass();
            if (!lst.contains(apCls))
            {
                lst.add(apCls);
            }
        }
        return lst;
    }
 
//-----------------------------------------------------------------------------
 
    @Override
    protected void setSymmetricAPSets(List<SymmetricAPs> sAPs)
    {
        this.lstSymAPs = sAPs;
    }
    
//-----------------------------------------------------------------------------
 
    @Override
    protected void addSymmetricAPSet(SymmetricAPs symAPs)
    {
        if (this.lstSymAPs==null)
        {
            this.lstSymAPs = new ArrayList<SymmetricAPs>();
        }
        this.lstSymAPs.add(symAPs);
    }
 
//-----------------------------------------------------------------------------
 
    @Override
    public List<SymmetricAPs> getSymmetricAPSets()
    {
        return lstSymAPs;
    }
 
//------------------------------------------------------------------------------
 
    @Override
    public List<Vertex> getMutationSites(List<MutationType> ignoredTypes)
    {
        List<Vertex> lst = new ArrayList<Vertex>();
        switch (getBuildingBlockType())
        {
            case CAP:
                break;
                
            case SCAFFOLD:
                break;
                
            default:
                if (getMutationTypes(ignoredTypes).size()>0)
                    lst.add(this);
                break;
        }
        return lst;
    }
    
//------------------------------------------------------------------------------
 
}