• Home
• com.scudata.esproc
• esproc
• 20240731
• source code
• Sequence.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.scudata.dm.Sequence Maven / Gradle / Ivy

package com.scudata.dm;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
//import java.text.Collator;

import com.ibm.icu.text.Collator;
import com.scudata.array.BoolArray;
import com.scudata.array.IArray;
import com.scudata.array.IntArray;
import com.scudata.array.NumberArray;
import com.scudata.array.ObjectArray;
import com.scudata.cellset.ICellSet;
import com.scudata.common.ByteArrayInputRecord;
import com.scudata.common.ByteArrayOutputRecord;
import com.scudata.common.Escape;
import com.scudata.common.IRecord;
import com.scudata.common.IntArrayList;
import com.scudata.common.MessageManager;
import com.scudata.common.ObjectCache;
import com.scudata.common.RQException;
import com.scudata.common.Sentence;
import com.scudata.dm.comparator.*;
import com.scudata.dm.cursor.ICursor;
import com.scudata.dm.cursor.MemoryCursor;
import com.scudata.dm.cursor.MultipathCursors;
import com.scudata.dm.op.IGroupsResult;
import com.scudata.dm.op.Join;
import com.scudata.dm.op.Operation;
import com.scudata.dm.op.PrimaryJoin;
import com.scudata.dm.op.Switch;
import com.scudata.dm.op.SwitchRemote;
import com.scudata.dw.IFilter;
import com.scudata.expression.CurrentElement;
import com.scudata.expression.Expression;
import com.scudata.expression.FieldId;
import com.scudata.expression.FieldRef;
import com.scudata.expression.Function;
import com.scudata.expression.Gather;
import com.scudata.expression.Node;
import com.scudata.expression.UnknownSymbol;
import com.scudata.expression.ValueList;
import com.scudata.expression.fn.gather.ICount.ICountBitSet;
import com.scudata.expression.fn.gather.ICount.ICountPositionSet;
import com.scudata.expression.operator.And;
import com.scudata.expression.operator.DotOperator;
import com.scudata.expression.operator.Equals;
import com.scudata.expression.operator.Greater;
import com.scudata.expression.operator.NotEquals;
import com.scudata.expression.operator.NotGreater;
import com.scudata.expression.operator.NotSmaller;
import com.scudata.expression.operator.Or;
import com.scudata.expression.operator.Smaller;
import com.scudata.parallel.ClusterMemoryTable;
import com.scudata.resources.EngineMessage;
import com.scudata.thread.MultithreadUtil;
import com.scudata.util.CursorUtil;
import com.scudata.util.HashUtil;
import com.scudata.util.MaxHeap;
import com.scudata.util.MinHeap;
import com.scudata.util.Variant;

/**
 * ?????࣬Ԫ????Ŵ?1??ʼ????
 * @author WangXiaoJun
 *
 */
public class Sequence implements Externalizable, IRecord, Comparable {
	private static final long serialVersionUID = 0x02010003;
	protected IArray mems; // ???г?Ա

	private static final char SEPARATOR = ','; // toStringʱ????Ԫ?طָ???
	private static final char STARTSYMBOL = '[';
	private static final char ENDSYMBOL = ']';
	private static final int SORT_HASH_LEN = 700; // ??????С?ڴ???ֵ??id??group??????????????????hash

	/**
	 * ????һ????????
	 */
	public Sequence() {
		mems = new ObjectArray(8);
	}

	/**
	 * ????һ????????
	 * @param createArray ?Ƿ????IArray
	 */
	protected Sequence(boolean createArray) {
		if (createArray) {
			mems = new ObjectArray(8);
		}
	}
	
	/**
	 * ????һ??ָ????????????
	 * @param initialCapacity int ????
	 */
	public Sequence(int initialCapacity) {
		mems = new ObjectArray(initialCapacity);
	}

	/**
	 * ????һ????ָ????Ա???ɵ?????
	 * @param v ??Ա????
	 */
	public Sequence(Object[] v) {
		if (v == null) {
			mems = new ObjectArray(10);
		} else {
			mems = new ObjectArray(v);
		}
	}

	/**
	 * ????һ?????У???????ӵ???Լ??ij?Ա
	 * @param seq Sequence
	 */
	public Sequence(Sequence seq) {
		if (seq == null) {
			mems = new ObjectArray(0);
		} else {
			mems = seq.getMems().dup();
		}
	}
	
