public DomainGroupMetadata deepCopy() { return new DomainGroupMetadata(this); }
@Override public boolean equals(Object that) { if (that == null) return false; if (that instanceof DomainGroupMetadata) return this.equals((DomainGroupMetadata)that); return false; }
public Object getFieldValue(_Fields field) { switch (field) { case DOMAIN_VERSIONS: return get_domain_versions(); } throw new IllegalStateException(); }
public void setFieldValue(_Fields field, Object value) { switch (field) { case DOMAIN_VERSIONS: if (value == null) { unset_domain_versions(); } else { set_domain_versions((Map<Integer,Integer>)value); } break; } }
public static ZkDomainGroup create(final ZooKeeperPlus zk, final Coordinator coordinator, final String rootPath, final String name) throws InterruptedException, KeeperException, IOException { String path = ZkPath.append(rootPath, name); DomainGroupMetadata initialMetadata = new DomainGroupMetadata(); initialMetadata.set_domain_versions(new HashMap<Integer, Integer>()); return new ZkDomainGroup(zk, coordinator, path, true, initialMetadata); }
struct.set_domain_versions_isSet(true); } else { org.apache.thrift.protocol.TProtocolUtil.skip(iprot, schemeField.type); struct.validate();
public boolean equals(DomainGroupMetadata that) { if (that == null) return false; boolean this_present_domain_versions = true && this.is_set_domain_versions(); boolean that_present_domain_versions = true && that.is_set_domain_versions(); if (this_present_domain_versions || that_present_domain_versions) { if (!(this_present_domain_versions && that_present_domain_versions)) return false; if (!this.domain_versions.equals(that.domain_versions)) return false; } return true; }
private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { try { read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in))); } catch (org.apache.thrift.TException te) { throw new java.io.IOException(te); } }
public void validate() throws org.apache.thrift.TException { // check for required fields if (domain_versions == null) { throw new org.apache.thrift.protocol.TProtocolException("Required field 'domain_versions' was not present! Struct: " + toString()); } // check for sub-struct validity }
public void write(org.apache.thrift.protocol.TProtocol oprot, DomainGroupMetadata struct) throws org.apache.thrift.TException { struct.validate(); oprot.writeStructBegin(STRUCT_DESC); if (struct.domain_versions != null) { oprot.writeFieldBegin(DOMAIN_VERSIONS_FIELD_DESC); { oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I32, org.apache.thrift.protocol.TType.I32, struct.domain_versions.size())); for (Map.Entry<Integer, Integer> _iter22 : struct.domain_versions.entrySet()) { oprot.writeI32(_iter22.getKey()); oprot.writeI32(_iter22.getValue()); } oprot.writeMapEnd(); } oprot.writeFieldEnd(); } oprot.writeFieldStop(); oprot.writeStructEnd(); }
@Override public void read(org.apache.thrift.protocol.TProtocol prot, DomainGroupMetadata struct) throws org.apache.thrift.TException { TTupleProtocol iprot = (TTupleProtocol) prot; { org.apache.thrift.protocol.TMap _map24 = new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I32, org.apache.thrift.protocol.TType.I32, iprot.readI32()); struct.domain_versions = new HashMap<Integer,Integer>(2*_map24.size); for (int _i25 = 0; _i25 < _map24.size; ++_i25) { int _key26; // required int _val27; // optional _key26 = iprot.readI32(); _val27 = iprot.readI32(); struct.domain_versions.put(_key26, _val27); } } struct.set_domain_versions_isSet(true); } }
/** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */ public boolean isSet(_Fields field) { if (field == null) { throw new IllegalArgumentException(); } switch (field) { case DOMAIN_VERSIONS: return is_set_domain_versions(); } throw new IllegalStateException(); }
@Override public int hashCode() { HashCodeBuilder builder = new HashCodeBuilder(); boolean present_domain_versions = true && (is_set_domain_versions()); builder.append(present_domain_versions); if (present_domain_versions) builder.append(domain_versions); return builder.toHashCode(); }
@Override public Set<DomainAndVersion> getDomainVersions() throws IOException { Set<DomainAndVersion> result = new HashSet<DomainAndVersion>(); for (Map.Entry<Integer, Integer> entry : metadata.get().get_domain_versions().entrySet()) { result.add(new DomainAndVersion(coordinator.getDomainById(entry.getKey()), entry.getValue())); } return result; }
public ZkDomainGroup(final ZooKeeperPlus zk, final Coordinator coordinator, final String path, final boolean create, final DomainGroupMetadata initialMetadata) throws InterruptedException, KeeperException, IOException { this.zk = zk; this.coordinator = coordinator; this.path = path; this.name = ZkPath.getFilename(path); this.metadata = new WatchedThriftNode<DomainGroupMetadata>(zk, path, true, create ? CreateMode.PERSISTENT : null, initialMetadata, new DomainGroupMetadata()); this.metadata.addListener(new WatchedNodeListener<DomainGroupMetadata>() { @Override public void onWatchedNodeChange(DomainGroupMetadata value) { synchronized (listeners) { for (DomainGroupListener listener : listeners) { listener.onDomainGroupChange(ZkDomainGroup.this); } } } }); }
/** * Performs a deep copy on <i>other</i>. */ public DomainGroupMetadata(DomainGroupMetadata other) { if (other.is_set_domain_versions()) { Map<Integer,Integer> __this__domain_versions = new HashMap<Integer,Integer>(); for (Map.Entry<Integer, Integer> other_element : other.domain_versions.entrySet()) { Integer other_element_key = other_element.getKey(); Integer other_element_value = other_element.getValue(); Integer __this__domain_versions_copy_key = other_element_key; Integer __this__domain_versions_copy_value = other_element_value; __this__domain_versions.put(__this__domain_versions_copy_key, __this__domain_versions_copy_value); } this.domain_versions = __this__domain_versions; } }
public int compareTo(DomainGroupMetadata other) { if (!getClass().equals(other.getClass())) { return getClass().getName().compareTo(other.getClass().getName()); } int lastComparison = 0; DomainGroupMetadata typedOther = (DomainGroupMetadata)other; lastComparison = Boolean.valueOf(is_set_domain_versions()).compareTo(typedOther.is_set_domain_versions()); if (lastComparison != 0) { return lastComparison; } if (is_set_domain_versions()) { lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.domain_versions, typedOther.domain_versions); if (lastComparison != 0) { return lastComparison; } } return 0; }