D-Net

{

  "type_source": "SVN", 

  "goal": "package -U -T 4C source:jar", 

  "url": "http://svn-public.driver.research-infrastructures.eu/driver/dnet40/modules/uoa-utils/trunk", 

  "deploy_repository": "dnet4-snapshots", 

  "version": "4", 

  "mail": "antleb@di.uoa.gr, kiatrop@di.uoa.gr", 

  "deploy_repository_url": "http://maven.research-infrastructures.eu/nexus/content/repositories/dnet4-snapshots", 

  "name": "uoa-utils"

}

ISLookUpService.url= INVALID LINK!!! ISLookUpService

ISRegistryService.url= INVALID LINK!!! ISRegistryService

ResultSetService.url= INVALID LINK!!! ResultSetService

ISSNService.url= INVALID LINK!!! ISSNService

DBService.url= INVALID LINK!!! DBService

ActionManagerService.url = INALVID LINK!!! action Service

A2Service.url= INVALID LINK!!! A2Service

UserProfileService.url= INVALID LINK!!! UserProfileService

IndexService.url= INVALID LINK!!! IndexService

SearchService.url= INVALID LINK!!! SearchService

CommunityService.url= INVALID LINK!!! CommunityService

CollectionService.url= INVALID LINK!!! CollectionService

PublisherService.url= INVALID LINK!!! PublisherService

RecommendationService.url= INVALID LINK!!! RecommendationService

ValidatorService.url= INVALID LINK!!! ValidatorService

ForumService.url = INVALID LINK!!! ForumService

RatingService.url = INVALID LINK!!! RatingService

WebInterfaceService.url = INVALID LINK!!! WebInterfaceService

ValidatorUserInterfaceService.url = INVALID LINK!!! ValidatorUserInterfaceService

DatasourceManagerService.url = SKATASKATASKATA datasource

MDStoreService.url = SKATASKATA MDSTORE

services.similarityService.ws.url = INVALID LINK!!! similarityService

services.alertService.ws.url = INVALID LINK!!! alertService

services.notificationService.ws.url = INVALID LINK!!! notificationService