	public Sequence(IArray array) {
		if (array == null) {
			mems = new ObjectArray(0);
		} else {
			mems = array;
		}
	}

	/**
	 * ????һ?????????䣬???start????end????һ???ݼ???????????
	 * @param start int ??ʼֵ
	 * @param end int ????ֵ
	 */
	public Sequence(int start, int end) {
		if (start < end) {
			ObjectArray mems = new ObjectArray(end - start + 1);
			this.mems = mems;
			for (; start <= end; ++start) {
				mems.add(ObjectCache.getInteger(start));
			}
		} else {
			ObjectArray mems = new ObjectArray(start - end + 1);
			this.mems = mems;
			for (; start >= end; --start) {
				mems.add(ObjectCache.getInteger(start));
			}
		}
	}

	/**
	 * ??ָ???????ֵ????????
	 * @param start ??ʼֵ??????
	 * @param end ????ֵ??????
	 */
	public Sequence(long start, long end) {
		if (start < end) {
			long len = end - start + 1;
			if (len > Integer.MAX_VALUE) {
				MessageManager mm = EngineMessage.get();
				throw new RQException("to" + mm.getMessage("function.invalidParam"));
			}

			ObjectArray mems = new ObjectArray((int)len);
			this.mems = mems;
			for (; start <= end; ++start) {
				mems.add(new Long(start));
			}
		} else {
			long len = start - end + 1;
			if (len > Integer.MAX_VALUE) {
				MessageManager mm = EngineMessage.get();
				throw new RQException("to" + mm.getMessage("function.invalidParam"));
			}

			ObjectArray mems = new ObjectArray((int)len);
			this.mems = mems;
			for (; start >= end; --start) {
				mems.add(new Long(start));
			}
		}
	}

	/**
	 * ȡ???еij?Ա?б??????ڱ????????Ż?
	 * @return
	 */
	public IArray getMems() {
		return mems;
	}
	
	/**
	 * ȡ???е?ǰ??Ա??ɵ????飬????~?ļ???
	 * @return
	 */
	public IArray getCurrentMems() {
		return mems;
	}

	/**
	 * ???????еij?Ա????
	 * @param mems ??Ա????
	 */
	public void setMems(IArray mems) {
		this.mems = mems;
		rebuildIndexTable();
	}

	/**
	 * ???????еĹ?ϣֵ
	 */
	public int hashCode() {
		IArray mems = getMems();
		int size = mems.size();
		if (size == 0) {
			return 0;
		}

		int hash = mems.hashCode(1);
		for (int i = 2; i <= size; ++i) {
			hash = 31 * hash + mems.hashCode(i);
		}

		return hash;
	}

	/**
	 * ʹ???е???????С??minCapacity
	 * @param minCapacity ??С????
	 */
	public void ensureCapacity(int minCapacity) {
		getMems().ensureCapacity(minCapacity);
	}

	/**
	 * ????Ԫ???״γ??ֵ?λ?ã???????????򷵻?0
	 * @param obj Object
	 * @return int
	 */
	public int firstIndexOf(Object obj) {
		return getMems().firstIndexOf(obj, 1);
	}

	/**
	 * ????Ԫ???????ֵ?λ?ã???????????򷵻?0
	 * @param obj Object
	 * @return int
	 */
	public int lastIndexof(Object obj) {
		return getMems().lastIndexOf(obj, length());
	}

	/**
	 * ???еij?Աֻ??????ͨ?????ݣ????ܰ?????¼
	 * @throws IOException
	 * @return byte[]
	 */
	public byte[] serialize() throws IOException {
		ByteArrayOutputRecord out = new ByteArrayOutputRecord();
		IArray mems = this.mems;
		if (mems instanceof ObjectArray) {
			out.writeRecord(mems);
		} else {
			out.writeByte(-1);
			out.writeObject(mems, true);
		}
		
		return out.toByteArray();
	}

