CGroup.java

Go to the documentation of this file.

package org.lightvoting.simulation.environment;

import cern.colt.bitvector.BitVector;
import org.lightjason.agentspeak.language.CLiteral;
import org.lightjason.agentspeak.language.CRawTerm;
import org.lightjason.agentspeak.language.ILiteral;
import org.lightjason.agentspeak.language.ITerm;
import org.lightjason.agentspeak.language.instantiable.plan.trigger.CTrigger;
import org.lightjason.agentspeak.language.instantiable.plan.trigger.ITrigger;
import org.lightvoting.simulation.agent.CChairAgent;
import org.lightvoting.simulation.agent.CVotingAgent;

import java.util.LinkedList;
import java.util.List;

public class CGroup
{
    private final List<CVotingAgent> m_agentList;

    private final int m_capacity = 3;

    private final CChairAgent m_chair;

    private boolean m_open;

    private BitVector m_result;

    private boolean m_readyForElection;
    private boolean m_inProgress;

    public CGroup( final CVotingAgent p_votingAgent, final String p_grouping )
    {
        m_agentList = new LinkedList<>();
        m_agentList.add( p_votingAgent );
        m_chair = p_votingAgent.getChair();
        m_open = true;
        m_result = null;
        if ( "RANDOM".equals( p_grouping ) )
            m_readyForElection = false;
        else
            m_readyForElection = true;
        m_inProgress = false;
    }

    public ILiteral literal( final CVotingAgent p_votingAgent )
    {
        return CLiteral.from( "group", CRawTerm.from( m_chair ), CRawTerm.from( this.open() ), CRawTerm.from( m_result ),
                              CRawTerm.from( m_agentList.contains( p_votingAgent ) ) );
    }

    public ILiteral literal( final CChairAgent p_chairAgent )
    {
        final List<ITerm> l_terms = new LinkedList<>();

        for ( int i = 0; i < m_agentList.size(); i++ )
            l_terms.add( CRawTerm.from( m_agentList.get( i ) ) );


        if ( ( this.m_chair ).equals( p_chairAgent ) )
            return CLiteral.from( "group", CRawTerm.from( this ) );
        else return null;
    }

    public boolean readyForElection()
    {
        return m_readyForElection;
    }

    public void addRandom( final CVotingAgent p_votingAgent )
    {
        System.out.println( "Adding agent, old size is " + m_agentList.size() );
        m_agentList.add( p_votingAgent );
        if ( m_agentList.size() >= m_capacity )
        {
            m_open = false;
            m_readyForElection = true;
        }
    }

    public void addCoordinated( final CVotingAgent p_votingAgent )
    {

        System.out.println( "Adding agent, old size is " + m_agentList.size() );
        m_agentList.add( p_votingAgent );
        m_open = false;
        m_readyForElection = true;
    }

    public void remove( final CVotingAgent p_votingAgent )
    {
        m_agentList.remove( p_votingAgent );
    }

    public boolean open()
    {
        return m_open;
    }

    public boolean electionInProgress()
    {
        return m_inProgress;
    }

    public void startProgress()
    {
        m_inProgress = true;
    }

    public void triggerAgents( final CChairAgent p_chairAgent )
    {
        m_agentList.forEach( i ->
            i.trigger(
                CTrigger.from(
                    ITrigger.EType.ADDGOAL,
                    CLiteral.from(
                        "submit/vote",
                        CRawTerm.from( p_chairAgent ) )
                )
            )
        );
    }

    public int size()
    {
        return m_agentList.size();
    }

    public ILiteral updateBasic( final CChairAgent p_chairAgent, final BitVector p_result )
    {
        // send result of election to all agents in the group
        m_agentList.stream().forEach( i ->
            i.trigger( CTrigger.from(
                ITrigger.EType.ADDGOAL,
                CLiteral.from( "election/result",
                               CRawTerm.from( p_chairAgent ),
                               CRawTerm.from( p_result ) )
                       )
            )
        );

        m_result = p_result;
        return this.literal( p_chairAgent );
    }

    public ILiteral updateIterative( final CChairAgent p_chairAgent, final BitVector p_result, final int p_iteration )
    {
        // send result of election to all agents in the group
        m_agentList.stream().forEach( i ->
        {
            i.trigger( CTrigger.from(
                ITrigger.EType.ADDGOAL,
                CLiteral.from( "election/result",
                               CRawTerm.from( p_chairAgent ),
                               CRawTerm.from( p_result  ),
                               CRawTerm.from( p_iteration ) )
                       )
            );
            System.out.println( "triggering agent " + i.name() );
        } );

        m_result = p_result;
        return this.literal( p_chairAgent );

    }

    public void reset()
    {
        m_inProgress = false;
        m_readyForElection = false;
    }

    public void reopen()
    {
        if ( m_agentList.size() < m_capacity )
        {
            m_open = true;
        }
    }

    public BitVector result()
    {
        return m_result;
    }


    public boolean finale()
    {
        return m_agentList.size() >= m_capacity;
    }

    public void makeReady()
    {
        m_readyForElection = true;
    }

    public CVotingAgent determineAgent( final String p_agentName )
    {
        for ( int i = 0; i < m_agentList.size(); i++ )
            if ( p_agentName.equals( m_agentList.get( i ).name() ) )
                return m_agentList.get( i );
        return null;
    }
}