services.conversionService.ws.url = INVALID LINK!!! conversionService

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

	xmlns:context="http://www.springframework.org/schema/context"

	xmlns:cxf="http://cxf.apache.org/core" 

	xmlns:jaxws="http://cxf.apache.org/jaxws"

	xmlns:p="http://http://www.springframework.org/schema/p"

	xsi:schemaLocation="

		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd

        http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd

        http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd"

	default-autowire="byName">

	<bean id="cnr.lookUpLocator" class="eu.dnetlib.enabling.tools.StaticServiceLocator">

		<property name="service" ref="cnr.lookUpService" />

	</bean>

	<alias name="cnr.lookUpLocator" alias="lookupLocator" />

	<jaxws:client id="cnr.lookUpService"

		serviceClass="eu.dnetlib.enabling.is.lookup.rmi.ISLookUpService" 

		address="${ISLookUpService.url}" />

	<bean id="cnr.registryLocator" class="eu.dnetlib.enabling.tools.StaticServiceLocator">

		<property name="service" ref="cnr.registryService" />

	</bean>

	<alias name="cnr.registryLocator" alias="registryLocator" />

	<jaxws:client id="cnr.registryService"

		serviceClass="eu.dnetlib.enabling.is.registry.rmi.ISRegistryService" 

		address="${ISRegistryService.url}" />

	<bean id="cnr.snLocator" class="eu.dnetlib.enabling.tools.StaticServiceLocator">

		<property name="service" ref="cnr.snService" />

	</bean>

	<alias name="cnr.snLocator" alias="snLocator" />

	<jaxws:client id="cnr.snService"

		serviceClass="eu.dnetlib.enabling.is.sn.rmi.ISSNService" 

		address="${ISSNService.url}" />

	<!-- The service locators -->

	<bean id="lookupServiceLocator" 

		class="eu.dnetlib.clients.utils.ws.JaxwsServiceLocator">

		<property name="url" value="${ISLookUpService.url}" />

		<property name="eprBuilder" ref="cxfEndpointReferenceBuilder" />

		<property name="resolver" ref="serviceResolver" />

		<property name="serviceClass" value="eu.dnetlib.api.enabling.ISLookUpService" />

	</bean>

	<bean id="registryServiceLocator" 

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.enabling.ISRegistryService" />

		<constructor-arg value="${ISRegistryService.url}" />

	</bean>

	<bean id="resultSetServiceLocator" 

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.enabling.ResultSetService" />

		<constructor-arg value="${ResultSetService.url}" />

	</bean>

	<bean id="subscriptionServiceLocator" 

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.enabling.ISSNService" />

		<constructor-arg value="${ISSNService.url}" />

	</bean>

	<bean id="datasourceManagerServiceLocator" 

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.data.DatasourceManagerService" />

		<constructor-arg value="${DatasourceManagerService.url}" />

	</bean>

	<bean id="mdStoreServiceLocator"

		  factory-bean="serviceLocatorFactory"

		  factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.data.MDStoreService" />

		<constructor-arg value="${MDStoreService.url}" />

	</bean>

	<bean id="dbServiceLocator" 

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.enabling.DatabaseService" />

		<constructor-arg value="${DBService.url}" />

	</bean>

	<bean id="actionManagerLocator"

                factory-bean="serviceLocatorFactory"

                factory-method="newServiceLocator">

                <constructor-arg value="eu.dnetlib.api.enabling.ActionManagerService" />

                <constructor-arg value="${ActionManagerService.url}" />

        </bean>

	<bean id="a2ServiceLocator" 

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.enabling.A2Service" />

		<constructor-arg value="${A2Service.url}" />

	</bean>

	<bean id="userProfileServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.UserProfileService" />

		<constructor-arg value="${UserProfileService.url}" />

	</bean>

	<bean id="indexServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.data.IndexService" />

		<constructor-arg value="${IndexService.url}" />

	</bean>

	<bean id="searchServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.data.SearchService" />

		<constructor-arg value="${SearchService.url}" />

	</bean>

	<bean id="communityServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.CommunityService" />

		<constructor-arg value="${CommunityService.url}" />

	</bean>

	<bean id="collectionServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.CollectionService" />

		<constructor-arg value="${CollectionService.url}" />

	</bean>	

	<bean id="conversionServiceLocator" 

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.ConversionService" />

		<constructor-arg value="${services.conversionService.ws.url}" />

	</bean>

	<bean id="publisherServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.data.PublisherService" />

		<constructor-arg value="${PublisherService.url}" />

	</bean>

	<bean id="recommendationServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.RecommendationService" />

		<constructor-arg value="${RecommendationService.url}" />

	</bean>

	<bean id="validatorServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.ValidatorService" />

		<constructor-arg value="${ValidatorService.url}" />

	</bean>

	<bean id="forumServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.ForumService" />

		<constructor-arg value="${ForumService.url}" />

	</bean>

	<bean id="ratingServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.RatingService" />

		<constructor-arg value="${RatingService.url}" />

	</bean>

	<bean id="webIntarfaceServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.WebInterfaceService" />

		<constructor-arg value="${WebInterfaceService.url}" />

	</bean>

	<bean id="validatorWebServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.ValidatorUserInterfaceService" />

		<constructor-arg value="${ValidatorUserInterfaceService.url}" />

	</bean>

	<bean id="similarityServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.data.SimilarityService" />

		<constructor-arg value="${services.similarityService.ws.url}" />

	</bean>	

	<bean id="alertServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.AlertService" />

		<constructor-arg value="${services.alertService.ws.url}" />

	</bean>	

		<bean id="notificationServiceLocator"

		factory-bean="serviceLocatorFactory"

		factory-method="newServiceLocator">

		<constructor-arg value="eu.dnetlib.api.functionality.NotificationService" />

		<constructor-arg value="${services.notificationService.ws.url}" />

	</bean>	

</beans>

package gr.uoa.di.driver.util;

import eu.dnetlib.api.DriverService;

/**

 * A factory to create service locators.

 * 

 * @author <a href="mailto:antleb@di.uoa.gr">Antonis Lempesis</a>

 *

 */

public interface ServiceLocatorFactory {

	/**

	 * Creates a dynamic service locator.

	 * 

	 * @param <S> the service type.

	 * @param serviceClass the service class.

	 * @return A service locator for services of type S.

	 */

	public <S extends DriverService> ServiceLocator<S> newServiceLocator(

			Class<S> serviceClass);

	/**

	 * Creates a service locator. It can be either static (if serviceUrl != null)

	 * or dynamic.

	 * 

	 * @param <S> the service type.

	 * @param serviceClass the service class.

	 * @param serviceUrl The service URL.

	 * @return A service locator for services of type S.

	 */

	public <S extends DriverService> ServiceLocator<S> newServiceLocator(

			Class<S> serviceClass, String serviceUrl);

}

package gr.uoa.di.driver.util;

import eu.dnetlib.api.DriverService;

/**

 * An implementation of the ServiceLocator that returns a predefined instance

 * of a service.

 * 

 * Can be used for debug purposes, FallBackLocator or when 2 services A and B 

 * are deployed in the same application (in this case, service A will get an 

 * instance of a StaticServiceLocator<B> in order to avoid calls to the IS and 

 * traversing the whole SOAP stack in order to communicate with B). 

 * 

 * @author <a href="mailto:antleb@di.uoa.gr">Antonis Lempesis</a>

 *

 * @param <S>

 */