	/**
	 * ???еij?Աֻ??????ͨ?????ݣ????ܰ?????¼
	 * @param buf byte[]
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
	public void fillRecord(byte[] buf) throws IOException, ClassNotFoundException {
		ByteArrayInputRecord in = new ByteArrayInputRecord(buf);
		if (buf[0] != -1) {
			mems = new ObjectArray();
			in.readRecord(mems);
		} else {
			in.readByte();
			in.readObject(true);
		}
	}

	public void writeExternal(ObjectOutput out) throws IOException {
		out.writeByte(1); // ?汾??
		out.writeObject(getMems());
	}

	public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
		in.readByte(); // ?汾??
		Object obj = in.readObject();
		if (obj instanceof IArray) {
			mems = (IArray)obj;
		} else {
			ListBase1 list = (ListBase1)obj;
			mems = new ObjectArray(list.getDatas(), list.size());
		}
	}

	/**
	 * ɾ?????еij?Ա?????ҵ???????
	 */
	public void reset() {
		getMems().clear();
	}

	/**
	 * ɾ?????еij?Ա
	 */
	public void clear() {
		getMems().clear();
	}

	/**
	 * ???????е???????ʹ????Ԫ???????
	 */
	public void trimToSize() {
		getMems().trimToSize();
	}

	/**
	 * ת??
	 * @param c int ????
	 * @return Sequence
	 */
	public Sequence transpose(int c) {
		IArray mems = getMems();
		int len = mems.size();

		int r = len / c;
		if (len % c != 0) {
			r++;
		}

		Sequence result = new Sequence(len);
		IArray resultMems = result.getMems();

		for (int i = 1; i <= c; ++i) {
			for (int j = 0; j < r; ++j) {
				int index = j * c + i;
				if (index <= len) {
					resultMems.add(mems.get(index));
				} else {
					resultMems.add(null);
				}
			}
		}

		return result;
	}

	/**
	 * ????????Ԫ?ظ???
	 * @return int
	 */
	public int length() {
		return getMems().size();
	}

	/**
	 * ȡ???зǿ?Ԫ?ظ???
	 * @param opt String
	 * @return int
	 */
	public int count() {
		return getMems().count();
	}

	/**
	 * ÿ??interval????ȡseqsָ????Ԫ??
	 * @param interval int ???
	 * @param seqs int[] Ԫ??????
	 * @return Sequence
	 */
	public Sequence step(int interval, int[] seqs) {
		if (interval < 1) {
			MessageManager mm = EngineMessage.get();
			throw new RQException(interval + mm.getMessage("engine.indexOutofBound"));
		}
		
		int count = seqs.length;
		for (int i = 0; i < count; ++i) {
			// ???ټ???Ƿ??interval???ˣ?????????????ǰ???
			if (seqs[i] < 1) { // || seqs[i] > interval
				MessageManager mm = EngineMessage.get();
				throw new RQException(seqs[i] + mm.getMessage("engine.indexOutofBound"));
			}
		}

		IArray mems = getMems();
		int srcLen = mems.size();
		Sequence result = new Sequence((srcLen / interval + 1) * count);
		IArray resultMems = result.getMems();

		for (int base = 0; ; base += interval) {
			boolean addOne = false;
			for (int i = 0; i < count; ++i) {
				int seq = base + seqs[i];
				if (seq <= srcLen) {
					resultMems.add(mems.get(seq));
					addOne = true;
				}
			}

			if (!addOne) break;
		}

		return result;
	}

	/**
	 * ȡ????ʹ????ʽΪ???Ԫ?ظ???
	 * @param exp ????ʽ
	 * @param ctx ??????????
	 * @return
	 */
	public int count(Expression exp, Context ctx) {
		if (exp == null) {
			return count();
		}

		int size = length();
		int count = size;

		ComputeStack stack = ctx.getComputeStack();
		Current current = new Current(this);
		stack.push(current);

		try {
			for (int i = 1; i <= size; ++i) {
				current.setCurrent(i);
				Object obj = exp.calculate(ctx);
				if (Variant.isFalse(obj)) {
					count--;
				}
			}
		} finally {
			stack.pop();
		}

		return count;
	}

	/**
	 * ???????е?Ԫ??
	 * @return Ԫ??ֵ??ɵ?????
	 */
	public Object[] toArray() {
		return getMems().toArray();
	}

	/**
	 * ??Ԫ?????θ???a????????a
	 * @param a Object[]
	 * @return Object[]
	 */
	public Object[] toArray(Object a[]) {
		getMems().toArray(a);
		return a;
	}

	/**
	 * ȡ??ijһԪ??
	 * @param seq int ??1??ʼ????
	 * @return Object
	 */
	public Object get(int seq) {
		if (seq < 1 || seq > length()) {
			MessageManager mm = EngineMessage.get();
			throw new RQException(seq + mm.getMessage("engine.indexOutofBound"));
		}
		
		return mems.get(seq);
	}
	
