All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.alachisoft.ncache.client.internal.caching.SearchServiceImpl Maven / Gradle / Ivy

    package com.alachisoft.ncache.client.internal.caching;

import Alachisoft.NCache.Caching.TagComparisonType;

import com.alachisoft.ncache.client.CacheReader;
import com.alachisoft.ncache.client.QueryCommand;
import com.alachisoft.ncache.client.TagSearchOptions;
import com.alachisoft.ncache.client.internal.util.ConversionUtil;
import com.alachisoft.ncache.client.services.SearchService;
import com.alachisoft.ncache.runtime.caching.Tag;
import com.alachisoft.ncache.runtime.exceptions.CacheException;

import java.io.IOException;
import java.util.*;

import static tangible.DotNetToJavaStringHelper.isNullOrEmpty;
import static tangible.DotNetToJavaStringHelper.isNull;

class SearchServiceImpl implements SearchService {

    protected CacheImpl cacheContainer;

    SearchServiceImpl(CacheImpl cache) {
        cacheContainer = cache;
    }

    CacheImpl getCacheContainer() {
        return cacheContainer;
    }

    void setCacheContainer(CacheImpl value) {
        cacheContainer = value;
    }

    //region Execute Reader Operations
    @Override
    public int executeNonQuery(QueryCommand queryCommand) throws CacheException {
        if (queryCommand == null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: queryCommand");
        }

        if (queryCommand.getQuery()==null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: query");
        }
        if (queryCommand.getQuery()=="") {
            throw new IllegalArgumentException("Value cannot be empty.\nParameter name: query");
        }

        return cacheContainer.executeNonQuery(queryCommand.getQuery(), queryCommand.getParameters());

    }

    @Override
    public CacheReader executeReader(QueryCommand queryCommand) throws CacheException {
        return executeReader(queryCommand, true, -1);
    }

    @Override
    public CacheReader executeReader(QueryCommand queryCommand, boolean getData, int chunkSize) throws CacheException {
        if (queryCommand == null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: queryCommand");
        }

        if (queryCommand.getQuery()==null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: query");
        }
        if (queryCommand.getQuery()=="") {
            throw new IllegalArgumentException("Value cannot be empty.\nParameter name: query");
        }

        return cacheContainer.executeReader(queryCommand.getQuery(), queryCommand.getParameters(), getData, chunkSize);
    }

    //endregion

    //region Tag Based Operations

