source: src/main/java/genius/gui/negosession/ContentProxy.java@ 346

package genius.gui.negosession;

import java.util.ArrayList;
import java.util.List;

import genius.core.repository.DomainRepItem;
import genius.core.repository.MultiPartyProtocolRepItem;
import genius.core.repository.ParticipantRepItem;
import genius.core.repository.PartyRepItem;
import genius.core.repository.ProfileRepItem;
import genius.core.repository.RepItem;
import genius.core.repository.Repository;
import genius.core.repository.RepositoryFactory;

/**
 * Proxy service to the {@link genius.core.repository.Repository}. This abstracts
 * all the plumbing and lets the GUI/Config just grab the requested values
 */
public final class ContentProxy {
        /**
         * Use the repository object to fetch protocols
         *
         * @return A list of MultiPartyProtocolRepItem represented in
         *         multipartprotocolsrepository.xml
         */
        public static List<MultiPartyProtocolRepItem> fetchProtocols() {
                // initialize original list and casted list
                List<MultiPartyProtocolRepItem> items = RepositoryFactory.getMultiPartyProtocolRepository().getItems();
                List<MultiPartyProtocolRepItem> itemsCasted = new ArrayList<MultiPartyProtocolRepItem>(items.size());

                // cast list element-wise
                for (RepItem item : items)
                        itemsCasted.add((MultiPartyProtocolRepItem) item);

                // return casted list
                return itemsCasted;
        }

        /**
         * Use the repository object to fetch domains
         *
         * @return A list of MultiPartyProtocolRepItem represented in
         *         domainrepository.xml
         */
        
        public static List<DomainRepItem> fetchDomains() {
                        
                Repository<DomainRepItem> domainrep = RepositoryFactory.get_domain_repos();
                List<DomainRepItem> domList = new ArrayList<DomainRepItem>();
                for (DomainRepItem domain : domainrep.getItems()) {
                        domList.add(domain);
                }
                return domList;
        }
        
        
        
        /**
         * Use the repository object to fetch non-mediator parties
         *
         * @return All parties as defined in partyrepository.xml that have mediator
         *         not set (or set to false)
         */
        public static List<ParticipantRepItem> fetchParties() {
                // initialize original list and casted list
                List<ParticipantRepItem> items = new ArrayList<>();
                items.addAll(RepositoryFactory.get_party_repository().getItems());
                items.addAll(RepositoryFactory.getBoaPartyRepository().getList().getList());
                List<ParticipantRepItem> itemsCasted = new ArrayList<>();

                // cast list element-wise and remove mediators
                for (RepItem item : items) {
                        ParticipantRepItem prItem = (ParticipantRepItem) item;
                        if (!prItem.isMediator())
                                itemsCasted.add(prItem);
                }

                // return casted list
                return itemsCasted;
        }

        /**
         * Use the repository object to fetch non-mediator parties
         *
         * @param protocol
         *            The protocol the requested parties should support
         * @return All parties as defined in partyrepository.xml that have mediator
         *         not set (or set to false) and have protocol set to the given
         *         protocol
         */
        public static List<ParticipantRepItem> fetchPartiesForProtocol(MultiPartyProtocolRepItem protocol) {
                List<ParticipantRepItem> items = fetchParties();
                List<ParticipantRepItem> filtered = new ArrayList<ParticipantRepItem>();
                for (ParticipantRepItem item : items)
                        if (item.getProtocolClassPath().equals(protocol.getClassPath()))
                                filtered.add(item);

                return filtered;
        }

        /**
         * Use the repository object to fetch mediator parties
         *
         * @return All the parties as defined in partyrepository.xml that have
         *         mediator set to true
         */
        public static List<PartyRepItem> fetchMediators() {
                // initialize original list and casted list
                List<PartyRepItem> items = RepositoryFactory.get_party_repository().getItems();
                List<PartyRepItem> itemsCasted = new ArrayList<PartyRepItem>(items.size());

                // cast list element-wise and only add mediators
                for (RepItem item : items) {
                        PartyRepItem prItem = (PartyRepItem) item;
                        if (prItem.isMediator())
                                itemsCasted.add(prItem);
                }

                // return casted list
                return itemsCasted;
        }

        /**
         * Use the repository object to fetch mediator parties
         *
         * @param protocol
         *            The protocol the requested mediator should support
         * @return All the parties as defined in partyrepository.xml that have
         *         mediator set to true and have protocol set to the given protocol
         */
        public static List<PartyRepItem> fetchMediatorsForProtocol(MultiPartyProtocolRepItem protocol) {
                List<PartyRepItem> items = fetchMediators();
                List<PartyRepItem> filtered = new ArrayList<PartyRepItem>(items.size());
                for (PartyRepItem item : items)
                        if (item.getProtocolClassPath().equals(protocol.getClassPath()))
                                filtered.add(item);

                return filtered;
        }

        /**
         * Use the repository object to fetch profiles
         *
         * @return All the profiles as defined in domainrepository.xmls
         */
        public static List<ProfileRepItem> fetchProfiles() {
                try {
                        Repository<DomainRepItem> domainrep = RepositoryFactory.get_domain_repos();
                        ArrayList<ProfileRepItem> profiles = new ArrayList<ProfileRepItem>();
                        for (RepItem domain : domainrep.getItems()) {
                                for (ProfileRepItem profile : ((DomainRepItem) domain).getProfiles())
                                        profiles.add(profile);
                        }
                        return profiles;
                } catch (Exception e) {
                        e.printStackTrace();
                        return new ArrayList<ProfileRepItem>();
                }

        }

        /**
         * Use the repository object to fetch profiles corresponding to a PARTICULAR domain
         *
         * @return All the profiles associated with the domain defined in domainrepository.xmls
         */
        
        public static List<ProfileRepItem> fetchDomainSpecificProfiles(DomainRepItem domRepItem) {
                List<ProfileRepItem> profiles = new ArrayList<ProfileRepItem>();
                                for (ProfileRepItem profile : domRepItem.getProfiles())
                                        profiles.add(profile);  
                        return profiles;                
        }
        
        
        
        /**
         * When fetching a list of type PartyRepItem, you must also provide the
         * protocol. Otherwise it can be null.
         * 
         * @param elementType
         *            can be ProfileRepItem.class or PartyRepItem.class and must be
         *            equal to T.
         * @param protocol
         * @return list of objects of type T in the repository of type T.
         */
        public static <T extends RepItem> List<T> fetchList(Class<T> elementType, MultiPartyProtocolRepItem protocol) {
                if (elementType == ProfileRepItem.class) {
                        return (List<T>) fetchProfiles();
                }
                if (elementType == PartyRepItem.class) {
                        return (List<T>) fetchPartiesForProtocol(protocol);
                }
                throw new IllegalArgumentException("unhandled type " + elementType);
        }
}