	/**
	 * ȡ??ijһԪ?أ??????????źϷ???
	 * @param seq int ??1??ʼ????
	 * @return Object
	 */
	public Object getMem(int seq) {
		return mems.get(seq);
	}

	/**
	 * ȡ????ѭ???ĵ?ǰԪ??
	 * @param seq int ??1??ʼ????
	 * @return Object
	 */
	public Object getCurrent(int seq) {
		return mems.get(seq);
	}
	
	/**
	 * ȡijһ????
	 * @param start int ??ʼλ?ã???????
	 * @param end int ????λ?ã?????????
	 * @return Sequence ???????
	 */
	public Sequence get(int start, int end) {
		return new Sequence(getMems().get(start, end));
	}
	
	/**
	 * ???ض??Ԫ??
	 * @param seq Sequence Ԫ??λ?ù??ɵ????У?Ԫ??ֵ?????????еij???
	 * @return Sequence
	 */
	public Sequence get(Sequence seq) {
		if (seq == null || seq.length() == 0) {
			return new Sequence(0);
		}

		int []posArray = seq.toIntArray();
		IArray result = getMems().get(posArray);
		return new Sequence(result);
	}

	/**
	 * ?Ƿ????ijһԪ??
	 * @param obj Object Ԫ??ֵ
	 * @param isSorted boolean?????????򣬽????ö??ֲ???
	 * @return boolean
	 */
	public boolean contains(Object obj, boolean isSorted) {
		if (isSorted) {
			return getMems().binarySearch(obj) > 0;
		} else {
			return getMems().contains(obj);
		}
	}
	/**
	 * ?ж??????Ԫ???Ƿ??ڵ?ǰ??????
	 * @param isSorted ??ǰ?????Ƿ?????
	 * @param array ????
	 * @param result ???ڴ?Ž????ֻ??ȡֵΪtrue??
	 */
	public void contains(boolean isSorted, IArray array, BoolArray result) {
		getMems().contains(isSorted, array, result);
	}

	// ?????Ƿ???????????s
	private boolean isIntInterval() {
		IArray mems = getMems();
		int size = mems.size();
		if (size == 0) {
			return false;
		}

		Object obj1 = mems.get(1);
		if (!(obj1 instanceof Number)) {
			return false;
		}
		if (size == 1) {
			return true;
		}

		Object obj2 = mems.get(2);
		if (!(obj2 instanceof Number)) {
			return false;
		}

		int prev = ((Number)obj2).intValue();
		int dif = prev - ((Number)obj1).intValue();

		if (dif == 1) { // ????
			for (int i = 3; i <= size; ++i) {
				Object obj = mems.get(i);
				if (!(obj instanceof Number)) {
					return false;
				}

				prev++;
				if (((Number)obj).intValue() != prev) {
					return false;
				}
			}
		} else if (dif == -1) { // ?ݼ?
			for (int i = 3; i <= size; ++i) {
				Object obj = mems.get(i);
				if (!(obj instanceof Number)) {
					return false;
				}

				prev--;
				if (((Number)obj).intValue() != prev) {
					return false;
				}
			}
		} else if (dif == 0) { // ??????ֻ??һ????
			if (size != 2) {
				return false;
			}
		} else {
			return false;
		}

		return true;
	}

	// ?????????Ƿ???n?û?
	private boolean isPermutation(int n) {
		IArray mems = getMems();
		int len = mems.size();
		if (len != n) return false;

		boolean[] sign = new boolean[n + 1];
		for (int i = 1; i <= len; ++i) {
			Object obj = mems.get(i);
			if (!(obj instanceof Number)) {
				return false;
			}

			// ????????[1??n]??Χ?ڣ???????ظ???Ԫ??
			int tmp = ( (Number) obj).intValue();
			if (tmp < 1 || tmp > n || sign[tmp]) {
				return false;
			}

			sign[tmp] = true;
		}

		return true;
	}

	/**
	 * ?????????Ƿ??м?¼
	 * @return boolean
	 */
	public boolean hasRecord() {
		return getMems().hasRecord();
	}

	/**
	 * ???ص?ǰ?????Ƿ???????
	 * @return boolean true???????У?false????????
	 */
	public boolean isPmt() {
		return getMems().isPmt(false);
	}

