Ring.java

Go to the documentation of this file.

/*
 *   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/>.
 */
 
package denoptim.graph;
 
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
 
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
 
import denoptim.exception.DENOPTIMException;
import denoptim.graph.Edge.BondType;
 
public class Ring
{
    private List<Vertex> vertices;
 
    private BondType bndTyp = BondType.UNDEFINED; 
 
//------------------------------------------------------------------------------
 
    public Ring()
    {
        vertices = new ArrayList<>();
    }
    
//------------------------------------------------------------------------------
    
    public Ring(List<Vertex> vertices)
    {
        this.vertices = vertices;
    }
    
//------------------------------------------------------------------------------
 
    public void addVertex(Vertex v)
    {
        vertices.add(v);
    }
    
//------------------------------------------------------------------------------
 
    public Vertex getHeadVertex()
    {
        return vertices.get(0);
    }
 
//------------------------------------------------------------------------------
 
    public Vertex getTailVertex()
    {
        return vertices.get(vertices.size() - 1);
    }
 
//------------------------------------------------------------------------------
 
    public Vertex getVertexAtPosition(int i)
    {
    if (i>= vertices.size() || i<0)
    {
        return null;
    }
        return vertices.get(i);
    }
 
//------------------------------------------------------------------------------
    
    public int indexOf(Vertex v)
    {
        return vertices.indexOf(v);
    }
    
//------------------------------------------------------------------------------
 
    public int getSize()
    {
        return vertices.size();
    }
 
//------------------------------------------------------------------------------
 
    public BondType getBondType()
    {
        return bndTyp;
    }
 
//------------------------------------------------------------------------------
 
    public void setBondType(BondType bndType)
    {
        this.bndTyp = bndType;
    }
 
//------------------------------------------------------------------------------
 
    public boolean contains(Vertex v)
    {
        return vertices.contains(v);
    }
 
//------------------------------------------------------------------------------
 
    public boolean containsID(int vid)
    {
    boolean result = false;
    for (Vertex v : vertices)
    {
        if (v.getVertexId() == vid)
        {
        result = true;
        break;
        }
    }
    return result;
    }
    
//------------------------------------------------------------------------------
 
    @Override
    public String toString() {
        return "DENOPTIMRing [vertices=" + vertices + "]";
    }
 
//------------------------------------------------------------------------------
 
    public List<Vertex> getVertices() {
        return Collections.unmodifiableList(vertices);
    }
 
//------------------------------------------------------------------------------
 
    public static class DENOPTIMRingSerializer
    implements JsonSerializer<Ring>
    {
        @Override
        public JsonElement serialize(Ring ring, Type typeOfSrc,
              JsonSerializationContext context)
        {
            JsonObject jsonObject = new JsonObject();
            ArrayList<Long> vertexIDs = new ArrayList<Long>();
            for (int i=0; i<ring.getSize(); i++)
            {
                Vertex v = ring.getVertexAtPosition(i);
                vertexIDs.add(v.getVertexId());
            }
            jsonObject.add("vertices",context.serialize(vertexIDs));
            jsonObject.add("bndTyp",context.serialize(ring.getBondType()));
            return jsonObject;
        }
    }
    
//------------------------------------------------------------------------------
    
    public void removeVertex(Vertex oldVrtx)
    {
        int idx = vertices.indexOf(oldVrtx);
        vertices.remove(idx);
    }
 
//------------------------------------------------------------------------------
    
    public void replaceVertex(Vertex oldVrtx, Vertex newVrtx)
    {
        int idx = vertices.indexOf(oldVrtx);
        vertices.set(idx, newVrtx);
    }
 
    
//------------------------------------------------------------------------------
    
    public boolean insertVertex(int position, Vertex newLink)
    {
        if (this.contains(newLink) || position>=vertices.size())
            return false;
        
        vertices.add(position,newLink);
        return true;
    }
    
//------------------------------------------------------------------------------
    
    public boolean insertVertex(Vertex newLink, Vertex vA,
            Vertex vB)
    {
        if (this.contains(newLink) || !this.contains(vA) || !this.contains(vB))
            return false;
        
        int idA = vertices.indexOf(vA);
        int idB = vertices.indexOf(vB);
        if (idA < idB)
        {
            vertices.add(idB,newLink);
        } else {
            vertices.add(idA,newLink);
        }
        return true;
    }
 
//------------------------------------------------------------------------------
 
    public int getDistance(Vertex v1, Vertex v2) throws DENOPTIMException
    {
        if (!contains(v1))
            throw new DENOPTIMException("Cannot measure distance along ring "
                    + "because " + v1 + " does not belong ring " + this);
        if (!contains(v2))
            throw new DENOPTIMException("Cannot measure distance along ring "
                    + "because " + v2 + " does not belong ring " + this);
        
        int pV1 = vertices.indexOf(v1);
        int pV2 = vertices.indexOf(v2);
        
        return Math.max(pV1,pV2) - Math.min(pV1, pV2);
    }
    
//------------------------------------------------------------------------------
    
    public Vertex getCloserToHead(Vertex vA, Vertex vB)
    {
        return getCloserTo(vA, vB, vertices.get(0));
    }
    
//------------------------------------------------------------------------------
 
    public Vertex getCloserToTail(Vertex vA, Vertex vB)
    {
        return getCloserTo(vA, vB, vertices.get(vertices.size() - 1));
    }
    
//------------------------------------------------------------------------------
    
    public Vertex getCloserTo(Vertex vA, Vertex vB,
            Vertex vT)
    {
        int dA = -1, dB = -1;
        try
        {
            dA = getDistance(vA, vT);
        } catch (DENOPTIMException e)
        {
            if (contains(vB))
                return vB;
            else
                return null;
        }
        try
        {
            dB = getDistance(vB, vT);
        } catch (DENOPTIMException e)
        {
            if (contains(vA))
                return vA;
            else
                return null;
        }
        if (dA<=dB)
            return vA;
        else
            return vB;
    }
    
//------------------------------------------------------------------------------
    
    public int getPositionOf(Vertex v)
    {
        return vertices.indexOf(v);
    }
 
//------------------------------------------------------------------------------
 
}