public class StaticServiceLocator<S extends DriverService>

	implements ServiceLocator<S> {

	private S service = null;

	public StaticServiceLocator() {

	}

	public StaticServiceLocator(S service) {

		this.service = service;

	}

	@Override

	public S getService() {

		return service;

	}

	public void setService(S service) {

		this.service = service;

	}

}

package gr.uoa.di.driver.util;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

import org.apache.log4j.Logger;

import eu.dnetlib.api.DriverService;

/**

 * An implementation of the service locator that keeps a cache of the service

 * and refreshes it periodically.

 * 

 * The actual task of service discovery is performed by a locator that is 

 * injected. 

 * 

 * @author <a href="mailto:antleb@di.uoa.gr">Antonis Lempesis</a>

 *

 * @param <S> the service type

 */

public class RefreshingServiceLocator<S extends DriverService> implements

		ServiceLocator<S> {

	/** The locator used to discover the service */

	private ServiceLocator<S> locator = null;

	/** the cached instance of the service */

	private S service = null;

	/** the executor that runs the refresh tasks */

	private ScheduledExecutorService executor = null;

	/** the discovery period in milliseconds*/

	private long period = 0;

	@Override

	public synchronized S getService() {

		if (service == null)

			init();

		return service;

	}

	/** 

	 * Called to initialize the locator. Performs the first service lookup and

	 * also schedules the periodic refresh of the cache. 

	 * 

	 * */

	private void init() {

		this.service = locator.getService();

		executor.scheduleWithFixedDelay(new RefreshTask(), period, period,

				TimeUnit.MILLISECONDS);

	}

	/**

	 * A very simple runnable that refreshed the cache. No synchronization is

	 * needed during cache refresh: The old instance will be returned while the

	 * locator is working to refresh the cache.

	 * 

	 * @author <a href="mailto:antleb@di.uoa.gr">Antonis Lempesis</a>

	 *

	 */

	private class RefreshTask implements Runnable {

		private Logger logger = Logger.getLogger(RefreshTask.class);

		@Override

		public void run() {

			try {

				logger.debug("Refreshing service cache");

				service = locator.getService();

			} catch (Exception e) {

				logger.info("Error refreshing service", e);

			}

		}

	}

	public ServiceLocator<S> getLocator() {

		return locator;

	}

	public void setLocator(ServiceLocator<S> locator) {

		this.locator = locator;

	}

	public ScheduledExecutorService getExecutor() {

		return executor;

	}

	public void setExecutor(ScheduledExecutorService executor) {

		this.executor = executor;

	}

	public long getPeriod() {

		return period;

	}

	public void setPeriod(long period) {

		this.period = period;

	}

}

package gr.uoa.di.driver.util;

import eu.dnetlib.api.DriverService;

public class FallBackServiceLocator<S extends DriverService>

	implements ServiceLocator<S> {

	private ServiceLocator<S> mainLocator = null;

	private ServiceLocator<S> fallBackLocator = null;

	@Override

	public S getService() {

		S service = null;

		if (mainLocator != null)

			service = mainLocator.getService();

		if (service == null && fallBackLocator != null)

			service = fallBackLocator.getService();

		return service;

	}

	public FallBackServiceLocator(ServiceLocator<S> mainLocator,

			ServiceLocator<S> fallBackLocator) {

		this.mainLocator = mainLocator;

		this.fallBackLocator = fallBackLocator;

	}

	public void setMainLocator(ServiceLocator<S> mainLocator) {

		this.mainLocator = mainLocator;

	}

	public void setFallBackLocator(ServiceLocator<S> fallBackLocator) {

		this.fallBackLocator = fallBackLocator;

	}

}

package gr.uoa.di.driver.util;

import eu.dnetlib.api.DriverService;

public interface ServiceLocator<S extends DriverService> {

	public S getService();

}

package gr.uoa.di.driver.util;

import java.util.HashMap;

import java.util.Map;

import eu.dnetlib.api.DriverService;

import eu.dnetlib.enabling.tools.registration.ServiceNameResolver;

public class ServiceNameResolverImpl implements ServiceNameResolver {

	private Map<Class<?>, String> override = new HashMap<Class<?>, String>();

	@Override

	public String getName(Object service) {

		return getName(service.getClass());

	}

	@Override

	public String getName(Class<?> serviceInterface) {

		String serviceName = null;

		for (Class<?> i : serviceInterface.getInterfaces()) {

			if (DriverService.class.isAssignableFrom(i)) {

				if (override.get(i) != null)

					serviceName = override.get(i);

				else

					serviceName = i.getSimpleName();

			}

		}

		return serviceName;

	}

	public Map<Class<?>, String> getOverride() {

		return override;

	}

	public void setOverride(Map<Class<?>, String> override) {

		this.override = override;

	}

}

package eu.dnetlib.utils.cql;

import static eu.dnetlib.utils.cql.CqlClause.CqlClauseType.BOOLEAN;

import static eu.dnetlib.utils.cql.CqlClause.CqlClauseType.RELATION;

import static eu.dnetlib.utils.cql.CqlClause.CqlClauseType.TERM;

import java.util.ArrayList;

import java.util.List;

/**

 * @author stoumpos

 * 

 */

public class CqlQuery {

	CqlClause root = null;

	CqlQuery() {

		this(null);

	}

	CqlQuery(CqlClause root) {

		this.root = root;

	}

	public CqlClause getRoot() {

		return root;

	}

	public void setRoot(CqlClause root) {

		this.root = root;

	}

	@Override

	public String toString() {

		return (root == null) ? "null" : root.toCqlString();

	}

	/**

	 * Return <code>true</code> if this query is a superset of

	 * <code>query</code>, otherwise <code>false</code>.

	 */

	public boolean contains(CqlQuery query) {

		return contains(root, query.getRoot());

	}

	private boolean contains(CqlClause big, CqlClause small) {

		if (big.type ==  BOOLEAN && small.type ==  BOOLEAN) {

			return containsBooleans((CqlBoolean) big, (CqlBoolean) small);

		} else if (big.type ==  BOOLEAN) {

			// small is either term or relation

			return containsBooleanTerm((CqlBoolean) big, small);

		} else if (small.type ==  BOOLEAN) {

			// big is either term or relation

			return containsTermBoolean(big, (CqlBoolean) small);

		} else if (big.type == RELATION && small.type == RELATION) {

			CqlRelation bigRelation = (CqlRelation) big;

			CqlRelation smallRelation = (CqlRelation) small;

			return bigRelation.index.equals(smallRelation.index)

				&& bigRelation.operator.equals(smallRelation.operator)

				&& bigRelation.value.equals(smallRelation.value);

		} else if (big.type == TERM && small.type == TERM) {

			return ((CqlTerm) big).term.equals(((CqlTerm) small).term);

		}

		return false;

	}

	private boolean containsBooleans(CqlBoolean a, CqlBoolean b) {

		if (a.getOperator().equalsIgnoreCase(b.getOperator())) {

			ArrayList<CqlClause> aList = unfold(a);

			ArrayList<CqlClause> bList = unfold(b);

			if (a.operator.equalsIgnoreCase("and")) {

				return subset(aList, bList);

			} else if (a.operator.equalsIgnoreCase("or")) {

				return superset(bList, aList);

			} else {

				throw new IllegalArgumentException(

						"Unsupported operator: " + a.operator);

			}

		} else {

			return contains(a, b.getLeft()) && contains(a, b.getRight());

		}

	}

	public ArrayList<CqlClause> unfold(CqlBoolean bool) {

		String op = bool.operator;

		ArrayList<CqlClause> siblings = new ArrayList<CqlClause>();

		if (bool.left.type == BOOLEAN

				&& ((CqlBoolean) bool.left).operator.equalsIgnoreCase(op)) {

			siblings.addAll(unfold((CqlBoolean) bool.left));

		} else {

			siblings.add(bool.left);

		}

		if (bool.right.type == BOOLEAN

				&& ((CqlBoolean) bool.right).operator.equalsIgnoreCase(op)) {

			siblings.addAll(unfold((CqlBoolean) bool.right));

		} else {

			siblings.add(bool.right);

		}

		return siblings;

	}

	private boolean superset(List<CqlClause> superset, List<CqlClause> subset) {

		if (subset.size() > superset.size()) {

			return false;

		}

		for (CqlClause sub : subset) {

			boolean found = false;

			for (CqlClause sup : superset) {

				if (contains(sup, sub)) {

					found = true;

					break;

				}

			}

			if (!found) {

				return false;

			}

		}

		return true;

	}

	private boolean subset(List<CqlClause> subset, List<CqlClause> superset) {

		if (subset.size() > superset.size()) {

			return false;

		}

		for (CqlClause sub : subset) {

			boolean found = false;

			for (CqlClause sup : superset) {

				if (contains(sub, sup)) {

					found = true;

					break;

				}

			}

			if (!found) {

				return false;

			}

		}

		return true;

	}

	private boolean containsBooleanTerm(CqlBoolean bool, CqlClause clause) {

		if (bool.getOperator().equalsIgnoreCase("and")) {

			// warn: assume clause is either term or relation

			return false;

		}

		return contains(bool.getLeft(), clause)

				|| contains(bool.getRight(), clause);

	}

	private boolean containsTermBoolean(CqlClause clause, CqlBoolean bool) {

		if (bool.getOperator().equalsIgnoreCase("or")) {

			// warn: assume clause is either term or relation

			return false;

		}

		return contains(clause, bool.getLeft())

				|| contains(clause, bool.getRight());

	}

}