	/**
	 * ???ص?ǰ?????Ƿ??Ǵ?????
	 * @return boolean true???Ǵ????У??ṹ??ͬ??
	 */
	public boolean isPurePmt() {
		return getMems().isPmt(true);
	}

	/**
	 * ????λ???е??????У????س???Ϊn??λ????
	 * @param n int
	 * @return Sequence
	 */
	public Sequence inv(int n) {
		if (n < 0) {
			MessageManager mm = EngineMessage.get();
			throw new RQException("inv" + mm.getMessage("function.invalidParam"));
		}

		IArray mems = getMems();
		Integer[] seqs = new Integer[n];
		for (int i = 1, len = mems.size(); i <= len; ++i) {
			Object obj = mems.get(i);
			if (!(obj instanceof Number)) {
				MessageManager mm = EngineMessage.get();
				throw new RQException(mm.getMessage("engine.needIntSeries"));
			}

			int pos = ((Number)obj).intValue();
			if (pos > 0 && pos <= n) {
				if (seqs[pos - 1] == null) {
					seqs[pos - 1] = ObjectCache.getInteger(i);
				}
			}
		}

		Integer int0 = ObjectCache.getInteger(0);
		for (int i = 0; i < n; ++i) {
			if (seqs[i] == null)seqs[i] = int0;
		}

		return new Sequence(seqs);
	}

	/**
	 * ????λ?????з?תԴ????
	 * @param seq Sequence λ??????
	 * @param opt String o???ı?Դ????
	 * @return Sequence
	 */
	public Sequence inv(Sequence seq, String opt) {
		IArray mems = getMems();
		IArray posMems = seq.getMems();
		int n = mems.size();
		int len = posMems.size();

		boolean isNew = opt == null || opt.indexOf('o') == -1;
		if (!isNew && this instanceof Table) {
			if (!seq.isPermutation(n)) {
				MessageManager mm = EngineMessage.get();
				throw new RQException("inv" + mm.getMessage("function.invalidParam"));
			}
		}

		Object[] objs = new Object[n];
		for (int i = 1; i <= len; ++i) {
			Object obj = posMems.get(i);
			if (!(obj instanceof Number)) {
				MessageManager mm = EngineMessage.get();
				throw new RQException(mm.getMessage("engine.needIntSeries"));
			}

			int pos = ((Number)obj).intValue();
			if (pos > 0 && pos <= n) {
				objs[pos - 1] = mems.get(i);
			}
		}

		if (isNew) {
			return new Sequence(objs);
		} else {
			mems.clear();
			mems.addAll(objs);
			return this;
		}
	}
	
	/**
	 * ?ж?seq?Ƿ??ǵ?ǰ???е??û???
	 * @param seq Sequence
	 * @return boolean
	 */
	public boolean isPeq(Sequence seq) {
		if (seq == null) {
			return false;
		}

		IArray mems = getMems();
		IArray mems2 = seq.getMems();
		int size = mems.size();
		int size2 = mems2.size();
		if (size != size2) {
			return false;
		}

		boolean[] founds = new boolean[size + 1];
		nextCand:
		for (int t = 1; t <= size2; ++t) {
			Object obj = mems2.get(t);
			for (int s = 1; s <= size; ++s) {
				if (!founds[s] && Variant.isEquals(mems.get(s), obj)) {
					// ?ҵ??????????ѭ????????
					founds[s] = true;
					continue nextCand;
				}
			}
			
			// û???ҵ?????false
			return false;
		}
		
		return true;
	}

	/**
	 * ???????еķ?ת????
	 * @return Sequence
	 */
	public Sequence rvs() {
		return new Sequence(getMems().rvs());
	}

	/**
	 * ????ʹ?????еIJ?????Ϊ?????е?n?û?
	 * @param opt String z??????
	 * @return Sequence
	 */
	public Sequence psort(String opt) {
		IArray mems = getMems();
		int size = mems.size();
		if (size == 0) {
			return new Sequence(0);
		}
		
		boolean isDesc = false, isNullLast = false;
		if (opt != null) {
			if (opt.indexOf('z') != -1) isDesc = true;
			if (opt.indexOf('0') != -1) isNullLast = true;
		}

		int len = size + 1;
		PSortItem[] infos = new PSortItem[len];
		for (int i = 1; i < len; ++i) {
			infos[i] = new PSortItem(i, mems.get(i));
		}

		Comparator