    @Override
    public  T executeScalar(QueryCommand queryCommand, Class cls) throws CacheException {
        if (queryCommand == null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: queryCommand");
        }

        if (queryCommand.getQuery()==null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: query");
        }
        if (queryCommand.getQuery()=="") {
            throw new IllegalArgumentException("Value cannot be empty.\nParameter name: query");
        }

        Object scalarValue = null;
        CacheReader reader = null;

        try {
            reader = cacheContainer.executeReader(queryCommand.getQuery(), queryCommand.getParameters(), true, -1);

            if (reader != null) {
                if (reader.read()) {
                    if (reader.getFieldCount() > 1) {
                        scalarValue = reader.getValue(1, cls);
                    } else {
                        scalarValue = reader.getValue(0, cls);
                    }
                }
            }
        } catch (IOException | ClassNotFoundException e) {
            throw new CacheException(e);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (Exception e) {
                    throw new CacheException(e);
                }
            }
        }
        return (T) scalarValue;

    }

    @Override
    public void removeByTag(Tag tag) throws CacheException {
        if (tag == null || tag.getTagName() == null) {
            throw new IllegalArgumentException("Tag cannot be null.");
        }
        cacheContainer.removeByTag(new Tag[]{tag}, TagComparisonType.BY_TAG);
    }

    @Override
    public void removeByTags(List tags, TagSearchOptions searchOptions) throws CacheException {
        if (tags == null) {
            throw new IllegalArgumentException("Tags cannot be null.");
        }
        if (searchOptions == null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: searchOptions");
        }
        Tag[] tagsList = ConversionUtil.toArray(tags);

        if (tagsList.length == 0) {
            throw new IllegalArgumentException("At least one Tag required.");
        }
        tagsList = removeDuplicateTags(tagsList);
        cacheContainer.removeByTag(tagsList, getTagComparisonType(searchOptions));
    }

    @Override
    public  Map getByTag(Tag tag) throws CacheException {
        if (tag == null || tag.getTagName() == null) {
            throw new IllegalArgumentException("Tag cannot be null.");
        }
        return cacheContainer.getByTagInternal(new Tag[]{tag}, TagComparisonType.BY_TAG);


    }

    @Override
    public  Map getByTag(String wildCardExpression) throws CacheException {
        if (wildCardExpression==null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: wildCardExpression");
        }
        if (wildCardExpression=="") {
            throw new IllegalArgumentException("Value cannot be empty."+System.lineSeparator()+"Parameter name: wildCardExpression");
        }
        return cacheContainer.getByTagInternal(new Tag[]{new Tag(wildCardExpression)}, TagComparisonType.BY_WILDCARDTAG);
    }

    @Override
    public  Map getByTags(List tags, TagSearchOptions searchOptions) throws CacheException {
        if (tags == null) {
            throw new IllegalArgumentException("Tags cannot be null.");
        }
        if (searchOptions == null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: searchOptions");
        }

        Tag[] tagsList = ConversionUtil.toArray(tags);

        if (tagsList.length == 0) {
            throw new IllegalArgumentException("At least one Tag required.");
        }
        tagsList = removeDuplicateTags(tagsList);
        return cacheContainer.getByTagInternal(tagsList, getTagComparisonType(searchOptions));
    }

    @Override
    public Collection getKeysByTag(Tag tag) throws CacheException {
        if (tag == null || tag.getTagName() == null) {
            throw new IllegalArgumentException("Tag cannot be null.");
        }
        return cacheContainer.getKeysByTag(new Tag[]{tag}, TagComparisonType.BY_TAG);
    }

    @Override
    public Collection getKeysByTag(String wildCardExpression) throws CacheException {
        if (wildCardExpression==null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: wildCardExpression");
        }
        if (wildCardExpression=="") {
            throw new IllegalArgumentException("Value cannot be empty."+System.lineSeparator()+"Parameter name: wildCardExpression");
        }

        return cacheContainer.getKeysByTag(new Tag[]{new Tag(wildCardExpression)}, TagComparisonType.BY_WILDCARDTAG);
    }

    //endregion

    //region Group Based Operations

    @Override
    public Collection getKeysByTags(List tags, TagSearchOptions searchOptions) throws CacheException {
        if (tags == null) {
            throw new IllegalArgumentException("Tag cannot be null."+System.lineSeparator()+"Parameter name: tags");
        }
        if (searchOptions == null) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: searchOptions");
        }
        Tag[] tagsArray = ConversionUtil.toArray(tags );

        if (tagsArray.length == 0) {
            throw new IllegalArgumentException("At least one Tag required.");
        }
        tagsArray = removeDuplicateTags(tagsArray);
        return cacheContainer.getKeysByTag(tagsArray, getTagComparisonType(searchOptions));
    }

    @Override
    public void removeGroupData(String group) throws CacheException {
        if (isNull(group)) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: group");
        }
        cacheContainer.removeGroupData(group);
    }

    @Override
    public Collection getGroupKeys(String group) throws CacheException {
        if (isNull(group)) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: group");
        }
        ArrayList groupKeys = cacheContainer.getGroupKeys(group);
        return getGenericCollection(groupKeys);
    }

    //endregion

    //region Internal Methods

    @Override
    public  Map getGroupData(String group) throws CacheException {
        if (isNull(group)) {
            throw new IllegalArgumentException("Value cannot be null."+System.lineSeparator()+"Parameter name: group");
        }
        return cacheContainer.getGroupData(group);
    }

    Tag[] removeDuplicateTags(Tag[] tags) {
        HashMap keysAndItems = new HashMap(tags.length);
        for (int item = 0; item < tags.length; item++) {
            if (tags[item] != null && tags[item].getTagName() != null) {
                keysAndItems.put(tags[item], null);
            } else {
                throw new IllegalArgumentException("Tag cannot be null.");
            }
        }
        Object[] objects = keysAndItems.keySet().toArray();
        Tag[] finalTags = new Tag[objects.length];
        for(int i=0;i getGenericCollection(Collection col) {
        Collection keyList = new ArrayList();
        for (Object item : col) {
            keyList.add((String) item);
        }
        return keyList;
    }

    //endregion
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy