/**
* This is the standard liveness calculation (Dragon Book, section 10.6). At each BB (and its
* corresponding usage), we evaluate "in" using use and def. in = use U (out \ def) where out = U
* succ.in, for all successors
*
* <p>this algorithm has been modified to treat catch blocks as occurring anywhere ie, that vars
* defined in a try may never be set however, this only applies to vars that have been defined at
* least once (ie, born)
*/
public boolean evalLiveIn(ArrayList<Usage> succUsage, ArrayList<Handler> handUsage) {
BitSet out = new BitSet(nLocals);
BitSet old_in = (BitSet) in.clone();
if (handUsage == null) handUsage = new ArrayList();
if (succUsage.size() == 0) {
in = use;
} else {
// calculate out = U succ.in
out = (BitSet) succUsage.get(0).in.clone();
for (int i = 1; i < succUsage.size(); i++) {
out.or(succUsage.get(i).in);
}
// calc out \ def == out & ~def == ~(out | def)
// unless a var has been def'd in all catch blocks, assume it may fail to def
BitSet def1 = (BitSet) def.clone();
for (Handler handle : handUsage) def1.and(handle.catchBB.usage.def);
def1.flip(0, nLocals);
out.and(def1);
for (Handler handler : handUsage) out.or(handler.catchBB.usage.use);
// catch block vars may be def'd in this block, but we can't easily know if the
// def has occurred before the throw
// if the var has never been def'd (or was a parameter), then it can't be live
out.and(born);
out.or(use);
in = out;
}
return !(in.equals(old_in));
}
protected int freeBit(HierNode<T> x, HierNode<T> z) {
// System.out.println( "Looking for a free bit in node " + x );
BitSet forbid = new BitSet(this.size());
forbid.or(x.getBitMask());
for (HierNode<T> y : getNodes()) {
if (superset(y, x) > 0) {
// System.out.println( "\t\t Subtype " + y + " contributes " + toBinaryString(
// y.getBitMask() ) );
forbid.or(y.getBitMask());
}
if (z != null) {
if (superset(y, z) > 0) {
// System.out.println( "\t\t Subtype " + y + " contributes " +
// toBinaryString( y.getBitMask() ) );
forbid.or(y.getBitMask());
}
}
if (superset(x, y) < 0) {
BitSet diff = singleBitDiff(x.getBitMask(), y.getBitMask());
// System.out.println( "\t\t Incomparable " + y + " contributes " + toBinaryString( diff )
// );
forbid.or(diff);
}
}
// System.out.println( "\t Forbidden mask " + toBinaryString( forbid ) );
return firstZero(forbid);
}
/**
* Prob0 precomputation algorithm. i.e. determine the states of an STPG which, with min/max
* probability 0, reach a state in {@code target}, while remaining in those in @{code remain}.
* {@code min}=true gives Prob0E, {@code min}=false gives Prob0A.
*
* @param stpg The STPG
* @param remain Remain in these states (optional: null means "all")
* @param target Target states
* @param min1 Min or max probabilities for player 1 (true=lower bound, false=upper bound)
* @param min2 Min or max probabilities for player 2 (true=min, false=max)
*/
public BitSet prob0(STPG stpg, BitSet remain, BitSet target, boolean min1, boolean min2) {
int n, iters;
BitSet u, soln, unknown;
boolean u_done;
long timer;
// Start precomputation
timer = System.currentTimeMillis();
if (verbosity >= 1)
mainLog.println(
"Starting Prob0 (" + (min1 ? "min" : "max") + (min2 ? "min" : "max") + ")...");
// Special case: no target states
if (target.cardinality() == 0) {
soln = new BitSet(stpg.getNumStates());
soln.set(0, stpg.getNumStates());
return soln;
}
// Initialise vectors
n = stpg.getNumStates();
u = new BitSet(n);
soln = new BitSet(n);
// Determine set of states actually need to perform computation for
unknown = new BitSet();
unknown.set(0, n);
unknown.andNot(target);
if (remain != null) unknown.and(remain);
// Fixed point loop
iters = 0;
u_done = false;
// Least fixed point - should start from 0 but we optimise by
// starting from 'target', thus bypassing first iteration
u.or(target);
soln.or(target);
while (!u_done) {
iters++;
// Single step of Prob0
stpg.prob0step(unknown, u, min1, min2, soln);
// Check termination
u_done = soln.equals(u);
// u = soln
u.clear();
u.or(soln);
}
// Negate
u.flip(0, n);
// Finished precomputation
timer = System.currentTimeMillis() - timer;
if (verbosity >= 1) {
mainLog.print("Prob0 (" + (min1 ? "min" : "max") + (min2 ? "min" : "max") + ")");
mainLog.println(" took " + iters + " iterations and " + timer / 1000.0 + " seconds.");
}
return u;
}
void computeIn(LinkedList<Vertex> worklist) {
int i;
BitSet old;
BitSet ne;
Vertex v;
ListIterator<Vertex> iter;
iter = succ.listIterator();
while (iter.hasNext()) {
v = iter.next();
out.or(v.in);
}
old = in;
in = new BitSet();
in.or(out);
in.andNot(def);
in.or(use);
if (!in.equals(old)) {
iter = pred.listIterator();
while (iter.hasNext()) {
v = iter.next();
if (!v.listed) {
worklist.addLast(v);
v.listed = true;
}
}
}
}
private BlockDataFlowState generateDFState(CFGBlock block) {
int totalGlobals = this.uniqueGlobals.get(block.getMethodName()).size();
// Get the original inBitSet for this block
BitSet origIn;
if (this.cfgBlocksState.containsKey(block)) {
origIn = this.cfgBlocksState.get(block).getIn();
} else {
origIn = new BitSet(totalGlobals);
origIn.set(0, totalGlobals);
}
// Calculate the in BitSet by taking intersection of predecessors
BlockDataFlowState bFlow = new BlockDataFlowState(totalGlobals);
// If there exist at least one successor, set Out to all True
if (block.getSuccessors().size() > 0) {
bFlow.getOut().set(0, totalGlobals);
}
BitSet out = bFlow.getOut();
for (CFGBlock pred : block.getSuccessors()) {
if (this.cfgBlocksState.containsKey(pred)) {
out.and(this.cfgBlocksState.get(pred).getIn());
}
}
calculateGenKillSets(block, bFlow);
// Calculate Out
BitSet in = bFlow.getIn(); // IN = (OUT - KILL) U GEN
in.or(out);
in.xor(bFlow.getKill());
in.or(bFlow.getGen());
if (!in.equals(origIn)) {
// Add successors to cfgBlocks list
for (CFGBlock pred : block.getPredecessors()) {
if (!cfgBlocksToProcess.contains(pred)) {
cfgBlocksToProcess.add(pred);
}
}
}
// Remove this block, since it has been processed
cfgBlocksToProcess.remove(block);
return bFlow;
}
/** Performs a deep copy on <i>other</i>. */
public TArticle(TArticle other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
if (other.isSetTitle()) {
this.title = other.title;
}
if (other.isSetContent()) {
this.content = other.content;
}
if (other.isSetSummary()) {
this.summary = other.summary;
}
this.publishTime = other.publishTime;
if (other.isSetOriginalUrl()) {
this.originalUrl = other.originalUrl;
}
if (other.isSetArticleFrom()) {
this.articleFrom = other.articleFrom;
}
this.articleType = other.articleType;
this.topDay = other.topDay;
if (other.isSetImageItems()) {
List<TImageItem> __this__imageItems = new ArrayList<TImageItem>();
for (TImageItem other_element : other.imageItems) {
__this__imageItems.add(new TImageItem(other_element));
}
this.imageItems = __this__imageItems;
}
if (other.isSetArticleUuid()) {
this.articleUuid = other.articleUuid;
}
}
public static void main(String[] args) {
BitSet bits1 = new BitSet(16);
BitSet bits2 = new BitSet(16);
for (int i = 0; i < 16; i++) {
if ((i % 2) == 0) bits1.set(i);
if ((i % 5) != 0) bits2.set(i);
}
System.out.println("Initial pattern in bits1: ");
System.out.println(bits1);
System.out.println("\nInitial pattern in bits2: ");
System.out.println(bits2);
// AND bits
bits2.and(bits1);
System.out.println("\nbits2 AND bits1: ");
System.out.println(bits2);
// OR bits
bits2.or(bits1);
System.out.println("\nbits2 OR bits1: ");
System.out.println(bits2);
// XOR bits
bits2.xor(bits1);
System.out.println("\nbits2 XOR bits1: ");
System.out.println(bits2);
}
/** Performs a deep copy on <i>other</i>. */
public OrderPlacedByClient(OrderPlacedByClient other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
if (other.isSetChosenItems()) {
List<ChosenMenuItem> __this__chosenItems = new ArrayList<ChosenMenuItem>();
for (ChosenMenuItem other_element : other.chosenItems) {
__this__chosenItems.add(new ChosenMenuItem(other_element));
}
this.chosenItems = __this__chosenItems;
}
this.expectedPrice = other.expectedPrice;
this.userId = other.userId;
if (other.isSetHowWillPay()) {
this.howWillPay = other.howWillPay;
}
this.pickUp = other.pickUp;
if (other.isSetAddress()) {
this.address = other.address;
}
if (other.isSetPhoneNumber()) {
this.phoneNumber = other.phoneNumber;
}
this.timestamp = other.timestamp;
this.tableId = other.tableId;
if (other.isSetPhoneId()) {
this.phoneId = other.phoneId;
}
this.orderId = other.orderId;
if (other.isSetUsername()) {
this.username = other.username;
}
}
/** The longest dep set of the sub-sequence s[0..idx]. */
public static BitSet longestDepSet(Sequence s, int idx) {
if (s.size() == 0) throw new IllegalArgumentException("size must be greater than 0.");
if (idx < 0 || idx >= s.size()) throw new IllegalArgumentException();
assert s.size() <= maxlength;
int max = -1;
int maxidx = -1;
for (int i = 0; i <= idx; i++) {
BitSet set = sets[i];
set.clear();
set.set(i);
lastuse[i] = i;
for (Variable invar : s.getInputs(i)) {
set.or(sets[lastuse[invar.index]]);
lastuse[invar.index] = i;
}
int size = set.cardinality();
if (size > max) {
max = size;
maxidx = i;
}
}
for (int i = 0; i < s.size(); i++) {
// System.out.println("@ " + sets[i]);
}
return sets[maxidx];
}
/** Performs a deep copy on <i>other</i>. */
public Appl(Appl other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
if (other.isSetId()) {
this.id = other.id;
}
if (other.isSetType()) {
this.type = other.type;
}
this.excuteAction = other.excuteAction;
if (other.isSetExcuteDescribe()) {
this.excuteDescribe = other.excuteDescribe;
}
if (other.isSetPkgName()) {
this.pkgName = other.pkgName;
}
if (other.isSetLevel()) {
this.level = other.level;
}
if (other.isSetCategory()) {
this.category = other.category;
}
if (other.isSetName()) {
this.name = other.name;
}
}
public boolean verify(String message, Signature signature, PublicKey publicKey) throws Exception {
if (!(publicKey instanceof PublicKeyLamport)) {
throw new Exception("Wrong Type of Signing Key");
}
final PublicKeyLamport publicKeyLamport = (PublicKeyLamport) publicKey;
if (!(signature instanceof SignatureLamport)) {
throw new Exception("Wrong Type of Signature");
}
final SignatureLamport signatureLamport = (SignatureLamport) signature;
final BitSet messageBits = new BitSet(this.k);
messageBits.or(BitSet.valueOf(message.getBytes()));
// verification algorithm
for (int i = 0; i < this.k; ++i) {
final Hash hashX = this.h.hash(signatureLamport.getSig(i).toByteArray());
final Hash hashY =
!messageBits.get(i) ? publicKeyLamport.getY1(i) : publicKeyLamport.getY2(i);
if (!hashX.equals(hashY)) {
return false;
}
}
return true;
}
/** Performs a deep copy on <i>other</i>. */
public ChosenMenuItem(ChosenMenuItem other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
this.menuItemId = other.menuItemId;
if (other.isSetSingleChoiceOptions()) {
List<org.pocketcampus.platform.sdk.shared.common.ChosenSingleChoiceOption>
__this__singleChoiceOptions =
new ArrayList<org.pocketcampus.platform.sdk.shared.common.ChosenSingleChoiceOption>();
for (org.pocketcampus.platform.sdk.shared.common.ChosenSingleChoiceOption other_element :
other.singleChoiceOptions) {
__this__singleChoiceOptions.add(
new org.pocketcampus.platform.sdk.shared.common.ChosenSingleChoiceOption(
other_element));
}
this.singleChoiceOptions = __this__singleChoiceOptions;
}
if (other.isSetMultiChoiceOptions()) {
List<org.pocketcampus.platform.sdk.shared.common.ChosenMultiChoiceOption>
__this__multiChoiceOptions =
new ArrayList<org.pocketcampus.platform.sdk.shared.common.ChosenMultiChoiceOption>();
for (org.pocketcampus.platform.sdk.shared.common.ChosenMultiChoiceOption other_element :
other.multiChoiceOptions) {
__this__multiChoiceOptions.add(
new org.pocketcampus.platform.sdk.shared.common.ChosenMultiChoiceOption(other_element));
}
this.multiChoiceOptions = __this__multiChoiceOptions;
}
if (other.isSetComments()) {
this.comments = other.comments;
}
}
protected void inheritMerged(HierNode<T> x) {
BitSet mask = new BitSet(x.getBitMask() != null ? x.getBitMask().length() : 1);
for (HierNode<T> p : x.getParents()) {
mask.or(p.getBitMask());
}
updateMask(x, mask);
}
@Override
public void fixSomeVariables(ICause cause) throws ContradictionException {
// this is called after restart
// if required, force the cut and explain the cut
if (forceCft) {
explainCut();
nbFixedVariables = related2cut.cardinality();
nbCall = 0;
increaseLimit();
}
// then fix variables
// this part is specific: a fake decision path has to be created
nbCall++;
restrictLess();
notFrozen.clear();
notFrozen.or(related2cut);
for (; !notFrozen.isEmpty() && notFrozen.cardinality() > nbFixedVariables; ) {
int idx = selectVariable();
notFrozen.clear(idx);
}
assert mSolver.getSearchLoop().getLastDecision() == RootDecision.ROOT;
// add the first refuted decisions
int first = notFrozen.nextSetBit(0);
for (int i = (first > -1 ? refuted.nextSetBit(first) : first);
i > -1;
i = refuted.nextSetBit(i + 1)) {
notFrozen.clear(i);
}
// add unrelated
notFrozen.or(unrelated);
// then build the fake decision path
last = null;
// LOGGER.debug("relax cut {}", notFrozen.cardinality());
for (int id = notFrozen.nextSetBit(0);
id >= 0 && id < path.size();
id = notFrozen.nextSetBit(id + 1)) {
// last = ExplanationToolbox.mimic(path.get(id)); // required because some
// unrelated decisions can be refuted
if (path.get(id).hasNext()) {
last = path.get(id).duplicate();
if (refuted.get(id)) last.buildNext();
ExplanationToolbox.imposeDecisionPath(mSolver, last);
}
}
}
/** Performs a deep copy on <i>other</i>. */
public SessionId(SessionId other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
this.tos = other.tos;
if (other.isSetCamiproCookie()) {
this.camiproCookie = other.camiproCookie;
}
}
/**
* evolve the born value a single iteration by mixing in either pred or combo
*
* @param pred if combo is null, use pred.born
* @param combo if non-null, the value to mix in
* @return true if the evolution resulted in a change in the born value
*/
boolean evalBornIn(Usage pred, BitSet combo) {
BitSet old = (BitSet) born.clone();
if (combo == null) combo = pred.born;
if (firstBorn) born.or(combo);
else born.and(combo);
firstBorn = false;
return !old.equals(born);
}
/** Performs a deep copy on <i>other</i>. */
public NamespaceListing(NamespaceListing other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
if (other.isSetName()) {
this.name = other.name;
}
this.is_namespace = other.is_namespace;
}
private void set(GameData data) {
iBlockRegistry.set(data.iBlockRegistry);
iItemRegistry.set(data.iItemRegistry);
availabilityMap.clear();
availabilityMap.or(data.availabilityMap);
blockedIds.clear();
blockedIds.addAll(data.blockedIds);
}
/** Performs a deep copy on <i>other</i>. */
public T_QueryOrderResponse(T_QueryOrderResponse other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
this.responseCode = other.responseCode;
this.transactionID = other.transactionID;
if (other.isSetDescription()) {
this.description = other.description;
}
}
private void changeServiceDependencies(final double addFactor, final double removeFactor) {
BitSet servicesInNeighbourhood[] = new BitSet[numNeighbourhoods];
for (int s = 0; s < servicesInNeighbourhood.length; ++s) {
servicesInNeighbourhood[s] = new BitSet();
}
IntAVLTreeSet serviceToNeighbourhoods[] = new IntAVLTreeSet[services.length];
for (int s = 0; s < services.length; ++s) serviceToNeighbourhoods[s] = new IntAVLTreeSet();
for (Process p : processes) {
int n = machines[assignment[p.id]].neighborhood;
int s = p.service;
servicesInNeighbourhood[n].set(s);
serviceToNeighbourhoods[s].add(n);
}
for (int sid = 0; sid < services.length; sid++) {
IntAVLTreeSet neighbourhoods = serviceToNeighbourhoods[sid];
BitSet intersection = null;
for (int n : neighbourhoods) {
if (intersection == null) {
intersection = new BitSet();
intersection.or(servicesInNeighbourhood[n]);
} else intersection.and(servicesInNeighbourhood[n]);
}
// intersection - all possible services I can depend on
for (int d : services[sid].dependencies) intersection.clear(d);
intersection.clear(sid); // exclude itself
// services we can add as new dependencies
int[] list = new int[intersection.cardinality()];
int i = 0;
for (int q = intersection.nextSetBit(0); q >= 0; q = intersection.nextSetBit(q + 1)) {
list[i++] = q;
}
MyArrayUtils.shuffle(list, random);
int addCount = nextInt(0, 1 + (int) (addFactor * services[sid].dependencies.length));
// addCount = 0;
int removeCount = nextInt(0, 1 + (int) (addFactor * services[sid].dependencies.length));
int[] newdependencies =
org.apache.commons.lang.ArrayUtils.addAll(
services[sid].dependencies,
Arrays.copyOfRange(list, 0, Math.min(list.length, addCount)));
MyArrayUtils.shuffle(newdependencies, random);
services[sid].dependencies =
Arrays.copyOfRange(newdependencies, 0, Math.max(0, newdependencies.length - removeCount));
}
}
/** Performs a deep copy on <i>other</i>. */
public HibariException(HibariException other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
this.timestamp = other.timestamp;
this.what = other.what;
if (other.isSetWhy()) {
this.why = other.why;
}
}
/**
* Given the current set of potential matching rules, obtain the rules which match the current
* field defined either by key or anykey. The rules are represented by bitsets which are
* intersected to return the remain potentially matching rules. If after bitset intersection, the
* resulting bitset is empty, an exception is thrown to halt the search.
*
* @param src - the current set of potentially matching rules.
* @param map - the data structure holding all the possible values defined by all flow space rules
* for given field.
* @param key - the key (or field value) used to index the data structure.
* @param anykey - the 'any' value for this field.
* @param wildcards - the set of wildcards defined by this match
* @param wild - the specific wildcard value for this field
* @return - true if field was wildcarded and false otherwise.
* @throws NoMatch - if the set of rules (ie. the src bitset) is empty after intersection.
*/
private <K> boolean testEmpty(
BitSet src, Map<K, BitSet> map, K key, K anykey, int wildcards, int wild) throws NoMatch {
if ((wildcards & wild) != 0) return true;
BitSet any = get(map, anykey);
any.or(get(map, key));
src.and(any);
if (src.isEmpty()) throw new NoMatch("No Match");
return false;
}
/** Performs a deep copy on <i>other</i>. */
public IntString(IntString other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
this.myint = other.myint;
if (other.isSetMyString()) {
this.myString = other.myString;
}
this.underscore_int = other.underscore_int;
}
/** Performs a deep copy on <i>other</i>. */
public KeyCount(KeyCount other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
if (other.isSetKey()) {
this.key = new byte[other.key.length];
System.arraycopy(other.key, 0, key, 0, other.key.length);
}
this.count = other.count;
}
/** Performs a deep copy on <i>other</i>. */
public AppInfoResult(AppInfoResult other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
this.deviceId = other.deviceId;
this.flowNum = other.flowNum;
this.result = other.result;
if (other.isSetAppdatainfo()) {
this.appdatainfo = new AppDataInfo(other.appdatainfo);
}
}
@Override
public void or(Filter filter) {
if (filter == null
|| !(filter instanceof BloomFilter)
|| filter.vectorSize != this.vectorSize
|| filter.nbHash != this.nbHash) {
throw new IllegalArgumentException("filters cannot be or-ed");
}
bits.or(((BloomFilter) filter).bits);
}
/** Performs a deep copy on <i>other</i>. */
public AchieveResult(AchieveResult other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
if (other.isSetScore()) {
this.score = other.score;
}
this.isShot = other.isShot;
if (other.isSetDetail()) {
this.detail = other.detail;
}
}
/** Performs a deep copy on <i>other</i>. */
public ThriftTaskAttemptID(ThriftTaskAttemptID other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
if (other.isSetTaskID()) {
this.taskID = new ThriftTaskID(other.taskID);
}
this.attemptID = other.attemptID;
if (other.isSetAsString()) {
this.asString = other.asString;
}
}
/** Performs a deep copy on <i>other</i>. */
public StorageDescriptor(StorageDescriptor other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
if (other.isSetCols()) {
List<FieldSchema> __this__cols = new ArrayList<FieldSchema>();
for (FieldSchema other_element : other.cols) {
__this__cols.add(new FieldSchema(other_element));
}
this.cols = __this__cols;
}
if (other.isSetLocation()) {
this.location = other.location;
}
if (other.isSetInputFormat()) {
this.inputFormat = other.inputFormat;
}
if (other.isSetOutputFormat()) {
this.outputFormat = other.outputFormat;
}
this.compressed = other.compressed;
this.numBuckets = other.numBuckets;
if (other.isSetSerdeInfo()) {
this.serdeInfo = new SerDeInfo(other.serdeInfo);
}
if (other.isSetBucketCols()) {
List<String> __this__bucketCols = new ArrayList<String>();
for (String other_element : other.bucketCols) {
__this__bucketCols.add(other_element);
}
this.bucketCols = __this__bucketCols;
}
if (other.isSetSortCols()) {
List<Order> __this__sortCols = new ArrayList<Order>();
for (Order other_element : other.sortCols) {
__this__sortCols.add(new Order(other_element));
}
this.sortCols = __this__sortCols;
}
if (other.isSetParameters()) {
Map<String, String> __this__parameters = new HashMap<String, String>();
for (Map.Entry<String, String> other_element : other.parameters.entrySet()) {
String other_element_key = other_element.getKey();
String other_element_value = other_element.getValue();
String __this__parameters_copy_key = other_element_key;
String __this__parameters_copy_value = other_element_value;
__this__parameters.put(__this__parameters_copy_key, __this__parameters_copy_value);
}
this.parameters = __this__parameters;
}
}
/** Performs a deep copy on <i>other</i>. */
public Table(Table other) {
__isset_bit_vector.clear();
__isset_bit_vector.or(other.__isset_bit_vector);
if (other.isSetTableName()) {
this.tableName = other.tableName;
}
if (other.isSetDbName()) {
this.dbName = other.dbName;
}
if (other.isSetOwner()) {
this.owner = other.owner;
}
this.createTime = other.createTime;
this.lastAccessTime = other.lastAccessTime;
this.retention = other.retention;
if (other.isSetSd()) {
this.sd = new StorageDescriptor(other.sd);
}
if (other.isSetPartitionKeys()) {
List<FieldSchema> __this__partitionKeys = new ArrayList<FieldSchema>();
for (FieldSchema other_element : other.partitionKeys) {
__this__partitionKeys.add(new FieldSchema(other_element));
}
this.partitionKeys = __this__partitionKeys;
}
if (other.isSetParameters()) {
Map<String, String> __this__parameters = new HashMap<String, String>();
for (Map.Entry<String, String> other_element : other.parameters.entrySet()) {
String other_element_key = other_element.getKey();
String other_element_value = other_element.getValue();
String __this__parameters_copy_key = other_element_key;
String __this__parameters_copy_value = other_element_value;
__this__parameters.put(__this__parameters_copy_key, __this__parameters_copy_value);
}
this.parameters = __this__parameters;
}
if (other.isSetViewOriginalText()) {
this.viewOriginalText = other.viewOriginalText;
}
if (other.isSetViewExpandedText()) {
this.viewExpandedText = other.viewExpandedText;
}
if (other.isSetTableType()) {
this.tableType = other.tableType;
}
if (other.isSetPrivileges()) {
this.privileges = new PrincipalPrivilegeSet(other.privileges);
}
}