package eu.dnetlib.utils.cql;

/**

 * @author stoumpos

 * 

 */

public class CqlTerm extends CqlClause {

	String term = null;

	public CqlTerm() {

		this(null);

	}

	public CqlTerm(String term) {

		super(CqlClauseType.TERM);

		this.term = term;

	}

	public String getTerm() {

		return term;

	}

	public void setTerm(String term) {

		this.term = term;

	}

	@Override

	public String toCqlString() {

		return term;

	}

	@Override

	public String toNodeString(String prefix) {

		return prefix + "term: " + toCqlString();

	}

}

package eu.dnetlib.utils.cql;

/**

 * @author stoumpos

 * 

 */

public abstract class CqlClause

{

	public static enum CqlClauseType { BOOLEAN, RELATION, TERM };

	public final CqlClauseType type;

	CqlClause(CqlClauseType type) {

		super();

		this.type = type;

	}

	@Override

	public String toString()

	{

		return toCqlString();

	}

	public abstract String toCqlString();

	public abstract String toNodeString(String prefix);

}

// $ANTLR 3.0.1 Cql.g3 2013-07-19 13:56:26

	package eu.dnetlib.utils.cql;

import org.antlr.runtime.*;

import java.util.Stack;

import java.util.List;

import java.util.ArrayList;

import org.antlr.runtime.tree.*;

public class CqlParser extends Parser {

    public static final String[] tokenNames = new String[] {

        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "AND", "OR", "NOT", "PROX", "WITHIN", "EXACT", "ALL", "ANY", "IDENTIFIER", "STRING", "QUOTE", "WHITESPACE", "'>'", "'='", "'/'", "'('", "')'", "'<'", "'>='", "'<='", "'<>'"

    };

    public static final int QUOTE=14;

    public static final int ANY=11;

    public static final int IDENTIFIER=12;

    public static final int ALL=10;

    public static final int OR=5;

    public static final int WITHIN=8;

    public static final int PROX=7;

    public static final int WHITESPACE=15;

    public static final int EXACT=9;

    public static final int NOT=6;

    public static final int AND=4;

    public static final int EOF=-1;

    public static final int STRING=13;

        public CqlParser(TokenStream input) {

            super(input);

        }

    protected TreeAdaptor adaptor = new CommonTreeAdaptor();

    public void setTreeAdaptor(TreeAdaptor adaptor) {

        this.adaptor = adaptor;

    }

    public TreeAdaptor getTreeAdaptor() {

        return adaptor;

    }

    public String[] getTokenNames() { return tokenNames; }

    public String getGrammarFileName() { return "Cql.g3"; }

      @Override

      public void reportError(RecognitionException e) {

        throw new CqlRuntimeException("Parser Error", e);

      }

    public static class cql_return extends ParserRuleReturnScope {

        public CqlQuery query;

        CommonTree tree;

        public Object getTree() { return tree; }

    };

    // $ANTLR start cql

    // Cql.g3:33:1: cql returns [CqlQuery query] : q= cqlquery ;

    public final cql_return cql() throws RecognitionException {

        cql_return retval = new cql_return();

        retval.start = input.LT(1);

        CommonTree root_0 = null;

        cqlquery_return q = null;

        try {

            // Cql.g3:33:30: (q= cqlquery )

            // Cql.g3:33:32: q= cqlquery

            {

            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_cqlquery_in_cql78);

            q=cqlquery();

            _fsp--;

            adaptor.addChild(root_0, q.getTree());

            						//System.out.println("query tree: " +

            						//		((CommonTree)q.tree).toStringTree() );

            						retval.query = q.query;

            }

            retval.stop = input.LT(-1);

                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException re) {

            reportError(re);

            recover(input,re);

        }

        finally {

        }

        return retval;

    }

    // $ANTLR end cql

    public static class cqlquery_return extends ParserRuleReturnScope {

        public CqlQuery query;

        CommonTree tree;

        public Object getTree() { return tree; }

    };

    // $ANTLR start cqlquery

    // Cql.g3:41:1: cqlquery returns [CqlQuery query] : ( qscope q= cqlquery | c= scopedClause );

    public final cqlquery_return cqlquery() throws RecognitionException {

        cqlquery_return retval = new cqlquery_return();

        retval.start = input.LT(1);

        CommonTree root_0 = null;

        cqlquery_return q = null;

        scopedClause_return c = null;

        qscope_return qscope1 = null;

        try {

            // Cql.g3:42:5: ( qscope q= cqlquery | c= scopedClause )

            int alt1=2;

            int LA1_0 = input.LA(1);

            if ( (LA1_0==16) ) {

                alt1=1;

            }

            else if ( ((LA1_0>=AND && LA1_0<=PROX)||(LA1_0>=IDENTIFIER && LA1_0<=STRING)||LA1_0==19) ) {

                alt1=2;

            }

            else {

                NoViableAltException nvae =

                    new NoViableAltException("41:1: cqlquery returns [CqlQuery query] : ( qscope q= cqlquery | c= scopedClause );", 1, 0, input);

                throw nvae;

            }

            switch (alt1) {

                case 1 :

                    // Cql.g3:42:7: qscope q= cqlquery

                    {

                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_qscope_in_cqlquery104);

                    qscope1=qscope();

                    _fsp--;

                    pushFollow(FOLLOW_cqlquery_in_cqlquery109);

                    q=cqlquery();

                    _fsp--;

                    adaptor.addChild(root_0, q.getTree());

                     retval.query = q.query; 

                    }

                    break;

                case 2 :

                    // Cql.g3:43:7: c= scopedClause

                    {

                    root_0 = (CommonTree)adaptor.nil();

                    pushFollow(FOLLOW_scopedClause_in_cqlquery121);

                    c=scopedClause();

                    _fsp--;

                    adaptor.addChild(root_0, c.getTree());

                     retval.query = new CqlQuery(c.clause); 

                    }

                    break;

            }

            retval.stop = input.LT(-1);

                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException re) {

            reportError(re);

            recover(input,re);

        }

        finally {

        }

        return retval;

    }

    // $ANTLR end cqlquery

    public static class qscope_return extends ParserRuleReturnScope {

        CommonTree tree;

        public Object getTree() { return tree; }

    };

    // $ANTLR start qscope

    // Cql.g3:45:1: qscope : ( '>' prefix '=' uri | '>' uri );

    public final qscope_return qscope() throws RecognitionException {

        qscope_return retval = new qscope_return();

        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token char_literal2=null;

        Token char_literal4=null;

        Token char_literal6=null;

        prefix_return prefix3 = null;

        uri_return uri5 = null;

        uri_return uri7 = null;

        CommonTree char_literal2_tree=null;

        CommonTree char_literal4_tree=null;

        CommonTree char_literal6_tree=null;

        try {

            // Cql.g3:47:9: ( '>' prefix '=' uri | '>' uri )

            int alt2=2;

            int LA2_0 = input.LA(1);

            if ( (LA2_0==16) ) {

                switch ( input.LA(2) ) {

                case IDENTIFIER:

                    {

                    int LA2_2 = input.LA(3);

                    if ( ((LA2_2>=AND && LA2_2<=PROX)||(LA2_2>=IDENTIFIER && LA2_2<=STRING)||LA2_2==16||LA2_2==19) ) {

                        alt2=2;

                    }

                    else if ( (LA2_2==17) ) {

                        alt2=1;

                    }

                    else {

                        NoViableAltException nvae =

                            new NoViableAltException("45:1: qscope : ( '>' prefix '=' uri | '>' uri );", 2, 2, input);

                        throw nvae;

                    }

                    }

                    break;

                case STRING:

                    {

                    int LA2_3 = input.LA(3);

                    if ( ((LA2_3>=AND && LA2_3<=PROX)||(LA2_3>=IDENTIFIER && LA2_3<=STRING)||LA2_3==16||LA2_3==19) ) {

                        alt2=2;

                    }

                    else if ( (LA2_3==17) ) {

                        alt2=1;

                    }

                    else {

                        NoViableAltException nvae =

                            new NoViableAltException("45:1: qscope : ( '>' prefix '=' uri | '>' uri );", 2, 3, input);

                        throw nvae;

                    }

                    }

                    break;

                case AND:

                    {

                    int LA2_4 = input.LA(3);

                    if ( (LA2_4==17) ) {

                        alt2=1;

                    }

                    else if ( ((LA2_4>=AND && LA2_4<=PROX)||(LA2_4>=IDENTIFIER && LA2_4<=STRING)||LA2_4==16||LA2_4==19) ) {

                        alt2=2;

                    }

                    else {

                        NoViableAltException nvae =

                            new NoViableAltException("45:1: qscope : ( '>' prefix '=' uri | '>' uri );", 2, 4, input);

                        throw nvae;

                    }

                    }

                    break;

                case OR:

                    {

                    int LA2_5 = input.LA(3);

                    if ( (LA2_5==17) ) {

                        alt2=1;

                    }

                    else if ( ((LA2_5>=AND && LA2_5<=PROX)||(LA2_5>=IDENTIFIER && LA2_5<=STRING)||LA2_5==16||LA2_5==19) ) {

                        alt2=2;

                    }

                    else {

                        NoViableAltException nvae =

                            new NoViableAltException("45:1: qscope : ( '>' prefix '=' uri | '>' uri );", 2, 5, input);

                        throw nvae;

                    }

                    }

                    break;

                case NOT:

                    {

                    int LA2_6 = input.LA(3);

                    if ( (LA2_6==17) ) {

                        alt2=1;

                    }

                    else if ( ((LA2_6>=AND && LA2_6<=PROX)||(LA2_6>=IDENTIFIER && LA2_6<=STRING)||LA2_6==16||LA2_6==19) ) {

                        alt2=2;

                    }

                    else {

                        NoViableAltException nvae =

                            new NoViableAltException("45:1: qscope : ( '>' prefix '=' uri | '>' uri );", 2, 6, input);

                        throw nvae;

                    }

                    }

                    break;

                case PROX:

                    {

                    int LA2_7 = input.LA(3);

                    if ( (LA2_7==17) ) {

                        alt2=1;

                    }

                    else if ( ((LA2_7>=AND && LA2_7<=PROX)||(LA2_7>=IDENTIFIER && LA2_7<=STRING)||LA2_7==16||LA2_7==19) ) {

                        alt2=2;

                    }

                    else {

                        NoViableAltException nvae =

                            new NoViableAltException("45:1: qscope : ( '>' prefix '=' uri | '>' uri );", 2, 7, input);

                        throw nvae;

                    }

                    }

                    break;

                default:

                    NoViableAltException nvae =

                        new NoViableAltException("45:1: qscope : ( '>' prefix '=' uri | '>' uri );", 2, 1, input);

                    throw nvae;

                }

            }

            else {

                NoViableAltException nvae =

                    new NoViableAltException("45:1: qscope : ( '>' prefix '=' uri | '>' uri );", 2, 0, input);

                throw nvae;

            }

            switch (alt2) {

                case 1 :

                    // Cql.g3:47:11: '>' prefix '=' uri

                    {

                    root_0 = (CommonTree)adaptor.nil();

                    char_literal2=(Token)input.LT(1);

                    match(input,16,FOLLOW_16_in_qscope137); 

                    char_literal2_tree = (CommonTree)adaptor.create(char_literal2);

                    adaptor.addChild(root_0, char_literal2_tree);

                    pushFollow(FOLLOW_prefix_in_qscope139);

                    prefix3=prefix();

                    _fsp--;

                    adaptor.addChild(root_0, prefix3.getTree());

                    char_literal4=(Token)input.LT(1);

                    match(input,17,FOLLOW_17_in_qscope141); 

                    char_literal4_tree = (CommonTree)adaptor.create(char_literal4);

                    adaptor.addChild(root_0, char_literal4_tree);

                    pushFollow(FOLLOW_uri_in_qscope143);

                    uri5=uri();

                    _fsp--;

                    adaptor.addChild(root_0, uri5.getTree());

                    }

                    break;

                case 2 :

                    // Cql.g3:47:32: '>' uri

                    {

                    root_0 = (CommonTree)adaptor.nil();

                    char_literal6=(Token)input.LT(1);

                    match(input,16,FOLLOW_16_in_qscope147); 

                    char_literal6_tree = (CommonTree)adaptor.create(char_literal6);

                    adaptor.addChild(root_0, char_literal6_tree);

                    pushFollow(FOLLOW_uri_in_qscope149);

                    uri7=uri();

                    _fsp--;

                    adaptor.addChild(root_0, uri7.getTree());

                    }

                    break;

            }

            retval.stop = input.LT(-1);

                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException re) {

            reportError(re);

            recover(input,re);

        }

        finally {

        }

        return retval;

    }

    // $ANTLR end qscope

    public static class prefix_return extends ParserRuleReturnScope {

        CommonTree tree;

        public Object getTree() { return tree; }

    };

    // $ANTLR start prefix

    // Cql.g3:48:1: prefix : term ;

    public final prefix_return prefix() throws RecognitionException {

        prefix_return retval = new prefix_return();

        retval.start = input.LT(1);

        CommonTree root_0 = null;

        term_return term8 = null;

        try {

            // Cql.g3:48:9: ( term )

            // Cql.g3:48:11: term

            {

            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_term_in_prefix158);

            term8=term();

            _fsp--;

            adaptor.addChild(root_0, term8.getTree());

            }

            retval.stop = input.LT(-1);

                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException re) {

            reportError(re);

            recover(input,re);

        }

        finally {

        }

        return retval;

    }

    // $ANTLR end prefix

    public static class uri_return extends ParserRuleReturnScope {

        CommonTree tree;

        public Object getTree() { return tree; }

    };

    // $ANTLR start uri

    // Cql.g3:49:1: uri : term ;

    public final uri_return uri() throws RecognitionException {

        uri_return retval = new uri_return();

        retval.start = input.LT(1);

        CommonTree root_0 = null;

        term_return term9 = null;

        try {

            // Cql.g3:49:7: ( term )

            // Cql.g3:49:9: term

            {

            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_term_in_uri168);

            term9=term();

            _fsp--;

            adaptor.addChild(root_0, term9.getTree());

            }

            retval.stop = input.LT(-1);

                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException re) {

            reportError(re);

            recover(input,re);

        }

        finally {

        }

        return retval;

    }

    // $ANTLR end uri

    public static class scopedClause_return extends ParserRuleReturnScope {

        public CqlClause clause;

        CommonTree tree;

        public Object getTree() { return tree; }

    };

    // $ANTLR start scopedClause

    // Cql.g3:50:1: scopedClause returns [CqlClause clause] : left= searchClause (op= booleanGroup right= searchClause )* ;

    public final scopedClause_return scopedClause() throws RecognitionException {

        scopedClause_return retval = new scopedClause_return();

        retval.start = input.LT(1);

        CommonTree root_0 = null;

        searchClause_return left = null;

        booleanGroup_return op = null;

        searchClause_return right = null;

        try {

            // Cql.g3:53:41: (left= searchClause (op= booleanGroup right= searchClause )* )

            // Cql.g3:54:3: left= searchClause (op= booleanGroup right= searchClause )*

            {

            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_searchClause_in_scopedClause188);

            left=searchClause();

            _fsp--;

            adaptor.addChild(root_0, left.getTree());

             retval.clause = left.clause; 

            // Cql.g3:55:3: (op= booleanGroup right= searchClause )*

            loop3:

            do {

                int alt3=2;

                int LA3_0 = input.LA(1);

                if ( ((LA3_0>=AND && LA3_0<=PROX)) ) {

                    alt3=1;

                }

                switch (alt3) {

            	case 1 :

            	    // Cql.g3:55:4: op= booleanGroup right= searchClause

            	    {

            	    pushFollow(FOLLOW_booleanGroup_in_scopedClause197);

            	    op=booleanGroup();

            	    _fsp--;

            	    root_0 = (CommonTree)adaptor.becomeRoot(op.getTree(), root_0);

            	    pushFollow(FOLLOW_searchClause_in_scopedClause202);

            	    right=searchClause();

            	    _fsp--;

            	    adaptor.addChild(root_0, right.getTree());

            	     retval.clause = new CqlBoolean(retval.clause, op.value, right.clause); 

            	    }

            	    break;

            	default :

            	    break loop3;

                }

            } while (true);

            }

            retval.stop = input.LT(-1);

                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException re) {

            reportError(re);

            recover(input,re);

        }

        finally {

        }

        return retval;

    }

    // $ANTLR end scopedClause

    public static class booleanGroup_return extends ParserRuleReturnScope {

        public String value;

        CommonTree tree;

        public Object getTree() { return tree; }

    };

    // $ANTLR start booleanGroup

    // Cql.g3:60:1: booleanGroup returns [String value] : b= bool ( modifierList )? ;

    public final booleanGroup_return booleanGroup() throws RecognitionException {

        booleanGroup_return retval = new booleanGroup_return();

        retval.start = input.LT(1);

        CommonTree root_0 = null;

        bool_return b = null;

        modifierList_return modifierList10 = null;

        try {

            // Cql.g3:60:37: (b= bool ( modifierList )? )

            // Cql.g3:61:2: b= bool ( modifierList )?

            {

            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_bool_in_booleanGroup230);

            b=bool();

            _fsp--;

            adaptor.addChild(root_0, b.getTree());

            // Cql.g3:61:9: ( modifierList )?

            int alt4=2;

            int LA4_0 = input.LA(1);

            if ( (LA4_0==18) ) {

                alt4=1;

            }

            switch (alt4) {

                case 1 :

                    // Cql.g3:61:10: modifierList

                    {

                    pushFollow(FOLLOW_modifierList_in_booleanGroup233);

                    modifierList10=modifierList();

                    _fsp--;

                    adaptor.addChild(root_0, modifierList10.getTree());

                    }

                    break;

            }

             retval.value = b.value; 

            }

            retval.stop = input.LT(-1);

                retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);

                adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }

        catch (RecognitionException re) {

            reportError(re);

            recover(input,re);

        }

        finally {

        }

        return retval;

    }

    // $ANTLR end booleanGroup

    public static class bool_return extends ParserRuleReturnScope {

        public String value;

        CommonTree tree;

        public Object getTree() { return tree; }

    };

    // $ANTLR start bool

    // Cql.g3:62:1: bool returns [String value] : ( AND | OR | NOT | PROX );

    public final bool_return bool() throws RecognitionException {

        bool_return retval = new bool_return();

        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token AND11=null;

        Token OR12=null;

        Token NOT13=null;

        Token PROX14=null;

        CommonTree AND11_tree=null;

        CommonTree OR12_tree=null;

        CommonTree NOT13_tree=null;

        CommonTree PROX14_tree=null;