diff --git a/pom.xml b/pom.xml index 97ca375f1..399cc57fb 100644 --- a/pom.xml +++ b/pom.xml @@ -212,6 +212,11 @@ ${dropwizard.version} test + + com.hp.csbu.cc + CsThriftModel + 1.2-SNAPSHOT + diff --git a/src/main/java/com/hp/csbu/cc/middleware/AuthClient.java b/src/main/java/com/hp/csbu/cc/middleware/AuthClient.java index 8f20ac391..324f264f4 100644 --- a/src/main/java/com/hp/csbu/cc/middleware/AuthClient.java +++ b/src/main/java/com/hp/csbu/cc/middleware/AuthClient.java @@ -5,11 +5,12 @@ import java.util.Map; import org.apache.http.client.ClientProtocolException; import org.apache.thrift.TException; -/*import org.apache.thrift.TException; +import org.apache.thrift.TException; + import com.hp.csbu.cc.security.cs.thrift.service.AuthResponse; import com.hp.csbu.cc.security.cs.thrift.service.ResourceException; -import com.hp.csbu.cc.security.cs.thrift.service.SigAuthRequest; */ +import com.hp.csbu.cc.security.cs.thrift.service.SigAuthRequest; /** @@ -25,6 +26,6 @@ public interface AuthClient { public Object validateTokenForServiceEndpointV3(String token, Map inputParams) throws TException, ClientProtocolException; //ResourceException - //public AuthResponse validateSignature(SigAuthRequest request) throws ResourceException, TException; + public AuthResponse validateSignature(SigAuthRequest request) throws ResourceException, TException; } diff --git a/src/main/java/com/hp/csbu/cc/middleware/HttpAuthClient.java b/src/main/java/com/hp/csbu/cc/middleware/HttpAuthClient.java index c8afc80be..c9e392c9e 100644 --- a/src/main/java/com/hp/csbu/cc/middleware/HttpAuthClient.java +++ b/src/main/java/com/hp/csbu/cc/middleware/HttpAuthClient.java @@ -15,6 +15,8 @@ import java.util.Date; import java.util.Map; import java.util.TimeZone; +import com.hp.csbu.cc.security.cs.thrift.service.AuthResponse; +import com.hp.csbu.cc.security.cs.thrift.service.SigAuthRequest; import org.apache.http.Header; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; @@ -288,9 +290,9 @@ public class HttpAuthClient implements AuthClient { public void reset() { } -/* @Override +@Override public AuthResponse validateSignature(SigAuthRequest request) { // TODO Auto-generated method stub return null; - }*/ + } } diff --git a/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/AuthResponse.java b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/AuthResponse.java new file mode 100755 index 000000000..16af464f8 --- /dev/null +++ b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/AuthResponse.java @@ -0,0 +1,485 @@ +/* */ package com.hp.csbu.cc.security.cs.thrift.service; +/* */ +/* */ import java.io.IOException; +/* */ import java.io.ObjectInputStream; +/* */ import java.io.ObjectOutputStream; +/* */ import java.io.Serializable; +/* */ import java.util.BitSet; +/* */ import java.util.Collections; +/* */ import java.util.EnumMap; +/* */ import java.util.EnumSet; +/* */ import java.util.HashMap; +/* */ import java.util.Map; +/* */ import org.apache.thrift.TBase; +/* */ import org.apache.thrift.TBaseHelper; +/* */ import org.apache.thrift.TException; +/* */ import org.apache.thrift.TFieldIdEnum; +/* */ import org.apache.thrift.meta_data.FieldMetaData; +/* */ import org.apache.thrift.meta_data.StructMetaData; +/* */ import org.apache.thrift.protocol.TCompactProtocol; +/* */ import org.apache.thrift.protocol.TField; +/* */ import org.apache.thrift.protocol.TProtocol; +/* */ import org.apache.thrift.protocol.TProtocolUtil; +/* */ import org.apache.thrift.protocol.TStruct; +/* */ import org.apache.thrift.protocol.TTupleProtocol; +/* */ import org.apache.thrift.scheme.IScheme; +/* */ import org.apache.thrift.scheme.SchemeFactory; +/* */ import org.apache.thrift.scheme.StandardScheme; +/* */ import org.apache.thrift.scheme.TupleScheme; +/* */ import org.apache.thrift.transport.TIOStreamTransport; +/* */ +/* */ public class AuthResponse +/* */ implements TBase, Serializable, Cloneable +/* */ { +/* 35 */ private static final TStruct STRUCT_DESC = new TStruct("AuthResponse"); +/* */ +/* 37 */ private static final TField TOKEN_INFO_FIELD_DESC = new TField("tokenInfo", (byte)12, (short)1); +/* 38 */ private static final TField USER_INFO_FIELD_DESC = new TField("userInfo", (byte)12, (short)2); +/* */ +/* 40 */ private static final Map, SchemeFactory> schemes = new HashMap(); +/* */ public Token tokenInfo; +/* */ public User userInfo; +/* */ public static final Map<_Fields, FieldMetaData> metaDataMap; +/* */ +/* */ public AuthResponse() +/* */ { +/* */ } +/* */ +/* */ public AuthResponse(Token tokenInfo, User userInfo) +/* */ { +/* 129 */ this(); +/* 130 */ this.tokenInfo = tokenInfo; +/* 131 */ this.userInfo = userInfo; +/* */ } +/* */ +/* */ public AuthResponse(AuthResponse other) +/* */ { +/* 138 */ if (other.isSetTokenInfo()) { +/* 139 */ this.tokenInfo = new Token(other.tokenInfo); +/* */ } +/* 141 */ if (other.isSetUserInfo()) +/* 142 */ this.userInfo = new User(other.userInfo); +/* */ } +/* */ +/* */ public AuthResponse deepCopy() +/* */ { +/* 147 */ return new AuthResponse(this); +/* */ } +/* */ +/* */ public void clear() +/* */ { +/* 152 */ this.tokenInfo = null; +/* 153 */ this.userInfo = null; +/* */ } +/* */ +/* */ public Token getTokenInfo() { +/* 157 */ return this.tokenInfo; +/* */ } +/* */ +/* */ public AuthResponse setTokenInfo(Token tokenInfo) { +/* 161 */ this.tokenInfo = tokenInfo; +/* 162 */ return this; +/* */ } +/* */ +/* */ public void unsetTokenInfo() { +/* 166 */ this.tokenInfo = null; +/* */ } +/* */ +/* */ public boolean isSetTokenInfo() +/* */ { +/* 171 */ return this.tokenInfo != null; +/* */ } +/* */ +/* */ public void setTokenInfoIsSet(boolean value) { +/* 175 */ if (!value) +/* 176 */ this.tokenInfo = null; +/* */ } +/* */ +/* */ public User getUserInfo() +/* */ { +/* 181 */ return this.userInfo; +/* */ } +/* */ +/* */ public AuthResponse setUserInfo(User userInfo) { +/* 185 */ this.userInfo = userInfo; +/* 186 */ return this; +/* */ } +/* */ +/* */ public void unsetUserInfo() { +/* 190 */ this.userInfo = null; +/* */ } +/* */ +/* */ public boolean isSetUserInfo() +/* */ { +/* 195 */ return this.userInfo != null; +/* */ } +/* */ +/* */ public void setUserInfoIsSet(boolean value) { +/* 199 */ if (!value) +/* 200 */ this.userInfo = null; +/* */ } +/* */ +/* */ public void setFieldValue(_Fields field, Object value) +/* */ { +/* 205 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$AuthResponse$_Fields[field.ordinal()]) { +/* */ case 1: +/* 207 */ if (value == null) +/* 208 */ unsetTokenInfo(); +/* */ else { +/* 210 */ setTokenInfo((Token)value); +/* */ } +/* 212 */ break; +/* */ case 2: +/* 215 */ if (value == null) +/* 216 */ unsetUserInfo(); +/* */ else +/* 218 */ setUserInfo((User)value); +/* */ break; +/* */ } +/* */ } +/* */ +/* */ public Object getFieldValue(_Fields field) +/* */ { +/* 226 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$AuthResponse$_Fields[field.ordinal()]) { +/* */ case 1: +/* 228 */ return getTokenInfo(); +/* */ case 2: +/* 231 */ return getUserInfo(); +/* */ } +/* */ +/* 234 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean isSet(_Fields field) +/* */ { +/* 239 */ if (field == null) { +/* 240 */ throw new IllegalArgumentException(); +/* */ } +/* */ +/* 243 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$AuthResponse$_Fields[field.ordinal()]) { +/* */ case 1: +/* 245 */ return isSetTokenInfo(); +/* */ case 2: +/* 247 */ return isSetUserInfo(); +/* */ } +/* 249 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean equals(Object that) +/* */ { +/* 254 */ if (that == null) +/* 255 */ return false; +/* 256 */ if ((that instanceof AuthResponse)) +/* 257 */ return equals((AuthResponse)that); +/* 258 */ return false; +/* */ } +/* */ +/* */ public boolean equals(AuthResponse that) { +/* 262 */ if (that == null) { +/* 263 */ return false; +/* */ } +/* 265 */ boolean this_present_tokenInfo = isSetTokenInfo(); +/* 266 */ boolean that_present_tokenInfo = that.isSetTokenInfo(); +/* 267 */ if ((this_present_tokenInfo) || (that_present_tokenInfo)) { +/* 268 */ if ((!this_present_tokenInfo) || (!that_present_tokenInfo)) +/* 269 */ return false; +/* 270 */ if (!this.tokenInfo.equals(that.tokenInfo)) { +/* 271 */ return false; +/* */ } +/* */ } +/* 274 */ boolean this_present_userInfo = isSetUserInfo(); +/* 275 */ boolean that_present_userInfo = that.isSetUserInfo(); +/* 276 */ if ((this_present_userInfo) || (that_present_userInfo)) { +/* 277 */ if ((!this_present_userInfo) || (!that_present_userInfo)) +/* 278 */ return false; +/* 279 */ if (!this.userInfo.equals(that.userInfo)) { +/* 280 */ return false; +/* */ } +/* */ } +/* 283 */ return true; +/* */ } +/* */ +/* */ public int hashCode() +/* */ { +/* 288 */ return 0; +/* */ } +/* */ +/* */ public int compareTo(AuthResponse other) { +/* 292 */ if (!getClass().equals(other.getClass())) { +/* 293 */ return getClass().getName().compareTo(other.getClass().getName()); +/* */ } +/* */ +/* 296 */ int lastComparison = 0; +/* 297 */ AuthResponse typedOther = other; +/* */ +/* 299 */ lastComparison = Boolean.valueOf(isSetTokenInfo()).compareTo(Boolean.valueOf(typedOther.isSetTokenInfo())); +/* 300 */ if (lastComparison != 0) { +/* 301 */ return lastComparison; +/* */ } +/* 303 */ if (isSetTokenInfo()) { +/* 304 */ lastComparison = TBaseHelper.compareTo(this.tokenInfo, typedOther.tokenInfo); +/* 305 */ if (lastComparison != 0) { +/* 306 */ return lastComparison; +/* */ } +/* */ } +/* 309 */ lastComparison = Boolean.valueOf(isSetUserInfo()).compareTo(Boolean.valueOf(typedOther.isSetUserInfo())); +/* 310 */ if (lastComparison != 0) { +/* 311 */ return lastComparison; +/* */ } +/* 313 */ if (isSetUserInfo()) { +/* 314 */ lastComparison = TBaseHelper.compareTo(this.userInfo, typedOther.userInfo); +/* 315 */ if (lastComparison != 0) { +/* 316 */ return lastComparison; +/* */ } +/* */ } +/* 319 */ return 0; +/* */ } +/* */ +/* */ public _Fields fieldForId(int fieldId) { +/* 323 */ return _Fields.findByThriftId(fieldId); +/* */ } +/* */ +/* */ public void read(TProtocol iprot) throws TException { +/* 327 */ ((SchemeFactory)schemes.get(iprot.getScheme())).getScheme().read(iprot, this); +/* */ } +/* */ +/* */ public void write(TProtocol oprot) throws TException { +/* 331 */ ((SchemeFactory)schemes.get(oprot.getScheme())).getScheme().write(oprot, this); +/* */ } +/* */ +/* */ public String toString() +/* */ { +/* 336 */ StringBuilder sb = new StringBuilder("AuthResponse("); +/* 337 */ boolean first = true; +/* */ +/* 339 */ sb.append("tokenInfo:"); +/* 340 */ if (this.tokenInfo == null) +/* 341 */ sb.append("null"); +/* */ else { +/* 343 */ sb.append(this.tokenInfo); +/* */ } +/* 345 */ first = false; +/* 346 */ if (!first) sb.append(", "); +/* 347 */ sb.append("userInfo:"); +/* 348 */ if (this.userInfo == null) +/* 349 */ sb.append("null"); +/* */ else { +/* 351 */ sb.append(this.userInfo); +/* */ } +/* 353 */ first = false; +/* 354 */ sb.append(")"); +/* 355 */ return sb.toString(); +/* */ } +/* */ +/* */ public void validate() throws TException +/* */ { +/* */ } +/* */ +/* */ private void writeObject(ObjectOutputStream out) throws IOException { +/* */ try { +/* 364 */ write(new TCompactProtocol(new TIOStreamTransport(out))); +/* */ } catch (TException te) { +/* 366 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { +/* */ try { +/* 372 */ read(new TCompactProtocol(new TIOStreamTransport(in))); +/* */ } catch (TException te) { +/* 374 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ static +/* */ { +/* 42 */ schemes.put(StandardScheme.class, new AuthResponseStandardSchemeFactory()); +/* 43 */ schemes.put(TupleScheme.class, new AuthResponseTupleSchemeFactory()); +/* */ +/* 113 */ Map tmpMap = new EnumMap(_Fields.class); +/* 114 */ tmpMap.put(_Fields.TOKEN_INFO, new FieldMetaData("tokenInfo", (byte)3, new StructMetaData((byte)12, Token.class))); +/* */ +/* 116 */ tmpMap.put(_Fields.USER_INFO, new FieldMetaData("userInfo", (byte)3, new StructMetaData((byte)12, User.class))); +/* */ +/* 118 */ metaDataMap = Collections.unmodifiableMap(tmpMap); +/* 119 */ FieldMetaData.addStructMetaDataMap(AuthResponse.class, metaDataMap); +/* */ } +/* */ +/* */ private static class AuthResponseTupleScheme extends TupleScheme +/* */ { +/* */ public void write(TProtocol prot, AuthResponse struct) +/* */ throws TException +/* */ { +/* 455 */ TTupleProtocol oprot = (TTupleProtocol)prot; +/* 456 */ BitSet optionals = new BitSet(); +/* 457 */ if (struct.isSetTokenInfo()) { +/* 458 */ optionals.set(0); +/* */ } +/* 460 */ if (struct.isSetUserInfo()) { +/* 461 */ optionals.set(1); +/* */ } +/* 463 */ oprot.writeBitSet(optionals, 2); +/* 464 */ if (struct.isSetTokenInfo()) { +/* 465 */ struct.tokenInfo.write(oprot); +/* */ } +/* 467 */ if (struct.isSetUserInfo()) +/* 468 */ struct.userInfo.write(oprot); +/* */ } +/* */ +/* */ public void read(TProtocol prot, AuthResponse struct) +/* */ throws TException +/* */ { +/* 474 */ TTupleProtocol iprot = (TTupleProtocol)prot; +/* 475 */ BitSet incoming = iprot.readBitSet(2); +/* 476 */ if (incoming.get(0)) { +/* 477 */ struct.tokenInfo = new Token(); +/* 478 */ struct.tokenInfo.read(iprot); +/* 479 */ struct.setTokenInfoIsSet(true); +/* */ } +/* 481 */ if (incoming.get(1)) { +/* 482 */ struct.userInfo = new User(); +/* 483 */ struct.userInfo.read(iprot); +/* 484 */ struct.setUserInfoIsSet(true); +/* */ } +/* */ } +/* */ } +/* */ +/* */ private static class AuthResponseTupleSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public AuthResponse.AuthResponseTupleScheme getScheme() +/* */ { +/* 447 */ return new AuthResponse.AuthResponseTupleScheme(); +/* */ } +/* */ } +/* */ +/* */ private static class AuthResponseStandardScheme extends StandardScheme +/* */ { +/* */ public void read(TProtocol iprot, AuthResponse struct) +/* */ throws TException +/* */ { +/* 388 */ iprot.readStructBegin(); +/* */ while (true) +/* */ { +/* 391 */ TField schemeField = iprot.readFieldBegin(); +/* 392 */ if (schemeField.type == 0) { +/* */ break; +/* */ } +/* 395 */ switch (schemeField.id) { +/* */ case 1: +/* 397 */ if (schemeField.type == 12) { +/* 398 */ struct.tokenInfo = new Token(); +/* 399 */ struct.tokenInfo.read(iprot); +/* 400 */ struct.setTokenInfoIsSet(true); +/* */ } else { +/* 402 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 404 */ break; +/* */ case 2: +/* 406 */ if (schemeField.type == 12) { +/* 407 */ struct.userInfo = new User(); +/* 408 */ struct.userInfo.read(iprot); +/* 409 */ struct.setUserInfoIsSet(true); +/* */ } else { +/* 411 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 413 */ break; +/* */ default: +/* 415 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 417 */ iprot.readFieldEnd(); +/* */ } +/* 419 */ iprot.readStructEnd(); +/* */ +/* 422 */ struct.validate(); +/* */ } +/* */ +/* */ public void write(TProtocol oprot, AuthResponse struct) throws TException { +/* 426 */ struct.validate(); +/* */ +/* 428 */ oprot.writeStructBegin(AuthResponse.STRUCT_DESC); +/* 429 */ if (struct.tokenInfo != null) { +/* 430 */ oprot.writeFieldBegin(AuthResponse.TOKEN_INFO_FIELD_DESC); +/* 431 */ struct.tokenInfo.write(oprot); +/* 432 */ oprot.writeFieldEnd(); +/* */ } +/* 434 */ if (struct.userInfo != null) { +/* 435 */ oprot.writeFieldBegin(AuthResponse.USER_INFO_FIELD_DESC); +/* 436 */ struct.userInfo.write(oprot); +/* 437 */ oprot.writeFieldEnd(); +/* */ } +/* 439 */ oprot.writeFieldStop(); +/* 440 */ oprot.writeStructEnd(); +/* */ } +/* */ } +/* */ +/* */ private static class AuthResponseStandardSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public AuthResponse.AuthResponseStandardScheme getScheme() +/* */ { +/* 380 */ return new AuthResponse.AuthResponseStandardScheme(); +/* */ } +/* */ } +/* */ +/* */ public static enum _Fields +/* */ implements TFieldIdEnum +/* */ { +/* 51 */ TOKEN_INFO((short)1, "tokenInfo"), +/* 52 */ USER_INFO((short)2, "userInfo"); +/* */ +/* */ private static final Map byName; +/* */ private final short _thriftId; +/* */ private final String _fieldName; +/* */ +/* */ public static _Fields findByThriftId(int fieldId) +/* */ { +/* 66 */ switch (fieldId) { +/* */ case 1: +/* 68 */ return TOKEN_INFO; +/* */ case 2: +/* 70 */ return USER_INFO; +/* */ } +/* 72 */ return null; +/* */ } +/* */ +/* */ public static _Fields findByThriftIdOrThrow(int fieldId) +/* */ { +/* 81 */ _Fields fields = findByThriftId(fieldId); +/* 82 */ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); +/* 83 */ return fields; +/* */ } +/* */ +/* */ public static _Fields findByName(String name) +/* */ { +/* 90 */ return (_Fields)byName.get(name); +/* */ } +/* */ +/* */ private _Fields(short thriftId, String fieldName) +/* */ { +/* 97 */ this._thriftId = thriftId; +/* 98 */ this._fieldName = fieldName; +/* */ } +/* */ +/* */ public short getThriftFieldId() { +/* 102 */ return this._thriftId; +/* */ } +/* */ +/* */ public String getFieldName() { +/* 106 */ return this._fieldName; +/* */ } +/* */ +/* */ static +/* */ { +/* 54 */ byName = new HashMap(); +/* */ +/* 57 */ for (_Fields field : EnumSet.allOf(_Fields.class)) +/* 58 */ byName.put(field.getFieldName(), field); +/* */ } +/* */ } +/* */ } + +/* Location: /Users/johnderr/.m2/repository/com/hp/csbu/cc/CsThriftModel/1.2-SNAPSHOT/CsThriftModel-1.2-20140130.160951-1223.jar + * Qualified Name: com.hp.csbu.cc.security.cs.thrift.service.AuthResponse + * JD-Core Version: 0.6.2 + */ \ No newline at end of file diff --git a/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/ResourceException.java b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/ResourceException.java new file mode 100755 index 000000000..b3e89bb88 --- /dev/null +++ b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/ResourceException.java @@ -0,0 +1,575 @@ +/* */ package com.hp.csbu.cc.security.cs.thrift.service; +/* */ +/* */ import java.io.IOException; +/* */ import java.io.ObjectInputStream; +/* */ import java.io.ObjectOutputStream; +/* */ import java.io.Serializable; +/* */ import java.util.BitSet; +/* */ import java.util.Collections; +/* */ import java.util.EnumMap; +/* */ import java.util.EnumSet; +/* */ import java.util.HashMap; +/* */ import java.util.Map; +/* */ import org.apache.thrift.TBase; +/* */ import org.apache.thrift.TBaseHelper; +/* */ import org.apache.thrift.TException; +/* */ import org.apache.thrift.TFieldIdEnum; +/* */ import org.apache.thrift.meta_data.FieldMetaData; +/* */ import org.apache.thrift.meta_data.FieldValueMetaData; +/* */ import org.apache.thrift.protocol.TCompactProtocol; +/* */ import org.apache.thrift.protocol.TField; +/* */ import org.apache.thrift.protocol.TProtocol; +/* */ import org.apache.thrift.protocol.TProtocolUtil; +/* */ import org.apache.thrift.protocol.TStruct; +/* */ import org.apache.thrift.protocol.TTupleProtocol; +/* */ import org.apache.thrift.scheme.IScheme; +/* */ import org.apache.thrift.scheme.SchemeFactory; +/* */ import org.apache.thrift.scheme.StandardScheme; +/* */ import org.apache.thrift.scheme.TupleScheme; +/* */ import org.apache.thrift.transport.TIOStreamTransport; +/* */ +/* */ public class ResourceException extends Exception +/* */ implements TBase, Serializable, Cloneable +/* */ { +/* 36 */ private static final TStruct STRUCT_DESC = new TStruct("ResourceException"); +/* */ +/* 38 */ private static final TField CODE_FIELD_DESC = new TField("code", (byte)8, (short)1); +/* 39 */ private static final TField MESSAGE_FIELD_DESC = new TField("message", (byte)11, (short)2); +/* 40 */ private static final TField DETAIL_FIELD_DESC = new TField("detail", (byte)11, (short)3); +/* */ +/* 42 */ private static final Map, SchemeFactory> schemes = new HashMap(); +/* */ public int code; +/* */ public String message; +/* */ public String detail; +/* */ private static final int __CODE_ISSET_ID = 0; +/* 118 */ private BitSet __isset_bit_vector = new BitSet(1); +/* */ public static final Map<_Fields, FieldMetaData> metaDataMap; +/* */ +/* */ public ResourceException() +/* */ { +/* */ } +/* */ +/* */ public ResourceException(int code, String message, String detail) +/* */ { +/* 140 */ this(); +/* 141 */ this.code = code; +/* 142 */ setCodeIsSet(true); +/* 143 */ this.message = message; +/* 144 */ this.detail = detail; +/* */ } +/* */ +/* */ public ResourceException(ResourceException other) +/* */ { +/* 151 */ this.__isset_bit_vector.clear(); +/* 152 */ this.__isset_bit_vector.or(other.__isset_bit_vector); +/* 153 */ this.code = other.code; +/* 154 */ if (other.isSetMessage()) { +/* 155 */ this.message = other.message; +/* */ } +/* 157 */ if (other.isSetDetail()) +/* 158 */ this.detail = other.detail; +/* */ } +/* */ +/* */ public ResourceException deepCopy() +/* */ { +/* 163 */ return new ResourceException(this); +/* */ } +/* */ +/* */ public void clear() +/* */ { +/* 168 */ setCodeIsSet(false); +/* 169 */ this.code = 0; +/* 170 */ this.message = null; +/* 171 */ this.detail = null; +/* */ } +/* */ +/* */ public int getCode() { +/* 175 */ return this.code; +/* */ } +/* */ +/* */ public ResourceException setCode(int code) { +/* 179 */ this.code = code; +/* 180 */ setCodeIsSet(true); +/* 181 */ return this; +/* */ } +/* */ +/* */ public void unsetCode() { +/* 185 */ this.__isset_bit_vector.clear(0); +/* */ } +/* */ +/* */ public boolean isSetCode() +/* */ { +/* 190 */ return this.__isset_bit_vector.get(0); +/* */ } +/* */ +/* */ public void setCodeIsSet(boolean value) { +/* 194 */ this.__isset_bit_vector.set(0, value); +/* */ } +/* */ +/* */ public String getMessage() { +/* 198 */ return this.message; +/* */ } +/* */ +/* */ public ResourceException setMessage(String message) { +/* 202 */ this.message = message; +/* 203 */ return this; +/* */ } +/* */ +/* */ public void unsetMessage() { +/* 207 */ this.message = null; +/* */ } +/* */ +/* */ public boolean isSetMessage() +/* */ { +/* 212 */ return this.message != null; +/* */ } +/* */ +/* */ public void setMessageIsSet(boolean value) { +/* 216 */ if (!value) +/* 217 */ this.message = null; +/* */ } +/* */ +/* */ public String getDetail() +/* */ { +/* 222 */ return this.detail; +/* */ } +/* */ +/* */ public ResourceException setDetail(String detail) { +/* 226 */ this.detail = detail; +/* 227 */ return this; +/* */ } +/* */ +/* */ public void unsetDetail() { +/* 231 */ this.detail = null; +/* */ } +/* */ +/* */ public boolean isSetDetail() +/* */ { +/* 236 */ return this.detail != null; +/* */ } +/* */ +/* */ public void setDetailIsSet(boolean value) { +/* 240 */ if (!value) +/* 241 */ this.detail = null; +/* */ } +/* */ +/* */ public void setFieldValue(_Fields field, Object value) +/* */ { +/* 246 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$ResourceException$_Fields[field.ordinal()]) { +/* */ case 1: +/* 248 */ if (value == null) +/* 249 */ unsetCode(); +/* */ else { +/* 251 */ setCode(((Integer)value).intValue()); +/* */ } +/* 253 */ break; +/* */ case 2: +/* 256 */ if (value == null) +/* 257 */ unsetMessage(); +/* */ else { +/* 259 */ setMessage((String)value); +/* */ } +/* 261 */ break; +/* */ case 3: +/* 264 */ if (value == null) +/* 265 */ unsetDetail(); +/* */ else +/* 267 */ setDetail((String)value); +/* */ break; +/* */ } +/* */ } +/* */ +/* */ public Object getFieldValue(_Fields field) +/* */ { +/* 275 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$ResourceException$_Fields[field.ordinal()]) { +/* */ case 1: +/* 277 */ return Integer.valueOf(getCode()); +/* */ case 2: +/* 280 */ return getMessage(); +/* */ case 3: +/* 283 */ return getDetail(); +/* */ } +/* */ +/* 286 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean isSet(_Fields field) +/* */ { +/* 291 */ if (field == null) { +/* 292 */ throw new IllegalArgumentException(); +/* */ } +/* */ +/* 295 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$ResourceException$_Fields[field.ordinal()]) { +/* */ case 1: +/* 297 */ return isSetCode(); +/* */ case 2: +/* 299 */ return isSetMessage(); +/* */ case 3: +/* 301 */ return isSetDetail(); +/* */ } +/* 303 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean equals(Object that) +/* */ { +/* 308 */ if (that == null) +/* 309 */ return false; +/* 310 */ if ((that instanceof ResourceException)) +/* 311 */ return equals((ResourceException)that); +/* 312 */ return false; +/* */ } +/* */ +/* */ public boolean equals(ResourceException that) { +/* 316 */ if (that == null) { +/* 317 */ return false; +/* */ } +/* 319 */ boolean this_present_code = true; +/* 320 */ boolean that_present_code = true; +/* 321 */ if ((this_present_code) || (that_present_code)) { +/* 322 */ if ((!this_present_code) || (!that_present_code)) +/* 323 */ return false; +/* 324 */ if (this.code != that.code) { +/* 325 */ return false; +/* */ } +/* */ } +/* 328 */ boolean this_present_message = isSetMessage(); +/* 329 */ boolean that_present_message = that.isSetMessage(); +/* 330 */ if ((this_present_message) || (that_present_message)) { +/* 331 */ if ((!this_present_message) || (!that_present_message)) +/* 332 */ return false; +/* 333 */ if (!this.message.equals(that.message)) { +/* 334 */ return false; +/* */ } +/* */ } +/* 337 */ boolean this_present_detail = isSetDetail(); +/* 338 */ boolean that_present_detail = that.isSetDetail(); +/* 339 */ if ((this_present_detail) || (that_present_detail)) { +/* 340 */ if ((!this_present_detail) || (!that_present_detail)) +/* 341 */ return false; +/* 342 */ if (!this.detail.equals(that.detail)) { +/* 343 */ return false; +/* */ } +/* */ } +/* 346 */ return true; +/* */ } +/* */ +/* */ public int hashCode() +/* */ { +/* 351 */ return 0; +/* */ } +/* */ +/* */ public int compareTo(ResourceException other) { +/* 355 */ if (!getClass().equals(other.getClass())) { +/* 356 */ return getClass().getName().compareTo(other.getClass().getName()); +/* */ } +/* */ +/* 359 */ int lastComparison = 0; +/* 360 */ ResourceException typedOther = other; +/* */ +/* 362 */ lastComparison = Boolean.valueOf(isSetCode()).compareTo(Boolean.valueOf(typedOther.isSetCode())); +/* 363 */ if (lastComparison != 0) { +/* 364 */ return lastComparison; +/* */ } +/* 366 */ if (isSetCode()) { +/* 367 */ lastComparison = TBaseHelper.compareTo(this.code, typedOther.code); +/* 368 */ if (lastComparison != 0) { +/* 369 */ return lastComparison; +/* */ } +/* */ } +/* 372 */ lastComparison = Boolean.valueOf(isSetMessage()).compareTo(Boolean.valueOf(typedOther.isSetMessage())); +/* 373 */ if (lastComparison != 0) { +/* 374 */ return lastComparison; +/* */ } +/* 376 */ if (isSetMessage()) { +/* 377 */ lastComparison = TBaseHelper.compareTo(this.message, typedOther.message); +/* 378 */ if (lastComparison != 0) { +/* 379 */ return lastComparison; +/* */ } +/* */ } +/* 382 */ lastComparison = Boolean.valueOf(isSetDetail()).compareTo(Boolean.valueOf(typedOther.isSetDetail())); +/* 383 */ if (lastComparison != 0) { +/* 384 */ return lastComparison; +/* */ } +/* 386 */ if (isSetDetail()) { +/* 387 */ lastComparison = TBaseHelper.compareTo(this.detail, typedOther.detail); +/* 388 */ if (lastComparison != 0) { +/* 389 */ return lastComparison; +/* */ } +/* */ } +/* 392 */ return 0; +/* */ } +/* */ +/* */ public _Fields fieldForId(int fieldId) { +/* 396 */ return _Fields.findByThriftId(fieldId); +/* */ } +/* */ +/* */ public void read(TProtocol iprot) throws TException { +/* 400 */ ((SchemeFactory)schemes.get(iprot.getScheme())).getScheme().read(iprot, this); +/* */ } +/* */ +/* */ public void write(TProtocol oprot) throws TException { +/* 404 */ ((SchemeFactory)schemes.get(oprot.getScheme())).getScheme().write(oprot, this); +/* */ } +/* */ +/* */ public String toString() +/* */ { +/* 409 */ StringBuilder sb = new StringBuilder("ResourceException("); +/* 410 */ boolean first = true; +/* */ +/* 412 */ sb.append("code:"); +/* 413 */ sb.append(this.code); +/* 414 */ first = false; +/* 415 */ if (!first) sb.append(", "); +/* 416 */ sb.append("message:"); +/* 417 */ if (this.message == null) +/* 418 */ sb.append("null"); +/* */ else { +/* 420 */ sb.append(this.message); +/* */ } +/* 422 */ first = false; +/* 423 */ if (!first) sb.append(", "); +/* 424 */ sb.append("detail:"); +/* 425 */ if (this.detail == null) +/* 426 */ sb.append("null"); +/* */ else { +/* 428 */ sb.append(this.detail); +/* */ } +/* 430 */ first = false; +/* 431 */ sb.append(")"); +/* 432 */ return sb.toString(); +/* */ } +/* */ +/* */ public void validate() throws TException +/* */ { +/* */ } +/* */ +/* */ private void writeObject(ObjectOutputStream out) throws IOException { +/* */ try { +/* 441 */ write(new TCompactProtocol(new TIOStreamTransport(out))); +/* */ } catch (TException te) { +/* 443 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { +/* */ try { +/* 449 */ read(new TCompactProtocol(new TIOStreamTransport(in))); +/* */ } catch (TException te) { +/* 451 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ static +/* */ { +/* 44 */ schemes.put(StandardScheme.class, new ResourceExceptionStandardSchemeFactory()); +/* 45 */ schemes.put(TupleScheme.class, new ResourceExceptionTupleSchemeFactory()); +/* */ +/* 121 */ Map tmpMap = new EnumMap(_Fields.class); +/* 122 */ tmpMap.put(_Fields.CODE, new FieldMetaData("code", (byte)3, new FieldValueMetaData((byte)8))); +/* */ +/* 124 */ tmpMap.put(_Fields.MESSAGE, new FieldMetaData("message", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 126 */ tmpMap.put(_Fields.DETAIL, new FieldMetaData("detail", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 128 */ metaDataMap = Collections.unmodifiableMap(tmpMap); +/* 129 */ FieldMetaData.addStructMetaDataMap(ResourceException.class, metaDataMap); +/* */ } +/* */ +/* */ private static class ResourceExceptionTupleScheme extends TupleScheme +/* */ { +/* */ public void write(TProtocol prot, ResourceException struct) +/* */ throws TException +/* */ { +/* 541 */ TTupleProtocol oprot = (TTupleProtocol)prot; +/* 542 */ BitSet optionals = new BitSet(); +/* 543 */ if (struct.isSetCode()) { +/* 544 */ optionals.set(0); +/* */ } +/* 546 */ if (struct.isSetMessage()) { +/* 547 */ optionals.set(1); +/* */ } +/* 549 */ if (struct.isSetDetail()) { +/* 550 */ optionals.set(2); +/* */ } +/* 552 */ oprot.writeBitSet(optionals, 3); +/* 553 */ if (struct.isSetCode()) { +/* 554 */ oprot.writeI32(struct.code); +/* */ } +/* 556 */ if (struct.isSetMessage()) { +/* 557 */ oprot.writeString(struct.message); +/* */ } +/* 559 */ if (struct.isSetDetail()) +/* 560 */ oprot.writeString(struct.detail); +/* */ } +/* */ +/* */ public void read(TProtocol prot, ResourceException struct) +/* */ throws TException +/* */ { +/* 566 */ TTupleProtocol iprot = (TTupleProtocol)prot; +/* 567 */ BitSet incoming = iprot.readBitSet(3); +/* 568 */ if (incoming.get(0)) { +/* 569 */ struct.code = iprot.readI32(); +/* 570 */ struct.setCodeIsSet(true); +/* */ } +/* 572 */ if (incoming.get(1)) { +/* 573 */ struct.message = iprot.readString(); +/* 574 */ struct.setMessageIsSet(true); +/* */ } +/* 576 */ if (incoming.get(2)) { +/* 577 */ struct.detail = iprot.readString(); +/* 578 */ struct.setDetailIsSet(true); +/* */ } +/* */ } +/* */ } +/* */ +/* */ private static class ResourceExceptionTupleSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public ResourceException.ResourceExceptionTupleScheme getScheme() +/* */ { +/* 533 */ return new ResourceException.ResourceExceptionTupleScheme(); +/* */ } +/* */ } +/* */ +/* */ private static class ResourceExceptionStandardScheme extends StandardScheme +/* */ { +/* */ public void read(TProtocol iprot, ResourceException struct) +/* */ throws TException +/* */ { +/* 465 */ iprot.readStructBegin(); +/* */ while (true) +/* */ { +/* 468 */ TField schemeField = iprot.readFieldBegin(); +/* 469 */ if (schemeField.type == 0) { +/* */ break; +/* */ } +/* 472 */ switch (schemeField.id) { +/* */ case 1: +/* 474 */ if (schemeField.type == 8) { +/* 475 */ struct.code = iprot.readI32(); +/* 476 */ struct.setCodeIsSet(true); +/* */ } else { +/* 478 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 480 */ break; +/* */ case 2: +/* 482 */ if (schemeField.type == 11) { +/* 483 */ struct.message = iprot.readString(); +/* 484 */ struct.setMessageIsSet(true); +/* */ } else { +/* 486 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 488 */ break; +/* */ case 3: +/* 490 */ if (schemeField.type == 11) { +/* 491 */ struct.detail = iprot.readString(); +/* 492 */ struct.setDetailIsSet(true); +/* */ } else { +/* 494 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 496 */ break; +/* */ default: +/* 498 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 500 */ iprot.readFieldEnd(); +/* */ } +/* 502 */ iprot.readStructEnd(); +/* */ +/* 505 */ struct.validate(); +/* */ } +/* */ +/* */ public void write(TProtocol oprot, ResourceException struct) throws TException { +/* 509 */ struct.validate(); +/* */ +/* 511 */ oprot.writeStructBegin(ResourceException.STRUCT_DESC); +/* 512 */ oprot.writeFieldBegin(ResourceException.CODE_FIELD_DESC); +/* 513 */ oprot.writeI32(struct.code); +/* 514 */ oprot.writeFieldEnd(); +/* 515 */ if (struct.message != null) { +/* 516 */ oprot.writeFieldBegin(ResourceException.MESSAGE_FIELD_DESC); +/* 517 */ oprot.writeString(struct.message); +/* 518 */ oprot.writeFieldEnd(); +/* */ } +/* 520 */ if (struct.detail != null) { +/* 521 */ oprot.writeFieldBegin(ResourceException.DETAIL_FIELD_DESC); +/* 522 */ oprot.writeString(struct.detail); +/* 523 */ oprot.writeFieldEnd(); +/* */ } +/* 525 */ oprot.writeFieldStop(); +/* 526 */ oprot.writeStructEnd(); +/* */ } +/* */ } +/* */ +/* */ private static class ResourceExceptionStandardSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public ResourceException.ResourceExceptionStandardScheme getScheme() +/* */ { +/* 457 */ return new ResourceException.ResourceExceptionStandardScheme(); +/* */ } +/* */ } +/* */ +/* */ public static enum _Fields +/* */ implements TFieldIdEnum +/* */ { +/* 54 */ CODE((short)1, "code"), +/* 55 */ MESSAGE((short)2, "message"), +/* 56 */ DETAIL((short)3, "detail"); +/* */ +/* */ private static final Map byName; +/* */ private final short _thriftId; +/* */ private final String _fieldName; +/* */ +/* */ public static _Fields findByThriftId(int fieldId) +/* */ { +/* 70 */ switch (fieldId) { +/* */ case 1: +/* 72 */ return CODE; +/* */ case 2: +/* 74 */ return MESSAGE; +/* */ case 3: +/* 76 */ return DETAIL; +/* */ } +/* 78 */ return null; +/* */ } +/* */ +/* */ public static _Fields findByThriftIdOrThrow(int fieldId) +/* */ { +/* 87 */ _Fields fields = findByThriftId(fieldId); +/* 88 */ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); +/* 89 */ return fields; +/* */ } +/* */ +/* */ public static _Fields findByName(String name) +/* */ { +/* 96 */ return (_Fields)byName.get(name); +/* */ } +/* */ +/* */ private _Fields(short thriftId, String fieldName) +/* */ { +/* 103 */ this._thriftId = thriftId; +/* 104 */ this._fieldName = fieldName; +/* */ } +/* */ +/* */ public short getThriftFieldId() { +/* 108 */ return this._thriftId; +/* */ } +/* */ +/* */ public String getFieldName() { +/* 112 */ return this._fieldName; +/* */ } +/* */ +/* */ static +/* */ { +/* 58 */ byName = new HashMap(); +/* */ +/* 61 */ for (_Fields field : EnumSet.allOf(_Fields.class)) +/* 62 */ byName.put(field.getFieldName(), field); +/* */ } +/* */ } +/* */ } + +/* Location: /Users/johnderr/.m2/repository/com/hp/csbu/cc/CsThriftModel/1.2-SNAPSHOT/CsThriftModel-1.2-20140130.160951-1223.jar + * Qualified Name: com.hp.csbu.cc.security.cs.thrift.service.ResourceException + * JD-Core Version: 0.6.2 + */ \ No newline at end of file diff --git a/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/Role.java b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/Role.java new file mode 100755 index 000000000..16010077c --- /dev/null +++ b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/Role.java @@ -0,0 +1,685 @@ +/* */ package com.hp.csbu.cc.security.cs.thrift.service; +/* */ +/* */ import java.io.IOException; +/* */ import java.io.ObjectInputStream; +/* */ import java.io.ObjectOutputStream; +/* */ import java.io.Serializable; +/* */ import java.util.BitSet; +/* */ import java.util.Collections; +/* */ import java.util.EnumMap; +/* */ import java.util.EnumSet; +/* */ import java.util.HashMap; +/* */ import java.util.Map; +/* */ import org.apache.thrift.TBase; +/* */ import org.apache.thrift.TBaseHelper; +/* */ import org.apache.thrift.TException; +/* */ import org.apache.thrift.TFieldIdEnum; +/* */ import org.apache.thrift.meta_data.FieldMetaData; +/* */ import org.apache.thrift.meta_data.FieldValueMetaData; +/* */ import org.apache.thrift.protocol.TCompactProtocol; +/* */ import org.apache.thrift.protocol.TField; +/* */ import org.apache.thrift.protocol.TProtocol; +/* */ import org.apache.thrift.protocol.TProtocolUtil; +/* */ import org.apache.thrift.protocol.TStruct; +/* */ import org.apache.thrift.protocol.TTupleProtocol; +/* */ import org.apache.thrift.scheme.IScheme; +/* */ import org.apache.thrift.scheme.SchemeFactory; +/* */ import org.apache.thrift.scheme.StandardScheme; +/* */ import org.apache.thrift.scheme.TupleScheme; +/* */ import org.apache.thrift.transport.TIOStreamTransport; +/* */ +/* */ public class Role +/* */ implements TBase, Serializable, Cloneable +/* */ { +/* 34 */ private static final TStruct STRUCT_DESC = new TStruct("Role"); +/* */ +/* 36 */ private static final TField ID_FIELD_DESC = new TField("id", (byte)11, (short)1); +/* 37 */ private static final TField SERVICE_ID_FIELD_DESC = new TField("serviceId", (byte)11, (short)2); +/* 38 */ private static final TField NAME_FIELD_DESC = new TField("name", (byte)11, (short)3); +/* 39 */ private static final TField TENANT_ID_FIELD_DESC = new TField("tenantId", (byte)11, (short)4); +/* */ +/* 41 */ private static final Map, SchemeFactory> schemes = new HashMap(); +/* */ public String id; +/* */ public String serviceId; +/* */ public String name; +/* */ public String tenantId; +/* 120 */ private _Fields[] optionals = { _Fields.SERVICE_ID, _Fields.NAME, _Fields.TENANT_ID }; +/* */ public static final Map<_Fields, FieldMetaData> metaDataMap; +/* */ +/* */ public Role() +/* */ { +/* */ } +/* */ +/* */ public Role(String id) +/* */ { +/* 142 */ this(); +/* 143 */ this.id = id; +/* */ } +/* */ +/* */ public Role(Role other) +/* */ { +/* 150 */ if (other.isSetId()) { +/* 151 */ this.id = other.id; +/* */ } +/* 153 */ if (other.isSetServiceId()) { +/* 154 */ this.serviceId = other.serviceId; +/* */ } +/* 156 */ if (other.isSetName()) { +/* 157 */ this.name = other.name; +/* */ } +/* 159 */ if (other.isSetTenantId()) +/* 160 */ this.tenantId = other.tenantId; +/* */ } +/* */ +/* */ public Role deepCopy() +/* */ { +/* 165 */ return new Role(this); +/* */ } +/* */ +/* */ public void clear() +/* */ { +/* 170 */ this.id = null; +/* 171 */ this.serviceId = null; +/* 172 */ this.name = null; +/* 173 */ this.tenantId = null; +/* */ } +/* */ +/* */ public String getId() { +/* 177 */ return this.id; +/* */ } +/* */ +/* */ public Role setId(String id) { +/* 181 */ this.id = id; +/* 182 */ return this; +/* */ } +/* */ +/* */ public void unsetId() { +/* 186 */ this.id = null; +/* */ } +/* */ +/* */ public boolean isSetId() +/* */ { +/* 191 */ return this.id != null; +/* */ } +/* */ +/* */ public void setIdIsSet(boolean value) { +/* 195 */ if (!value) +/* 196 */ this.id = null; +/* */ } +/* */ +/* */ public String getServiceId() +/* */ { +/* 201 */ return this.serviceId; +/* */ } +/* */ +/* */ public Role setServiceId(String serviceId) { +/* 205 */ this.serviceId = serviceId; +/* 206 */ return this; +/* */ } +/* */ +/* */ public void unsetServiceId() { +/* 210 */ this.serviceId = null; +/* */ } +/* */ +/* */ public boolean isSetServiceId() +/* */ { +/* 215 */ return this.serviceId != null; +/* */ } +/* */ +/* */ public void setServiceIdIsSet(boolean value) { +/* 219 */ if (!value) +/* 220 */ this.serviceId = null; +/* */ } +/* */ +/* */ public String getName() +/* */ { +/* 225 */ return this.name; +/* */ } +/* */ +/* */ public Role setName(String name) { +/* 229 */ this.name = name; +/* 230 */ return this; +/* */ } +/* */ +/* */ public void unsetName() { +/* 234 */ this.name = null; +/* */ } +/* */ +/* */ public boolean isSetName() +/* */ { +/* 239 */ return this.name != null; +/* */ } +/* */ +/* */ public void setNameIsSet(boolean value) { +/* 243 */ if (!value) +/* 244 */ this.name = null; +/* */ } +/* */ +/* */ public String getTenantId() +/* */ { +/* 249 */ return this.tenantId; +/* */ } +/* */ +/* */ public Role setTenantId(String tenantId) { +/* 253 */ this.tenantId = tenantId; +/* 254 */ return this; +/* */ } +/* */ +/* */ public void unsetTenantId() { +/* 258 */ this.tenantId = null; +/* */ } +/* */ +/* */ public boolean isSetTenantId() +/* */ { +/* 263 */ return this.tenantId != null; +/* */ } +/* */ +/* */ public void setTenantIdIsSet(boolean value) { +/* 267 */ if (!value) +/* 268 */ this.tenantId = null; +/* */ } +/* */ +/* */ public void setFieldValue(_Fields field, Object value) +/* */ { +/* 273 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$Role$_Fields[field.ordinal()]) { +/* */ case 1: +/* 275 */ if (value == null) +/* 276 */ unsetId(); +/* */ else { +/* 278 */ setId((String)value); +/* */ } +/* 280 */ break; +/* */ case 2: +/* 283 */ if (value == null) +/* 284 */ unsetServiceId(); +/* */ else { +/* 286 */ setServiceId((String)value); +/* */ } +/* 288 */ break; +/* */ case 3: +/* 291 */ if (value == null) +/* 292 */ unsetName(); +/* */ else { +/* 294 */ setName((String)value); +/* */ } +/* 296 */ break; +/* */ case 4: +/* 299 */ if (value == null) +/* 300 */ unsetTenantId(); +/* */ else +/* 302 */ setTenantId((String)value); +/* */ break; +/* */ } +/* */ } +/* */ +/* */ public Object getFieldValue(_Fields field) +/* */ { +/* 310 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$Role$_Fields[field.ordinal()]) { +/* */ case 1: +/* 312 */ return getId(); +/* */ case 2: +/* 315 */ return getServiceId(); +/* */ case 3: +/* 318 */ return getName(); +/* */ case 4: +/* 321 */ return getTenantId(); +/* */ } +/* */ +/* 324 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean isSet(_Fields field) +/* */ { +/* 329 */ if (field == null) { +/* 330 */ throw new IllegalArgumentException(); +/* */ } +/* */ +/* 333 */ switch (field.ordinal()) { //1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$Role$_Fields[field.ordinal()]) { +/* */ case 1: +/* 335 */ return isSetId(); +/* */ case 2: +/* 337 */ return isSetServiceId(); +/* */ case 3: +/* 339 */ return isSetName(); +/* */ case 4: +/* 341 */ return isSetTenantId(); +/* */ } +/* 343 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean equals(Object that) +/* */ { +/* 348 */ if (that == null) +/* 349 */ return false; +/* 350 */ if ((that instanceof Role)) +/* 351 */ return equals((Role)that); +/* 352 */ return false; +/* */ } +/* */ +/* */ public boolean equals(Role that) { +/* 356 */ if (that == null) { +/* 357 */ return false; +/* */ } +/* 359 */ boolean this_present_id = isSetId(); +/* 360 */ boolean that_present_id = that.isSetId(); +/* 361 */ if ((this_present_id) || (that_present_id)) { +/* 362 */ if ((!this_present_id) || (!that_present_id)) +/* 363 */ return false; +/* 364 */ if (!this.id.equals(that.id)) { +/* 365 */ return false; +/* */ } +/* */ } +/* 368 */ boolean this_present_serviceId = isSetServiceId(); +/* 369 */ boolean that_present_serviceId = that.isSetServiceId(); +/* 370 */ if ((this_present_serviceId) || (that_present_serviceId)) { +/* 371 */ if ((!this_present_serviceId) || (!that_present_serviceId)) +/* 372 */ return false; +/* 373 */ if (!this.serviceId.equals(that.serviceId)) { +/* 374 */ return false; +/* */ } +/* */ } +/* 377 */ boolean this_present_name = isSetName(); +/* 378 */ boolean that_present_name = that.isSetName(); +/* 379 */ if ((this_present_name) || (that_present_name)) { +/* 380 */ if ((!this_present_name) || (!that_present_name)) +/* 381 */ return false; +/* 382 */ if (!this.name.equals(that.name)) { +/* 383 */ return false; +/* */ } +/* */ } +/* 386 */ boolean this_present_tenantId = isSetTenantId(); +/* 387 */ boolean that_present_tenantId = that.isSetTenantId(); +/* 388 */ if ((this_present_tenantId) || (that_present_tenantId)) { +/* 389 */ if ((!this_present_tenantId) || (!that_present_tenantId)) +/* 390 */ return false; +/* 391 */ if (!this.tenantId.equals(that.tenantId)) { +/* 392 */ return false; +/* */ } +/* */ } +/* 395 */ return true; +/* */ } +/* */ +/* */ public int hashCode() +/* */ { +/* 400 */ return 0; +/* */ } +/* */ +/* */ public int compareTo(Role other) { +/* 404 */ if (!getClass().equals(other.getClass())) { +/* 405 */ return getClass().getName().compareTo(other.getClass().getName()); +/* */ } +/* */ +/* 408 */ int lastComparison = 0; +/* 409 */ Role typedOther = other; +/* */ +/* 411 */ lastComparison = Boolean.valueOf(isSetId()).compareTo(Boolean.valueOf(typedOther.isSetId())); +/* 412 */ if (lastComparison != 0) { +/* 413 */ return lastComparison; +/* */ } +/* 415 */ if (isSetId()) { +/* 416 */ lastComparison = TBaseHelper.compareTo(this.id, typedOther.id); +/* 417 */ if (lastComparison != 0) { +/* 418 */ return lastComparison; +/* */ } +/* */ } +/* 421 */ lastComparison = Boolean.valueOf(isSetServiceId()).compareTo(Boolean.valueOf(typedOther.isSetServiceId())); +/* 422 */ if (lastComparison != 0) { +/* 423 */ return lastComparison; +/* */ } +/* 425 */ if (isSetServiceId()) { +/* 426 */ lastComparison = TBaseHelper.compareTo(this.serviceId, typedOther.serviceId); +/* 427 */ if (lastComparison != 0) { +/* 428 */ return lastComparison; +/* */ } +/* */ } +/* 431 */ lastComparison = Boolean.valueOf(isSetName()).compareTo(Boolean.valueOf(typedOther.isSetName())); +/* 432 */ if (lastComparison != 0) { +/* 433 */ return lastComparison; +/* */ } +/* 435 */ if (isSetName()) { +/* 436 */ lastComparison = TBaseHelper.compareTo(this.name, typedOther.name); +/* 437 */ if (lastComparison != 0) { +/* 438 */ return lastComparison; +/* */ } +/* */ } +/* 441 */ lastComparison = Boolean.valueOf(isSetTenantId()).compareTo(Boolean.valueOf(typedOther.isSetTenantId())); +/* 442 */ if (lastComparison != 0) { +/* 443 */ return lastComparison; +/* */ } +/* 445 */ if (isSetTenantId()) { +/* 446 */ lastComparison = TBaseHelper.compareTo(this.tenantId, typedOther.tenantId); +/* 447 */ if (lastComparison != 0) { +/* 448 */ return lastComparison; +/* */ } +/* */ } +/* 451 */ return 0; +/* */ } +/* */ +/* */ public _Fields fieldForId(int fieldId) { +/* 455 */ return _Fields.findByThriftId(fieldId); +/* */ } +/* */ +/* */ public void read(TProtocol iprot) throws TException { +/* 459 */ ((SchemeFactory)schemes.get(iprot.getScheme())).getScheme().read(iprot, this); +/* */ } +/* */ +/* */ public void write(TProtocol oprot) throws TException { +/* 463 */ ((SchemeFactory)schemes.get(oprot.getScheme())).getScheme().write(oprot, this); +/* */ } +/* */ +/* */ public String toString() +/* */ { +/* 468 */ StringBuilder sb = new StringBuilder("Role("); +/* 469 */ boolean first = true; +/* */ +/* 471 */ sb.append("id:"); +/* 472 */ if (this.id == null) +/* 473 */ sb.append("null"); +/* */ else { +/* 475 */ sb.append(this.id); +/* */ } +/* 477 */ first = false; +/* 478 */ if (isSetServiceId()) { +/* 479 */ if (!first) sb.append(", "); +/* 480 */ sb.append("serviceId:"); +/* 481 */ if (this.serviceId == null) +/* 482 */ sb.append("null"); +/* */ else { +/* 484 */ sb.append(this.serviceId); +/* */ } +/* 486 */ first = false; +/* */ } +/* 488 */ if (isSetName()) { +/* 489 */ if (!first) sb.append(", "); +/* 490 */ sb.append("name:"); +/* 491 */ if (this.name == null) +/* 492 */ sb.append("null"); +/* */ else { +/* 494 */ sb.append(this.name); +/* */ } +/* 496 */ first = false; +/* */ } +/* 498 */ if (isSetTenantId()) { +/* 499 */ if (!first) sb.append(", "); +/* 500 */ sb.append("tenantId:"); +/* 501 */ if (this.tenantId == null) +/* 502 */ sb.append("null"); +/* */ else { +/* 504 */ sb.append(this.tenantId); +/* */ } +/* 506 */ first = false; +/* */ } +/* 508 */ sb.append(")"); +/* 509 */ return sb.toString(); +/* */ } +/* */ +/* */ public void validate() throws TException +/* */ { +/* */ } +/* */ +/* */ private void writeObject(ObjectOutputStream out) throws IOException { +/* */ try { +/* 518 */ write(new TCompactProtocol(new TIOStreamTransport(out))); +/* */ } catch (TException te) { +/* 520 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { +/* */ try { +/* 526 */ read(new TCompactProtocol(new TIOStreamTransport(in))); +/* */ } catch (TException te) { +/* 528 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ static +/* */ { +/* 43 */ schemes.put(StandardScheme.class, new RoleStandardSchemeFactory()); +/* 44 */ schemes.put(TupleScheme.class, new RoleTupleSchemeFactory()); +/* */ +/* 123 */ Map tmpMap = new EnumMap(_Fields.class); +/* 124 */ tmpMap.put(_Fields.ID, new FieldMetaData("id", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 126 */ tmpMap.put(_Fields.SERVICE_ID, new FieldMetaData("serviceId", (byte)2, new FieldValueMetaData((byte)11))); +/* */ +/* 128 */ tmpMap.put(_Fields.NAME, new FieldMetaData("name", (byte)2, new FieldValueMetaData((byte)11))); +/* */ +/* 130 */ tmpMap.put(_Fields.TENANT_ID, new FieldMetaData("tenantId", (byte)2, new FieldValueMetaData((byte)11))); +/* */ +/* 132 */ metaDataMap = Collections.unmodifiableMap(tmpMap); +/* 133 */ FieldMetaData.addStructMetaDataMap(Role.class, metaDataMap); +/* */ } +/* */ +/* */ private static class RoleTupleScheme extends TupleScheme +/* */ { +/* */ public void write(TProtocol prot, Role struct) +/* */ throws TException +/* */ { +/* 639 */ TTupleProtocol oprot = (TTupleProtocol)prot; +/* 640 */ BitSet optionals = new BitSet(); +/* 641 */ if (struct.isSetId()) { +/* 642 */ optionals.set(0); +/* */ } +/* 644 */ if (struct.isSetServiceId()) { +/* 645 */ optionals.set(1); +/* */ } +/* 647 */ if (struct.isSetName()) { +/* 648 */ optionals.set(2); +/* */ } +/* 650 */ if (struct.isSetTenantId()) { +/* 651 */ optionals.set(3); +/* */ } +/* 653 */ oprot.writeBitSet(optionals, 4); +/* 654 */ if (struct.isSetId()) { +/* 655 */ oprot.writeString(struct.id); +/* */ } +/* 657 */ if (struct.isSetServiceId()) { +/* 658 */ oprot.writeString(struct.serviceId); +/* */ } +/* 660 */ if (struct.isSetName()) { +/* 661 */ oprot.writeString(struct.name); +/* */ } +/* 663 */ if (struct.isSetTenantId()) +/* 664 */ oprot.writeString(struct.tenantId); +/* */ } +/* */ +/* */ public void read(TProtocol prot, Role struct) +/* */ throws TException +/* */ { +/* 670 */ TTupleProtocol iprot = (TTupleProtocol)prot; +/* 671 */ BitSet incoming = iprot.readBitSet(4); +/* 672 */ if (incoming.get(0)) { +/* 673 */ struct.id = iprot.readString(); +/* 674 */ struct.setIdIsSet(true); +/* */ } +/* 676 */ if (incoming.get(1)) { +/* 677 */ struct.serviceId = iprot.readString(); +/* 678 */ struct.setServiceIdIsSet(true); +/* */ } +/* 680 */ if (incoming.get(2)) { +/* 681 */ struct.name = iprot.readString(); +/* 682 */ struct.setNameIsSet(true); +/* */ } +/* 684 */ if (incoming.get(3)) { +/* 685 */ struct.tenantId = iprot.readString(); +/* 686 */ struct.setTenantIdIsSet(true); +/* */ } +/* */ } +/* */ } +/* */ +/* */ private static class RoleTupleSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public Role.RoleTupleScheme getScheme() +/* */ { +/* 631 */ return new Role.RoleTupleScheme(); +/* */ } +/* */ } +/* */ +/* */ private static class RoleStandardScheme extends StandardScheme +/* */ { +/* */ public void read(TProtocol iprot, Role struct) +/* */ throws TException +/* */ { +/* 542 */ iprot.readStructBegin(); +/* */ while (true) +/* */ { +/* 545 */ TField schemeField = iprot.readFieldBegin(); +/* 546 */ if (schemeField.type == 0) { +/* */ break; +/* */ } +/* 549 */ switch (schemeField.id) { +/* */ case 1: +/* 551 */ if (schemeField.type == 11) { +/* 552 */ struct.id = iprot.readString(); +/* 553 */ struct.setIdIsSet(true); +/* */ } else { +/* 555 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 557 */ break; +/* */ case 2: +/* 559 */ if (schemeField.type == 11) { +/* 560 */ struct.serviceId = iprot.readString(); +/* 561 */ struct.setServiceIdIsSet(true); +/* */ } else { +/* 563 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 565 */ break; +/* */ case 3: +/* 567 */ if (schemeField.type == 11) { +/* 568 */ struct.name = iprot.readString(); +/* 569 */ struct.setNameIsSet(true); +/* */ } else { +/* 571 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 573 */ break; +/* */ case 4: +/* 575 */ if (schemeField.type == 11) { +/* 576 */ struct.tenantId = iprot.readString(); +/* 577 */ struct.setTenantIdIsSet(true); +/* */ } else { +/* 579 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 581 */ break; +/* */ default: +/* 583 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 585 */ iprot.readFieldEnd(); +/* */ } +/* 587 */ iprot.readStructEnd(); +/* */ +/* 590 */ struct.validate(); +/* */ } +/* */ +/* */ public void write(TProtocol oprot, Role struct) throws TException { +/* 594 */ struct.validate(); +/* */ +/* 596 */ oprot.writeStructBegin(Role.STRUCT_DESC); +/* 597 */ if (struct.id != null) { +/* 598 */ oprot.writeFieldBegin(Role.ID_FIELD_DESC); +/* 599 */ oprot.writeString(struct.id); +/* 600 */ oprot.writeFieldEnd(); +/* */ } +/* 602 */ if ((struct.serviceId != null) && +/* 603 */ (struct.isSetServiceId())) { +/* 604 */ oprot.writeFieldBegin(Role.SERVICE_ID_FIELD_DESC); +/* 605 */ oprot.writeString(struct.serviceId); +/* 606 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 609 */ if ((struct.name != null) && +/* 610 */ (struct.isSetName())) { +/* 611 */ oprot.writeFieldBegin(Role.NAME_FIELD_DESC); +/* 612 */ oprot.writeString(struct.name); +/* 613 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 616 */ if ((struct.tenantId != null) && +/* 617 */ (struct.isSetTenantId())) { +/* 618 */ oprot.writeFieldBegin(Role.TENANT_ID_FIELD_DESC); +/* 619 */ oprot.writeString(struct.tenantId); +/* 620 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 623 */ oprot.writeFieldStop(); +/* 624 */ oprot.writeStructEnd(); +/* */ } +/* */ } +/* */ +/* */ private static class RoleStandardSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public Role.RoleStandardScheme getScheme() +/* */ { +/* 534 */ return new Role.RoleStandardScheme(); +/* */ } +/* */ } +/* */ +/* */ public static enum _Fields +/* */ implements TFieldIdEnum +/* */ { +/* 54 */ ID((short)1, "id"), +/* 55 */ SERVICE_ID((short)2, "serviceId"), +/* 56 */ NAME((short)3, "name"), +/* 57 */ TENANT_ID((short)4, "tenantId"); +/* */ +/* */ private static final Map byName; +/* */ private final short _thriftId; +/* */ private final String _fieldName; +/* */ +/* */ public static _Fields findByThriftId(int fieldId) +/* */ { +/* 71 */ switch (fieldId) { +/* */ case 1: +/* 73 */ return ID; +/* */ case 2: +/* 75 */ return SERVICE_ID; +/* */ case 3: +/* 77 */ return NAME; +/* */ case 4: +/* 79 */ return TENANT_ID; +/* */ } +/* 81 */ return null; +/* */ } +/* */ +/* */ public static _Fields findByThriftIdOrThrow(int fieldId) +/* */ { +/* 90 */ _Fields fields = findByThriftId(fieldId); +/* 91 */ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); +/* 92 */ return fields; +/* */ } +/* */ +/* */ public static _Fields findByName(String name) +/* */ { +/* 99 */ return (_Fields)byName.get(name); +/* */ } +/* */ +/* */ private _Fields(short thriftId, String fieldName) +/* */ { +/* 106 */ this._thriftId = thriftId; +/* 107 */ this._fieldName = fieldName; +/* */ } +/* */ +/* */ public short getThriftFieldId() { +/* 111 */ return this._thriftId; +/* */ } +/* */ +/* */ public String getFieldName() { +/* 115 */ return this._fieldName; +/* */ } +/* */ +/* */ static +/* */ { +/* 59 */ byName = new HashMap(); +/* */ +/* 62 */ for (_Fields field : EnumSet.allOf(_Fields.class)) +/* 63 */ byName.put(field.getFieldName(), field); +/* */ } +/* */ } +/* */ } + +/* Location: /Users/johnderr/.m2/repository/com/hp/csbu/cc/CsThriftModel/1.2-SNAPSHOT/CsThriftModel-1.2-20140130.160951-1223.jar + * Qualified Name: com.hp.csbu.cc.security.cs.thrift.service.Role + * JD-Core Version: 0.6.2 + */ \ No newline at end of file diff --git a/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/SigAuthRequest.java b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/SigAuthRequest.java new file mode 100755 index 000000000..fccdf8a92 --- /dev/null +++ b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/SigAuthRequest.java @@ -0,0 +1,544 @@ +/* */ package com.hp.csbu.cc.security.cs.thrift.service; +/* */ +/* */ import java.io.IOException; +/* */ import java.io.ObjectInputStream; +/* */ import java.io.ObjectOutputStream; +/* */ import java.io.Serializable; +/* */ import java.util.BitSet; +/* */ import java.util.Collections; +/* */ import java.util.EnumMap; +/* */ import java.util.EnumSet; +/* */ import java.util.HashMap; +/* */ import java.util.Map; +/* */ import java.util.Map.Entry; +/* */ import org.apache.thrift.TBase; +/* */ import org.apache.thrift.TBaseHelper; +/* */ import org.apache.thrift.TException; +/* */ import org.apache.thrift.TFieldIdEnum; +/* */ import org.apache.thrift.meta_data.FieldMetaData; +/* */ import org.apache.thrift.meta_data.FieldValueMetaData; +/* */ import org.apache.thrift.meta_data.MapMetaData; +/* */ import org.apache.thrift.meta_data.StructMetaData; +/* */ import org.apache.thrift.protocol.TCompactProtocol; +/* */ import org.apache.thrift.protocol.TField; +/* */ import org.apache.thrift.protocol.TMap; +/* */ import org.apache.thrift.protocol.TProtocol; +/* */ import org.apache.thrift.protocol.TProtocolUtil; +/* */ import org.apache.thrift.protocol.TStruct; +/* */ import org.apache.thrift.protocol.TTupleProtocol; +/* */ import org.apache.thrift.scheme.IScheme; +/* */ import org.apache.thrift.scheme.SchemeFactory; +/* */ import org.apache.thrift.scheme.StandardScheme; +/* */ import org.apache.thrift.scheme.TupleScheme; +/* */ import org.apache.thrift.transport.TIOStreamTransport; +/* */ +/* */ public class SigAuthRequest +/* */ implements TBase, Serializable, Cloneable +/* */ { +/* 34 */ private static final TStruct STRUCT_DESC = new TStruct("SigAuthRequest"); +/* */ +/* 36 */ private static final TField CREDENTIALS_FIELD_DESC = new TField("credentials", (byte)12, (short)1); +/* 37 */ private static final TField PARAMS_FIELD_DESC = new TField("params", (byte)13, (short)2); +/* */ +/* 39 */ private static final Map, SchemeFactory> schemes = new HashMap(); +/* */ public SignatureCredentials credentials; +/* */ public Map params; +/* */ public static final Map<_Fields, FieldMetaData> metaDataMap; +/* */ +/* */ public SigAuthRequest() +/* */ { +/* */ } +/* */ +/* */ public SigAuthRequest(SignatureCredentials credentials, Map params) +/* */ { +/* 130 */ this(); +/* 131 */ this.credentials = credentials; +/* 132 */ this.params = params; +/* */ } +/* */ +/* */ public SigAuthRequest(SigAuthRequest other) +/* */ { +/* 139 */ if (other.isSetCredentials()) { +/* 140 */ this.credentials = new SignatureCredentials(other.credentials); +/* */ } +/* 142 */ if (other.isSetParams()) { +/* 143 */ Map __this__params = new HashMap(); +/* 144 */ for (Map.Entry other_element : other.params.entrySet()) +/* */ { +/* 146 */ String other_element_key = (String)other_element.getKey(); +/* 147 */ String other_element_value = (String)other_element.getValue(); +/* */ +/* 149 */ String __this__params_copy_key = other_element_key; +/* */ +/* 151 */ String __this__params_copy_value = other_element_value; +/* */ +/* 153 */ __this__params.put(__this__params_copy_key, __this__params_copy_value); +/* */ } +/* 155 */ this.params = __this__params; +/* */ } +/* */ } +/* */ +/* */ public SigAuthRequest deepCopy() { +/* 160 */ return new SigAuthRequest(this); +/* */ } +/* */ +/* */ public void clear() +/* */ { +/* 165 */ this.credentials = null; +/* 166 */ this.params = null; +/* */ } +/* */ +/* */ public SignatureCredentials getCredentials() { +/* 170 */ return this.credentials; +/* */ } +/* */ +/* */ public SigAuthRequest setCredentials(SignatureCredentials credentials) { +/* 174 */ this.credentials = credentials; +/* 175 */ return this; +/* */ } +/* */ +/* */ public void unsetCredentials() { +/* 179 */ this.credentials = null; +/* */ } +/* */ +/* */ public boolean isSetCredentials() +/* */ { +/* 184 */ return this.credentials != null; +/* */ } +/* */ +/* */ public void setCredentialsIsSet(boolean value) { +/* 188 */ if (!value) +/* 189 */ this.credentials = null; +/* */ } +/* */ +/* */ public int getParamsSize() +/* */ { +/* 194 */ return this.params == null ? 0 : this.params.size(); +/* */ } +/* */ +/* */ public void putToParams(String key, String val) { +/* 198 */ if (this.params == null) { +/* 199 */ this.params = new HashMap(); +/* */ } +/* 201 */ this.params.put(key, val); +/* */ } +/* */ +/* */ public Map getParams() { +/* 205 */ return this.params; +/* */ } +/* */ +/* */ public SigAuthRequest setParams(Map params) { +/* 209 */ this.params = params; +/* 210 */ return this; +/* */ } +/* */ +/* */ public void unsetParams() { +/* 214 */ this.params = null; +/* */ } +/* */ +/* */ public boolean isSetParams() +/* */ { +/* 219 */ return this.params != null; +/* */ } +/* */ +/* */ public void setParamsIsSet(boolean value) { +/* 223 */ if (!value) +/* 224 */ this.params = null; +/* */ } +/* */ +/* */ public void setFieldValue(_Fields field, Object value) +/* */ { +/* 229 */ switch (field.ordinal()) { //1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$SigAuthRequest$_Fields[field.ordinal()]) { +/* */ case 1: +/* 231 */ if (value == null) +/* 232 */ unsetCredentials(); +/* */ else { +/* 234 */ setCredentials((SignatureCredentials)value); +/* */ } +/* 236 */ break; +/* */ case 2: +/* 239 */ if (value == null) +/* 240 */ unsetParams(); +/* */ else +/* 242 */ setParams((Map)value); +/* */ break; +/* */ } +/* */ } +/* */ +/* */ public Object getFieldValue(_Fields field) +/* */ { +/* 250 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$SigAuthRequest$_Fields[field.ordinal()]) { +/* */ case 1: +/* 252 */ return getCredentials(); +/* */ case 2: +/* 255 */ return getParams(); +/* */ } +/* */ +/* 258 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean isSet(_Fields field) +/* */ { +/* 263 */ if (field == null) { +/* 264 */ throw new IllegalArgumentException(); +/* */ } +/* */ +/* 267 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$SigAuthRequest$_Fields[field.ordinal()]) { +/* */ case 1: +/* 269 */ return isSetCredentials(); +/* */ case 2: +/* 271 */ return isSetParams(); +/* */ } +/* 273 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean equals(Object that) +/* */ { +/* 278 */ if (that == null) +/* 279 */ return false; +/* 280 */ if ((that instanceof SigAuthRequest)) +/* 281 */ return equals((SigAuthRequest)that); +/* 282 */ return false; +/* */ } +/* */ +/* */ public boolean equals(SigAuthRequest that) { +/* 286 */ if (that == null) { +/* 287 */ return false; +/* */ } +/* 289 */ boolean this_present_credentials = isSetCredentials(); +/* 290 */ boolean that_present_credentials = that.isSetCredentials(); +/* 291 */ if ((this_present_credentials) || (that_present_credentials)) { +/* 292 */ if ((!this_present_credentials) || (!that_present_credentials)) +/* 293 */ return false; +/* 294 */ if (!this.credentials.equals(that.credentials)) { +/* 295 */ return false; +/* */ } +/* */ } +/* 298 */ boolean this_present_params = isSetParams(); +/* 299 */ boolean that_present_params = that.isSetParams(); +/* 300 */ if ((this_present_params) || (that_present_params)) { +/* 301 */ if ((!this_present_params) || (!that_present_params)) +/* 302 */ return false; +/* 303 */ if (!this.params.equals(that.params)) { +/* 304 */ return false; +/* */ } +/* */ } +/* 307 */ return true; +/* */ } +/* */ +/* */ public int hashCode() +/* */ { +/* 312 */ return 0; +/* */ } +/* */ +/* */ public int compareTo(SigAuthRequest other) { +/* 316 */ if (!getClass().equals(other.getClass())) { +/* 317 */ return getClass().getName().compareTo(other.getClass().getName()); +/* */ } +/* */ +/* 320 */ int lastComparison = 0; +/* 321 */ SigAuthRequest typedOther = other; +/* */ +/* 323 */ lastComparison = Boolean.valueOf(isSetCredentials()).compareTo(Boolean.valueOf(typedOther.isSetCredentials())); +/* 324 */ if (lastComparison != 0) { +/* 325 */ return lastComparison; +/* */ } +/* 327 */ if (isSetCredentials()) { +/* 328 */ lastComparison = TBaseHelper.compareTo(this.credentials, typedOther.credentials); +/* 329 */ if (lastComparison != 0) { +/* 330 */ return lastComparison; +/* */ } +/* */ } +/* 333 */ lastComparison = Boolean.valueOf(isSetParams()).compareTo(Boolean.valueOf(typedOther.isSetParams())); +/* 334 */ if (lastComparison != 0) { +/* 335 */ return lastComparison; +/* */ } +/* 337 */ if (isSetParams()) { +/* 338 */ lastComparison = TBaseHelper.compareTo(this.params, typedOther.params); +/* 339 */ if (lastComparison != 0) { +/* 340 */ return lastComparison; +/* */ } +/* */ } +/* 343 */ return 0; +/* */ } +/* */ +/* */ public _Fields fieldForId(int fieldId) { +/* 347 */ return _Fields.findByThriftId(fieldId); +/* */ } +/* */ +/* */ public void read(TProtocol iprot) throws TException { +/* 351 */ ((SchemeFactory)schemes.get(iprot.getScheme())).getScheme().read(iprot, this); +/* */ } +/* */ +/* */ public void write(TProtocol oprot) throws TException { +/* 355 */ ((SchemeFactory)schemes.get(oprot.getScheme())).getScheme().write(oprot, this); +/* */ } +/* */ +/* */ public String toString() +/* */ { +/* 360 */ StringBuilder sb = new StringBuilder("SigAuthRequest("); +/* 361 */ boolean first = true; +/* */ +/* 363 */ sb.append("credentials:"); +/* 364 */ if (this.credentials == null) +/* 365 */ sb.append("null"); +/* */ else { +/* 367 */ sb.append(this.credentials); +/* */ } +/* 369 */ first = false; +/* 370 */ if (!first) sb.append(", "); +/* 371 */ sb.append("params:"); +/* 372 */ if (this.params == null) +/* 373 */ sb.append("null"); +/* */ else { +/* 375 */ sb.append(this.params); +/* */ } +/* 377 */ first = false; +/* 378 */ sb.append(")"); +/* 379 */ return sb.toString(); +/* */ } +/* */ +/* */ public void validate() throws TException +/* */ { +/* */ } +/* */ +/* */ private void writeObject(ObjectOutputStream out) throws IOException { +/* */ try { +/* 388 */ write(new TCompactProtocol(new TIOStreamTransport(out))); +/* */ } catch (TException te) { +/* 390 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { +/* */ try { +/* 396 */ read(new TCompactProtocol(new TIOStreamTransport(in))); +/* */ } catch (TException te) { +/* 398 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ static +/* */ { +/* 41 */ schemes.put(StandardScheme.class, new SigAuthRequestStandardSchemeFactory()); +/* 42 */ schemes.put(TupleScheme.class, new SigAuthRequestTupleSchemeFactory()); +/* */ +/* 112 */ Map tmpMap = new EnumMap(_Fields.class); +/* 113 */ tmpMap.put(_Fields.CREDENTIALS, new FieldMetaData("credentials", (byte)3, new StructMetaData((byte)12, SignatureCredentials.class))); +/* */ +/* 115 */ tmpMap.put(_Fields.PARAMS, new FieldMetaData("params", (byte)3, new MapMetaData((byte)13, new FieldValueMetaData((byte)11), new FieldValueMetaData((byte)11)))); +/* */ +/* 119 */ metaDataMap = Collections.unmodifiableMap(tmpMap); +/* 120 */ FieldMetaData.addStructMetaDataMap(SigAuthRequest.class, metaDataMap); +/* */ } +/* */ +/* */ private static class SigAuthRequestTupleScheme extends TupleScheme +/* */ { +/* */ public void write(TProtocol prot, SigAuthRequest struct) +/* */ throws TException +/* */ { +/* 498 */ TTupleProtocol oprot = (TTupleProtocol)prot; +/* 499 */ BitSet optionals = new BitSet(); +/* 500 */ if (struct.isSetCredentials()) { +/* 501 */ optionals.set(0); +/* */ } +/* 503 */ if (struct.isSetParams()) { +/* 504 */ optionals.set(1); +/* */ } +/* 506 */ oprot.writeBitSet(optionals, 2); +/* 507 */ if (struct.isSetCredentials()) { +/* 508 */ struct.credentials.write(oprot); +/* */ } +/* 510 */ if (struct.isSetParams()) +/* */ { +/* 512 */ oprot.writeI32(struct.params.size()); +/* 513 */ for (Map.Entry _iter13 : struct.params.entrySet()) +/* */ { +/* 515 */ oprot.writeString((String)_iter13.getKey()); +/* 516 */ oprot.writeString((String)_iter13.getValue()); +/* */ } +/* */ } +/* */ } +/* */ +/* */ public void read(TProtocol prot, SigAuthRequest struct) +/* */ throws TException +/* */ { +/* 524 */ TTupleProtocol iprot = (TTupleProtocol)prot; +/* 525 */ BitSet incoming = iprot.readBitSet(2); +/* 526 */ if (incoming.get(0)) { +/* 527 */ struct.credentials = new SignatureCredentials(); +/* 528 */ struct.credentials.read(iprot); +/* 529 */ struct.setCredentialsIsSet(true); +/* */ } +/* 531 */ if (incoming.get(1)) +/* */ { +/* 533 */ TMap _map14 = new TMap((byte)11, (byte)11, iprot.readI32()); +/* 534 */ struct.params = new HashMap(2 * _map14.size); +/* 535 */ for (int _i15 = 0; _i15 < _map14.size; _i15++) +/* */ { +/* 539 */ String _key16 = iprot.readString(); +/* 540 */ String _val17 = iprot.readString(); +/* 541 */ struct.params.put(_key16, _val17); +/* */ } +/* */ +/* 544 */ struct.setParamsIsSet(true); +/* */ } +/* */ } +/* */ } +/* */ +/* */ private static class SigAuthRequestTupleSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public SigAuthRequest.SigAuthRequestTupleScheme getScheme() +/* */ { +/* 490 */ return new SigAuthRequest.SigAuthRequestTupleScheme(); +/* */ } +/* */ } +/* */ +/* */ private static class SigAuthRequestStandardScheme extends StandardScheme +/* */ { +/* */ public void read(TProtocol iprot, SigAuthRequest struct) +/* */ throws TException +/* */ { +/* 412 */ iprot.readStructBegin(); +/* */ while (true) +/* */ { +/* 415 */ TField schemeField = iprot.readFieldBegin(); +/* 416 */ if (schemeField.type == 0) { +/* */ break; +/* */ } +/* 419 */ switch (schemeField.id) { +/* */ case 1: +/* 421 */ if (schemeField.type == 12) { +/* 422 */ struct.credentials = new SignatureCredentials(); +/* 423 */ struct.credentials.read(iprot); +/* 424 */ struct.setCredentialsIsSet(true); +/* */ } else { +/* 426 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 428 */ break; +/* */ case 2: +/* 430 */ if (schemeField.type == 13) +/* */ { +/* 432 */ TMap _map8 = iprot.readMapBegin(); +/* 433 */ struct.params = new HashMap(2 * _map8.size); +/* 434 */ for (int _i9 = 0; _i9 < _map8.size; _i9++) +/* */ { +/* 438 */ String _key10 = iprot.readString(); +/* 439 */ String _val11 = iprot.readString(); +/* 440 */ struct.params.put(_key10, _val11); +/* */ } +/* 442 */ iprot.readMapEnd(); +/* */ +/* 444 */ struct.setParamsIsSet(true); +/* */ } else { +/* 446 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 448 */ break; +/* */ default: +/* 450 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 452 */ iprot.readFieldEnd(); +/* */ } +/* 454 */ iprot.readStructEnd(); +/* */ +/* 457 */ struct.validate(); +/* */ } +/* */ +/* */ public void write(TProtocol oprot, SigAuthRequest struct) throws TException { +/* 461 */ struct.validate(); +/* */ +/* 463 */ oprot.writeStructBegin(SigAuthRequest.STRUCT_DESC); +/* 464 */ if (struct.credentials != null) { +/* 465 */ oprot.writeFieldBegin(SigAuthRequest.CREDENTIALS_FIELD_DESC); +/* 466 */ struct.credentials.write(oprot); +/* 467 */ oprot.writeFieldEnd(); +/* */ } +/* 469 */ if (struct.params != null) { +/* 470 */ oprot.writeFieldBegin(SigAuthRequest.PARAMS_FIELD_DESC); +/* */ +/* 472 */ oprot.writeMapBegin(new TMap((byte)11, (byte)11, struct.params.size())); +/* 473 */ for (Map.Entry _iter12 : struct.params.entrySet()) +/* */ { +/* 475 */ oprot.writeString((String)_iter12.getKey()); +/* 476 */ oprot.writeString((String)_iter12.getValue()); +/* */ } +/* 478 */ oprot.writeMapEnd(); +/* */ +/* 480 */ oprot.writeFieldEnd(); +/* */ } +/* 482 */ oprot.writeFieldStop(); +/* 483 */ oprot.writeStructEnd(); +/* */ } +/* */ } +/* */ +/* */ private static class SigAuthRequestStandardSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public SigAuthRequest.SigAuthRequestStandardScheme getScheme() +/* */ { +/* 404 */ return new SigAuthRequest.SigAuthRequestStandardScheme(); +/* */ } +/* */ } +/* */ +/* */ public static enum _Fields +/* */ implements TFieldIdEnum +/* */ { +/* 50 */ CREDENTIALS((short)1, "credentials"), +/* 51 */ PARAMS((short)2, "params"); +/* */ +/* */ private static final Map byName; +/* */ private final short _thriftId; +/* */ private final String _fieldName; +/* */ +/* */ public static _Fields findByThriftId(int fieldId) +/* */ { +/* 65 */ switch (fieldId) { +/* */ case 1: +/* 67 */ return CREDENTIALS; +/* */ case 2: +/* 69 */ return PARAMS; +/* */ } +/* 71 */ return null; +/* */ } +/* */ +/* */ public static _Fields findByThriftIdOrThrow(int fieldId) +/* */ { +/* 80 */ _Fields fields = findByThriftId(fieldId); +/* 81 */ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); +/* 82 */ return fields; +/* */ } +/* */ +/* */ public static _Fields findByName(String name) +/* */ { +/* 89 */ return (_Fields)byName.get(name); +/* */ } +/* */ +/* */ private _Fields(short thriftId, String fieldName) +/* */ { +/* 96 */ this._thriftId = thriftId; +/* 97 */ this._fieldName = fieldName; +/* */ } +/* */ +/* */ public short getThriftFieldId() { +/* 101 */ return this._thriftId; +/* */ } +/* */ +/* */ public String getFieldName() { +/* 105 */ return this._fieldName; +/* */ } +/* */ +/* */ static +/* */ { +/* 53 */ byName = new HashMap(); +/* */ +/* 56 */ for (_Fields field : EnumSet.allOf(_Fields.class)) +/* 57 */ byName.put(field.getFieldName(), field); +/* */ } +/* */ } +/* */ } + +/* Location: /Users/johnderr/.m2/repository/com/hp/csbu/cc/CsThriftModel/1.2-SNAPSHOT/CsThriftModel-1.2-20140130.160951-1223.jar + * Qualified Name: com.hp.csbu.cc.security.cs.thrift.service.SigAuthRequest + * JD-Core Version: 0.6.2 + */ \ No newline at end of file diff --git a/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/SignatureCredentials.java b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/SignatureCredentials.java new file mode 100755 index 000000000..1aa7042e0 --- /dev/null +++ b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/SignatureCredentials.java @@ -0,0 +1,772 @@ +/* */ package com.hp.csbu.cc.security.cs.thrift.service; +/* */ +/* */ import java.io.IOException; +/* */ import java.io.ObjectInputStream; +/* */ import java.io.ObjectOutputStream; +/* */ import java.io.Serializable; +/* */ import java.util.BitSet; +/* */ import java.util.Collections; +/* */ import java.util.EnumMap; +/* */ import java.util.EnumSet; +/* */ import java.util.HashMap; +/* */ import java.util.Map; +/* */ import org.apache.thrift.TBase; +/* */ import org.apache.thrift.TBaseHelper; +/* */ import org.apache.thrift.TException; +/* */ import org.apache.thrift.TFieldIdEnum; +/* */ import org.apache.thrift.meta_data.FieldMetaData; +/* */ import org.apache.thrift.meta_data.FieldValueMetaData; +/* */ import org.apache.thrift.protocol.TCompactProtocol; +/* */ import org.apache.thrift.protocol.TField; +/* */ import org.apache.thrift.protocol.TProtocol; +/* */ import org.apache.thrift.protocol.TProtocolUtil; +/* */ import org.apache.thrift.protocol.TStruct; +/* */ import org.apache.thrift.protocol.TTupleProtocol; +/* */ import org.apache.thrift.scheme.IScheme; +/* */ import org.apache.thrift.scheme.SchemeFactory; +/* */ import org.apache.thrift.scheme.StandardScheme; +/* */ import org.apache.thrift.scheme.TupleScheme; +/* */ import org.apache.thrift.transport.TIOStreamTransport; +/* */ +/* */ public class SignatureCredentials +/* */ implements TBase, Serializable, Cloneable +/* */ { +/* 34 */ private static final TStruct STRUCT_DESC = new TStruct("SignatureCredentials"); +/* */ +/* 36 */ private static final TField KEY_ID_FIELD_DESC = new TField("keyId", (byte)11, (short)1); +/* 37 */ private static final TField KEY_TYPE_FIELD_DESC = new TField("keyType", (byte)11, (short)2); +/* 38 */ private static final TField SIGNATURE_METHOD_FIELD_DESC = new TField("signatureMethod", (byte)11, (short)3); +/* 39 */ private static final TField DATA_TO_SIGN_FIELD_DESC = new TField("dataToSign", (byte)11, (short)4); +/* 40 */ private static final TField SIGNATURE_FIELD_DESC = new TField("signature", (byte)11, (short)5); +/* */ +/* 42 */ private static final Map, SchemeFactory> schemes = new HashMap(); +/* */ public String keyId; +/* */ public String keyType; +/* */ public String signatureMethod; +/* */ public String dataToSign; +/* */ public String signature; +/* */ public static final Map<_Fields, FieldMetaData> metaDataMap; +/* */ +/* */ public SignatureCredentials() +/* */ { +/* */ } +/* */ +/* */ public SignatureCredentials(String keyId, String keyType, String signatureMethod, String dataToSign, String signature) +/* */ { +/* 152 */ this(); +/* 153 */ this.keyId = keyId; +/* 154 */ this.keyType = keyType; +/* 155 */ this.signatureMethod = signatureMethod; +/* 156 */ this.dataToSign = dataToSign; +/* 157 */ this.signature = signature; +/* */ } +/* */ +/* */ public SignatureCredentials(SignatureCredentials other) +/* */ { +/* 164 */ if (other.isSetKeyId()) { +/* 165 */ this.keyId = other.keyId; +/* */ } +/* 167 */ if (other.isSetKeyType()) { +/* 168 */ this.keyType = other.keyType; +/* */ } +/* 170 */ if (other.isSetSignatureMethod()) { +/* 171 */ this.signatureMethod = other.signatureMethod; +/* */ } +/* 173 */ if (other.isSetDataToSign()) { +/* 174 */ this.dataToSign = other.dataToSign; +/* */ } +/* 176 */ if (other.isSetSignature()) +/* 177 */ this.signature = other.signature; +/* */ } +/* */ +/* */ public SignatureCredentials deepCopy() +/* */ { +/* 182 */ return new SignatureCredentials(this); +/* */ } +/* */ +/* */ public void clear() +/* */ { +/* 187 */ this.keyId = null; +/* 188 */ this.keyType = null; +/* 189 */ this.signatureMethod = null; +/* 190 */ this.dataToSign = null; +/* 191 */ this.signature = null; +/* */ } +/* */ +/* */ public String getKeyId() { +/* 195 */ return this.keyId; +/* */ } +/* */ +/* */ public SignatureCredentials setKeyId(String keyId) { +/* 199 */ this.keyId = keyId; +/* 200 */ return this; +/* */ } +/* */ +/* */ public void unsetKeyId() { +/* 204 */ this.keyId = null; +/* */ } +/* */ +/* */ public boolean isSetKeyId() +/* */ { +/* 209 */ return this.keyId != null; +/* */ } +/* */ +/* */ public void setKeyIdIsSet(boolean value) { +/* 213 */ if (!value) +/* 214 */ this.keyId = null; +/* */ } +/* */ +/* */ public String getKeyType() +/* */ { +/* 219 */ return this.keyType; +/* */ } +/* */ +/* */ public SignatureCredentials setKeyType(String keyType) { +/* 223 */ this.keyType = keyType; +/* 224 */ return this; +/* */ } +/* */ +/* */ public void unsetKeyType() { +/* 228 */ this.keyType = null; +/* */ } +/* */ +/* */ public boolean isSetKeyType() +/* */ { +/* 233 */ return this.keyType != null; +/* */ } +/* */ +/* */ public void setKeyTypeIsSet(boolean value) { +/* 237 */ if (!value) +/* 238 */ this.keyType = null; +/* */ } +/* */ +/* */ public String getSignatureMethod() +/* */ { +/* 243 */ return this.signatureMethod; +/* */ } +/* */ +/* */ public SignatureCredentials setSignatureMethod(String signatureMethod) { +/* 247 */ this.signatureMethod = signatureMethod; +/* 248 */ return this; +/* */ } +/* */ +/* */ public void unsetSignatureMethod() { +/* 252 */ this.signatureMethod = null; +/* */ } +/* */ +/* */ public boolean isSetSignatureMethod() +/* */ { +/* 257 */ return this.signatureMethod != null; +/* */ } +/* */ +/* */ public void setSignatureMethodIsSet(boolean value) { +/* 261 */ if (!value) +/* 262 */ this.signatureMethod = null; +/* */ } +/* */ +/* */ public String getDataToSign() +/* */ { +/* 267 */ return this.dataToSign; +/* */ } +/* */ +/* */ public SignatureCredentials setDataToSign(String dataToSign) { +/* 271 */ this.dataToSign = dataToSign; +/* 272 */ return this; +/* */ } +/* */ +/* */ public void unsetDataToSign() { +/* 276 */ this.dataToSign = null; +/* */ } +/* */ +/* */ public boolean isSetDataToSign() +/* */ { +/* 281 */ return this.dataToSign != null; +/* */ } +/* */ +/* */ public void setDataToSignIsSet(boolean value) { +/* 285 */ if (!value) +/* 286 */ this.dataToSign = null; +/* */ } +/* */ +/* */ public String getSignature() +/* */ { +/* 291 */ return this.signature; +/* */ } +/* */ +/* */ public SignatureCredentials setSignature(String signature) { +/* 295 */ this.signature = signature; +/* 296 */ return this; +/* */ } +/* */ +/* */ public void unsetSignature() { +/* 300 */ this.signature = null; +/* */ } +/* */ +/* */ public boolean isSetSignature() +/* */ { +/* 305 */ return this.signature != null; +/* */ } +/* */ +/* */ public void setSignatureIsSet(boolean value) { +/* 309 */ if (!value) +/* 310 */ this.signature = null; +/* */ } +/* */ +/* */ public void setFieldValue(_Fields field, Object value) +/* */ { +/* 315 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$SignatureCredentials$_Fields[field.ordinal()]) { +/* */ case 1: +/* 317 */ if (value == null) +/* 318 */ unsetKeyId(); +/* */ else { +/* 320 */ setKeyId((String)value); +/* */ } +/* 322 */ break; +/* */ case 2: +/* 325 */ if (value == null) +/* 326 */ unsetKeyType(); +/* */ else { +/* 328 */ setKeyType((String)value); +/* */ } +/* 330 */ break; +/* */ case 3: +/* 333 */ if (value == null) +/* 334 */ unsetSignatureMethod(); +/* */ else { +/* 336 */ setSignatureMethod((String)value); +/* */ } +/* 338 */ break; +/* */ case 4: +/* 341 */ if (value == null) +/* 342 */ unsetDataToSign(); +/* */ else { +/* 344 */ setDataToSign((String)value); +/* */ } +/* 346 */ break; +/* */ case 5: +/* 349 */ if (value == null) +/* 350 */ unsetSignature(); +/* */ else +/* 352 */ setSignature((String)value); +/* */ break; +/* */ } +/* */ } +/* */ +/* */ public Object getFieldValue(_Fields field) +/* */ { +/* 360 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$SignatureCredentials$_Fields[field.ordinal()]) { +/* */ case 1: +/* 362 */ return getKeyId(); +/* */ case 2: +/* 365 */ return getKeyType(); +/* */ case 3: +/* 368 */ return getSignatureMethod(); +/* */ case 4: +/* 371 */ return getDataToSign(); +/* */ case 5: +/* 374 */ return getSignature(); +/* */ } +/* */ +/* 377 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean isSet(_Fields field) +/* */ { +/* 382 */ if (field == null) { +/* 383 */ throw new IllegalArgumentException(); +/* */ } +/* */ +/* 386 */ switch (field.ordinal()) { //1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$SignatureCredentials$_Fields[field.ordinal()]) { +/* */ case 1: +/* 388 */ return isSetKeyId(); +/* */ case 2: +/* 390 */ return isSetKeyType(); +/* */ case 3: +/* 392 */ return isSetSignatureMethod(); +/* */ case 4: +/* 394 */ return isSetDataToSign(); +/* */ case 5: +/* 396 */ return isSetSignature(); +/* */ } +/* 398 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean equals(Object that) +/* */ { +/* 403 */ if (that == null) +/* 404 */ return false; +/* 405 */ if ((that instanceof SignatureCredentials)) +/* 406 */ return equals((SignatureCredentials)that); +/* 407 */ return false; +/* */ } +/* */ +/* */ public boolean equals(SignatureCredentials that) { +/* 411 */ if (that == null) { +/* 412 */ return false; +/* */ } +/* 414 */ boolean this_present_keyId = isSetKeyId(); +/* 415 */ boolean that_present_keyId = that.isSetKeyId(); +/* 416 */ if ((this_present_keyId) || (that_present_keyId)) { +/* 417 */ if ((!this_present_keyId) || (!that_present_keyId)) +/* 418 */ return false; +/* 419 */ if (!this.keyId.equals(that.keyId)) { +/* 420 */ return false; +/* */ } +/* */ } +/* 423 */ boolean this_present_keyType = isSetKeyType(); +/* 424 */ boolean that_present_keyType = that.isSetKeyType(); +/* 425 */ if ((this_present_keyType) || (that_present_keyType)) { +/* 426 */ if ((!this_present_keyType) || (!that_present_keyType)) +/* 427 */ return false; +/* 428 */ if (!this.keyType.equals(that.keyType)) { +/* 429 */ return false; +/* */ } +/* */ } +/* 432 */ boolean this_present_signatureMethod = isSetSignatureMethod(); +/* 433 */ boolean that_present_signatureMethod = that.isSetSignatureMethod(); +/* 434 */ if ((this_present_signatureMethod) || (that_present_signatureMethod)) { +/* 435 */ if ((!this_present_signatureMethod) || (!that_present_signatureMethod)) +/* 436 */ return false; +/* 437 */ if (!this.signatureMethod.equals(that.signatureMethod)) { +/* 438 */ return false; +/* */ } +/* */ } +/* 441 */ boolean this_present_dataToSign = isSetDataToSign(); +/* 442 */ boolean that_present_dataToSign = that.isSetDataToSign(); +/* 443 */ if ((this_present_dataToSign) || (that_present_dataToSign)) { +/* 444 */ if ((!this_present_dataToSign) || (!that_present_dataToSign)) +/* 445 */ return false; +/* 446 */ if (!this.dataToSign.equals(that.dataToSign)) { +/* 447 */ return false; +/* */ } +/* */ } +/* 450 */ boolean this_present_signature = isSetSignature(); +/* 451 */ boolean that_present_signature = that.isSetSignature(); +/* 452 */ if ((this_present_signature) || (that_present_signature)) { +/* 453 */ if ((!this_present_signature) || (!that_present_signature)) +/* 454 */ return false; +/* 455 */ if (!this.signature.equals(that.signature)) { +/* 456 */ return false; +/* */ } +/* */ } +/* 459 */ return true; +/* */ } +/* */ +/* */ public int hashCode() +/* */ { +/* 464 */ return 0; +/* */ } +/* */ +/* */ public int compareTo(SignatureCredentials other) { +/* 468 */ if (!getClass().equals(other.getClass())) { +/* 469 */ return getClass().getName().compareTo(other.getClass().getName()); +/* */ } +/* */ +/* 472 */ int lastComparison = 0; +/* 473 */ SignatureCredentials typedOther = other; +/* */ +/* 475 */ lastComparison = Boolean.valueOf(isSetKeyId()).compareTo(Boolean.valueOf(typedOther.isSetKeyId())); +/* 476 */ if (lastComparison != 0) { +/* 477 */ return lastComparison; +/* */ } +/* 479 */ if (isSetKeyId()) { +/* 480 */ lastComparison = TBaseHelper.compareTo(this.keyId, typedOther.keyId); +/* 481 */ if (lastComparison != 0) { +/* 482 */ return lastComparison; +/* */ } +/* */ } +/* 485 */ lastComparison = Boolean.valueOf(isSetKeyType()).compareTo(Boolean.valueOf(typedOther.isSetKeyType())); +/* 486 */ if (lastComparison != 0) { +/* 487 */ return lastComparison; +/* */ } +/* 489 */ if (isSetKeyType()) { +/* 490 */ lastComparison = TBaseHelper.compareTo(this.keyType, typedOther.keyType); +/* 491 */ if (lastComparison != 0) { +/* 492 */ return lastComparison; +/* */ } +/* */ } +/* 495 */ lastComparison = Boolean.valueOf(isSetSignatureMethod()).compareTo(Boolean.valueOf(typedOther.isSetSignatureMethod())); +/* 496 */ if (lastComparison != 0) { +/* 497 */ return lastComparison; +/* */ } +/* 499 */ if (isSetSignatureMethod()) { +/* 500 */ lastComparison = TBaseHelper.compareTo(this.signatureMethod, typedOther.signatureMethod); +/* 501 */ if (lastComparison != 0) { +/* 502 */ return lastComparison; +/* */ } +/* */ } +/* 505 */ lastComparison = Boolean.valueOf(isSetDataToSign()).compareTo(Boolean.valueOf(typedOther.isSetDataToSign())); +/* 506 */ if (lastComparison != 0) { +/* 507 */ return lastComparison; +/* */ } +/* 509 */ if (isSetDataToSign()) { +/* 510 */ lastComparison = TBaseHelper.compareTo(this.dataToSign, typedOther.dataToSign); +/* 511 */ if (lastComparison != 0) { +/* 512 */ return lastComparison; +/* */ } +/* */ } +/* 515 */ lastComparison = Boolean.valueOf(isSetSignature()).compareTo(Boolean.valueOf(typedOther.isSetSignature())); +/* 516 */ if (lastComparison != 0) { +/* 517 */ return lastComparison; +/* */ } +/* 519 */ if (isSetSignature()) { +/* 520 */ lastComparison = TBaseHelper.compareTo(this.signature, typedOther.signature); +/* 521 */ if (lastComparison != 0) { +/* 522 */ return lastComparison; +/* */ } +/* */ } +/* 525 */ return 0; +/* */ } +/* */ +/* */ public _Fields fieldForId(int fieldId) { +/* 529 */ return _Fields.findByThriftId(fieldId); +/* */ } +/* */ +/* */ public void read(TProtocol iprot) throws TException { +/* 533 */ ((SchemeFactory)schemes.get(iprot.getScheme())).getScheme().read(iprot, this); +/* */ } +/* */ +/* */ public void write(TProtocol oprot) throws TException { +/* 537 */ ((SchemeFactory)schemes.get(oprot.getScheme())).getScheme().write(oprot, this); +/* */ } +/* */ +/* */ public String toString() +/* */ { +/* 542 */ StringBuilder sb = new StringBuilder("SignatureCredentials("); +/* 543 */ boolean first = true; +/* */ +/* 545 */ sb.append("keyId:"); +/* 546 */ if (this.keyId == null) +/* 547 */ sb.append("null"); +/* */ else { +/* 549 */ sb.append(this.keyId); +/* */ } +/* 551 */ first = false; +/* 552 */ if (!first) sb.append(", "); +/* 553 */ sb.append("keyType:"); +/* 554 */ if (this.keyType == null) +/* 555 */ sb.append("null"); +/* */ else { +/* 557 */ sb.append(this.keyType); +/* */ } +/* 559 */ first = false; +/* 560 */ if (!first) sb.append(", "); +/* 561 */ sb.append("signatureMethod:"); +/* 562 */ if (this.signatureMethod == null) +/* 563 */ sb.append("null"); +/* */ else { +/* 565 */ sb.append(this.signatureMethod); +/* */ } +/* 567 */ first = false; +/* 568 */ if (!first) sb.append(", "); +/* 569 */ sb.append("dataToSign:"); +/* 570 */ if (this.dataToSign == null) +/* 571 */ sb.append("null"); +/* */ else { +/* 573 */ sb.append(this.dataToSign); +/* */ } +/* 575 */ first = false; +/* 576 */ if (!first) sb.append(", "); +/* 577 */ sb.append("signature:"); +/* 578 */ if (this.signature == null) +/* 579 */ sb.append("null"); +/* */ else { +/* 581 */ sb.append(this.signature); +/* */ } +/* 583 */ first = false; +/* 584 */ sb.append(")"); +/* 585 */ return sb.toString(); +/* */ } +/* */ +/* */ public void validate() throws TException +/* */ { +/* */ } +/* */ +/* */ private void writeObject(ObjectOutputStream out) throws IOException { +/* */ try { +/* 594 */ write(new TCompactProtocol(new TIOStreamTransport(out))); +/* */ } catch (TException te) { +/* 596 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { +/* */ try { +/* 602 */ read(new TCompactProtocol(new TIOStreamTransport(in))); +/* */ } catch (TException te) { +/* 604 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ static +/* */ { +/* 44 */ schemes.put(StandardScheme.class, new SignatureCredentialsStandardSchemeFactory()); +/* 45 */ schemes.put(TupleScheme.class, new SignatureCredentialsTupleSchemeFactory()); +/* */ +/* 127 */ Map tmpMap = new EnumMap(_Fields.class); +/* 128 */ tmpMap.put(_Fields.KEY_ID, new FieldMetaData("keyId", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 130 */ tmpMap.put(_Fields.KEY_TYPE, new FieldMetaData("keyType", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 132 */ tmpMap.put(_Fields.SIGNATURE_METHOD, new FieldMetaData("signatureMethod", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 134 */ tmpMap.put(_Fields.DATA_TO_SIGN, new FieldMetaData("dataToSign", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 136 */ tmpMap.put(_Fields.SIGNATURE, new FieldMetaData("signature", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 138 */ metaDataMap = Collections.unmodifiableMap(tmpMap); +/* 139 */ FieldMetaData.addStructMetaDataMap(SignatureCredentials.class, metaDataMap); +/* */ } +/* */ +/* */ private static class SignatureCredentialsTupleScheme extends TupleScheme +/* */ { +/* */ public void write(TProtocol prot, SignatureCredentials struct) +/* */ throws TException +/* */ { +/* 722 */ TTupleProtocol oprot = (TTupleProtocol)prot; +/* 723 */ BitSet optionals = new BitSet(); +/* 724 */ if (struct.isSetKeyId()) { +/* 725 */ optionals.set(0); +/* */ } +/* 727 */ if (struct.isSetKeyType()) { +/* 728 */ optionals.set(1); +/* */ } +/* 730 */ if (struct.isSetSignatureMethod()) { +/* 731 */ optionals.set(2); +/* */ } +/* 733 */ if (struct.isSetDataToSign()) { +/* 734 */ optionals.set(3); +/* */ } +/* 736 */ if (struct.isSetSignature()) { +/* 737 */ optionals.set(4); +/* */ } +/* 739 */ oprot.writeBitSet(optionals, 5); +/* 740 */ if (struct.isSetKeyId()) { +/* 741 */ oprot.writeString(struct.keyId); +/* */ } +/* 743 */ if (struct.isSetKeyType()) { +/* 744 */ oprot.writeString(struct.keyType); +/* */ } +/* 746 */ if (struct.isSetSignatureMethod()) { +/* 747 */ oprot.writeString(struct.signatureMethod); +/* */ } +/* 749 */ if (struct.isSetDataToSign()) { +/* 750 */ oprot.writeString(struct.dataToSign); +/* */ } +/* 752 */ if (struct.isSetSignature()) +/* 753 */ oprot.writeString(struct.signature); +/* */ } +/* */ +/* */ public void read(TProtocol prot, SignatureCredentials struct) +/* */ throws TException +/* */ { +/* 759 */ TTupleProtocol iprot = (TTupleProtocol)prot; +/* 760 */ BitSet incoming = iprot.readBitSet(5); +/* 761 */ if (incoming.get(0)) { +/* 762 */ struct.keyId = iprot.readString(); +/* 763 */ struct.setKeyIdIsSet(true); +/* */ } +/* 765 */ if (incoming.get(1)) { +/* 766 */ struct.keyType = iprot.readString(); +/* 767 */ struct.setKeyTypeIsSet(true); +/* */ } +/* 769 */ if (incoming.get(2)) { +/* 770 */ struct.signatureMethod = iprot.readString(); +/* 771 */ struct.setSignatureMethodIsSet(true); +/* */ } +/* 773 */ if (incoming.get(3)) { +/* 774 */ struct.dataToSign = iprot.readString(); +/* 775 */ struct.setDataToSignIsSet(true); +/* */ } +/* 777 */ if (incoming.get(4)) { +/* 778 */ struct.signature = iprot.readString(); +/* 779 */ struct.setSignatureIsSet(true); +/* */ } +/* */ } +/* */ } +/* */ +/* */ private static class SignatureCredentialsTupleSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public SignatureCredentials.SignatureCredentialsTupleScheme getScheme() +/* */ { +/* 714 */ return new SignatureCredentials.SignatureCredentialsTupleScheme(); +/* */ } +/* */ } +/* */ +/* */ private static class SignatureCredentialsStandardScheme extends StandardScheme +/* */ { +/* */ public void read(TProtocol iprot, SignatureCredentials struct) +/* */ throws TException +/* */ { +/* 618 */ iprot.readStructBegin(); +/* */ while (true) +/* */ { +/* 621 */ TField schemeField = iprot.readFieldBegin(); +/* 622 */ if (schemeField.type == 0) { +/* */ break; +/* */ } +/* 625 */ switch (schemeField.id) { +/* */ case 1: +/* 627 */ if (schemeField.type == 11) { +/* 628 */ struct.keyId = iprot.readString(); +/* 629 */ struct.setKeyIdIsSet(true); +/* */ } else { +/* 631 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 633 */ break; +/* */ case 2: +/* 635 */ if (schemeField.type == 11) { +/* 636 */ struct.keyType = iprot.readString(); +/* 637 */ struct.setKeyTypeIsSet(true); +/* */ } else { +/* 639 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 641 */ break; +/* */ case 3: +/* 643 */ if (schemeField.type == 11) { +/* 644 */ struct.signatureMethod = iprot.readString(); +/* 645 */ struct.setSignatureMethodIsSet(true); +/* */ } else { +/* 647 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 649 */ break; +/* */ case 4: +/* 651 */ if (schemeField.type == 11) { +/* 652 */ struct.dataToSign = iprot.readString(); +/* 653 */ struct.setDataToSignIsSet(true); +/* */ } else { +/* 655 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 657 */ break; +/* */ case 5: +/* 659 */ if (schemeField.type == 11) { +/* 660 */ struct.signature = iprot.readString(); +/* 661 */ struct.setSignatureIsSet(true); +/* */ } else { +/* 663 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 665 */ break; +/* */ default: +/* 667 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 669 */ iprot.readFieldEnd(); +/* */ } +/* 671 */ iprot.readStructEnd(); +/* */ +/* 674 */ struct.validate(); +/* */ } +/* */ +/* */ public void write(TProtocol oprot, SignatureCredentials struct) throws TException { +/* 678 */ struct.validate(); +/* */ +/* 680 */ oprot.writeStructBegin(SignatureCredentials.STRUCT_DESC); +/* 681 */ if (struct.keyId != null) { +/* 682 */ oprot.writeFieldBegin(SignatureCredentials.KEY_ID_FIELD_DESC); +/* 683 */ oprot.writeString(struct.keyId); +/* 684 */ oprot.writeFieldEnd(); +/* */ } +/* 686 */ if (struct.keyType != null) { +/* 687 */ oprot.writeFieldBegin(SignatureCredentials.KEY_TYPE_FIELD_DESC); +/* 688 */ oprot.writeString(struct.keyType); +/* 689 */ oprot.writeFieldEnd(); +/* */ } +/* 691 */ if (struct.signatureMethod != null) { +/* 692 */ oprot.writeFieldBegin(SignatureCredentials.SIGNATURE_METHOD_FIELD_DESC); +/* 693 */ oprot.writeString(struct.signatureMethod); +/* 694 */ oprot.writeFieldEnd(); +/* */ } +/* 696 */ if (struct.dataToSign != null) { +/* 697 */ oprot.writeFieldBegin(SignatureCredentials.DATA_TO_SIGN_FIELD_DESC); +/* 698 */ oprot.writeString(struct.dataToSign); +/* 699 */ oprot.writeFieldEnd(); +/* */ } +/* 701 */ if (struct.signature != null) { +/* 702 */ oprot.writeFieldBegin(SignatureCredentials.SIGNATURE_FIELD_DESC); +/* 703 */ oprot.writeString(struct.signature); +/* 704 */ oprot.writeFieldEnd(); +/* */ } +/* 706 */ oprot.writeFieldStop(); +/* 707 */ oprot.writeStructEnd(); +/* */ } +/* */ } +/* */ +/* */ private static class SignatureCredentialsStandardSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public SignatureCredentials.SignatureCredentialsStandardScheme getScheme() +/* */ { +/* 610 */ return new SignatureCredentials.SignatureCredentialsStandardScheme(); +/* */ } +/* */ } +/* */ +/* */ public static enum _Fields +/* */ implements TFieldIdEnum +/* */ { +/* 56 */ KEY_ID((short)1, "keyId"), +/* 57 */ KEY_TYPE((short)2, "keyType"), +/* 58 */ SIGNATURE_METHOD((short)3, "signatureMethod"), +/* 59 */ DATA_TO_SIGN((short)4, "dataToSign"), +/* 60 */ SIGNATURE((short)5, "signature"); +/* */ +/* */ private static final Map byName; +/* */ private final short _thriftId; +/* */ private final String _fieldName; +/* */ +/* */ public static _Fields findByThriftId(int fieldId) +/* */ { +/* 74 */ switch (fieldId) { +/* */ case 1: +/* 76 */ return KEY_ID; +/* */ case 2: +/* 78 */ return KEY_TYPE; +/* */ case 3: +/* 80 */ return SIGNATURE_METHOD; +/* */ case 4: +/* 82 */ return DATA_TO_SIGN; +/* */ case 5: +/* 84 */ return SIGNATURE; +/* */ } +/* 86 */ return null; +/* */ } +/* */ +/* */ public static _Fields findByThriftIdOrThrow(int fieldId) +/* */ { +/* 95 */ _Fields fields = findByThriftId(fieldId); +/* 96 */ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); +/* 97 */ return fields; +/* */ } +/* */ +/* */ public static _Fields findByName(String name) +/* */ { +/* 104 */ return (_Fields)byName.get(name); +/* */ } +/* */ +/* */ private _Fields(short thriftId, String fieldName) +/* */ { +/* 111 */ this._thriftId = thriftId; +/* 112 */ this._fieldName = fieldName; +/* */ } +/* */ +/* */ public short getThriftFieldId() { +/* 116 */ return this._thriftId; +/* */ } +/* */ +/* */ public String getFieldName() { +/* 120 */ return this._fieldName; +/* */ } +/* */ +/* */ static +/* */ { +/* 62 */ byName = new HashMap(); +/* */ +/* 65 */ for (_Fields field : EnumSet.allOf(_Fields.class)) +/* 66 */ byName.put(field.getFieldName(), field); +/* */ } +/* */ } +/* */ } + +/* Location: /Users/johnderr/.m2/repository/com/hp/csbu/cc/CsThriftModel/1.2-SNAPSHOT/CsThriftModel-1.2-20140130.160951-1223.jar + * Qualified Name: com.hp.csbu.cc.security.cs.thrift.service.SignatureCredentials + * JD-Core Version: 0.6.2 + */ \ No newline at end of file diff --git a/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/Token.java b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/Token.java new file mode 100755 index 000000000..de7eb2a2c --- /dev/null +++ b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/Token.java @@ -0,0 +1,582 @@ +/* */ package com.hp.csbu.cc.security.cs.thrift.service; +/* */ +/* */ import java.io.IOException; +/* */ import java.io.ObjectInputStream; +/* */ import java.io.ObjectOutputStream; +/* */ import java.io.Serializable; +/* */ import java.util.BitSet; +/* */ import java.util.Collections; +/* */ import java.util.EnumMap; +/* */ import java.util.EnumSet; +/* */ import java.util.HashMap; +/* */ import java.util.Map; +/* */ import org.apache.thrift.TBase; +/* */ import org.apache.thrift.TBaseHelper; +/* */ import org.apache.thrift.TException; +/* */ import org.apache.thrift.TFieldIdEnum; +/* */ import org.apache.thrift.meta_data.FieldMetaData; +/* */ import org.apache.thrift.meta_data.FieldValueMetaData; +/* */ import org.apache.thrift.protocol.TCompactProtocol; +/* */ import org.apache.thrift.protocol.TField; +/* */ import org.apache.thrift.protocol.TProtocol; +/* */ import org.apache.thrift.protocol.TProtocolUtil; +/* */ import org.apache.thrift.protocol.TStruct; +/* */ import org.apache.thrift.protocol.TTupleProtocol; +/* */ import org.apache.thrift.scheme.IScheme; +/* */ import org.apache.thrift.scheme.SchemeFactory; +/* */ import org.apache.thrift.scheme.StandardScheme; +/* */ import org.apache.thrift.scheme.TupleScheme; +/* */ import org.apache.thrift.transport.TIOStreamTransport; +/* */ +/* */ public class Token +/* */ implements TBase, Serializable, Cloneable +/* */ { +/* 34 */ private static final TStruct STRUCT_DESC = new TStruct("Token"); +/* */ +/* 36 */ private static final TField EXPIRES_FIELD_DESC = new TField("expires", (byte)11, (short)1); +/* 37 */ private static final TField ID_FIELD_DESC = new TField("id", (byte)11, (short)2); +/* 38 */ private static final TField TENANT_ID_FIELD_DESC = new TField("tenantId", (byte)11, (short)3); +/* */ +/* 40 */ private static final Map, SchemeFactory> schemes = new HashMap(); +/* */ public String expires; +/* */ public String id; +/* */ public String tenantId; +/* 115 */ private _Fields[] optionals = { _Fields.TENANT_ID }; +/* */ public static final Map<_Fields, FieldMetaData> metaDataMap; +/* */ +/* */ public Token() +/* */ { +/* */ } +/* */ +/* */ public Token(String expires, String id) +/* */ { +/* 136 */ this(); +/* 137 */ this.expires = expires; +/* 138 */ this.id = id; +/* */ } +/* */ +/* */ public Token(Token other) +/* */ { +/* 145 */ if (other.isSetExpires()) { +/* 146 */ this.expires = other.expires; +/* */ } +/* 148 */ if (other.isSetId()) { +/* 149 */ this.id = other.id; +/* */ } +/* 151 */ if (other.isSetTenantId()) +/* 152 */ this.tenantId = other.tenantId; +/* */ } +/* */ +/* */ public Token deepCopy() +/* */ { +/* 157 */ return new Token(this); +/* */ } +/* */ +/* */ public void clear() +/* */ { +/* 162 */ this.expires = null; +/* 163 */ this.id = null; +/* 164 */ this.tenantId = null; +/* */ } +/* */ +/* */ public String getExpires() { +/* 168 */ return this.expires; +/* */ } +/* */ +/* */ public Token setExpires(String expires) { +/* 172 */ this.expires = expires; +/* 173 */ return this; +/* */ } +/* */ +/* */ public void unsetExpires() { +/* 177 */ this.expires = null; +/* */ } +/* */ +/* */ public boolean isSetExpires() +/* */ { +/* 182 */ return this.expires != null; +/* */ } +/* */ +/* */ public void setExpiresIsSet(boolean value) { +/* 186 */ if (!value) +/* 187 */ this.expires = null; +/* */ } +/* */ +/* */ public String getId() +/* */ { +/* 192 */ return this.id; +/* */ } +/* */ +/* */ public Token setId(String id) { +/* 196 */ this.id = id; +/* 197 */ return this; +/* */ } +/* */ +/* */ public void unsetId() { +/* 201 */ this.id = null; +/* */ } +/* */ +/* */ public boolean isSetId() +/* */ { +/* 206 */ return this.id != null; +/* */ } +/* */ +/* */ public void setIdIsSet(boolean value) { +/* 210 */ if (!value) +/* 211 */ this.id = null; +/* */ } +/* */ +/* */ public String getTenantId() +/* */ { +/* 216 */ return this.tenantId; +/* */ } +/* */ +/* */ public Token setTenantId(String tenantId) { +/* 220 */ this.tenantId = tenantId; +/* 221 */ return this; +/* */ } +/* */ +/* */ public void unsetTenantId() { +/* 225 */ this.tenantId = null; +/* */ } +/* */ +/* */ public boolean isSetTenantId() +/* */ { +/* 230 */ return this.tenantId != null; +/* */ } +/* */ +/* */ public void setTenantIdIsSet(boolean value) { +/* 234 */ if (!value) +/* 235 */ this.tenantId = null; +/* */ } +/* */ +/* */ public void setFieldValue(_Fields field, Object value) +/* */ { +/* 240 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$Token$_Fields[field.ordinal()]) { +/* */ case 1: +/* 242 */ if (value == null) +/* 243 */ unsetExpires(); +/* */ else { +/* 245 */ setExpires((String)value); +/* */ } +/* 247 */ break; +/* */ case 2: +/* 250 */ if (value == null) +/* 251 */ unsetId(); +/* */ else { +/* 253 */ setId((String)value); +/* */ } +/* 255 */ break; +/* */ case 3: +/* 258 */ if (value == null) +/* 259 */ unsetTenantId(); +/* */ else +/* 261 */ setTenantId((String)value); +/* */ break; +/* */ } +/* */ } +/* */ +/* */ public Object getFieldValue(_Fields field) +/* */ { +/* 269 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$Token$_Fields[field.ordinal()]) { +/* */ case 1: +/* 271 */ return getExpires(); +/* */ case 2: +/* 274 */ return getId(); +/* */ case 3: +/* 277 */ return getTenantId(); +/* */ } +/* */ +/* 280 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean isSet(_Fields field) +/* */ { +/* 285 */ if (field == null) { +/* 286 */ throw new IllegalArgumentException(); +/* */ } +/* */ +/* 289 */ switch (field.ordinal()) { //1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$Token$_Fields[field.ordinal()]) { +/* */ case 1: +/* 291 */ return isSetExpires(); +/* */ case 2: +/* 293 */ return isSetId(); +/* */ case 3: +/* 295 */ return isSetTenantId(); +/* */ } +/* 297 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean equals(Object that) +/* */ { +/* 302 */ if (that == null) +/* 303 */ return false; +/* 304 */ if ((that instanceof Token)) +/* 305 */ return equals((Token)that); +/* 306 */ return false; +/* */ } +/* */ +/* */ public boolean equals(Token that) { +/* 310 */ if (that == null) { +/* 311 */ return false; +/* */ } +/* 313 */ boolean this_present_expires = isSetExpires(); +/* 314 */ boolean that_present_expires = that.isSetExpires(); +/* 315 */ if ((this_present_expires) || (that_present_expires)) { +/* 316 */ if ((!this_present_expires) || (!that_present_expires)) +/* 317 */ return false; +/* 318 */ if (!this.expires.equals(that.expires)) { +/* 319 */ return false; +/* */ } +/* */ } +/* 322 */ boolean this_present_id = isSetId(); +/* 323 */ boolean that_present_id = that.isSetId(); +/* 324 */ if ((this_present_id) || (that_present_id)) { +/* 325 */ if ((!this_present_id) || (!that_present_id)) +/* 326 */ return false; +/* 327 */ if (!this.id.equals(that.id)) { +/* 328 */ return false; +/* */ } +/* */ } +/* 331 */ boolean this_present_tenantId = isSetTenantId(); +/* 332 */ boolean that_present_tenantId = that.isSetTenantId(); +/* 333 */ if ((this_present_tenantId) || (that_present_tenantId)) { +/* 334 */ if ((!this_present_tenantId) || (!that_present_tenantId)) +/* 335 */ return false; +/* 336 */ if (!this.tenantId.equals(that.tenantId)) { +/* 337 */ return false; +/* */ } +/* */ } +/* 340 */ return true; +/* */ } +/* */ +/* */ public int hashCode() +/* */ { +/* 345 */ return 0; +/* */ } +/* */ +/* */ public int compareTo(Token other) { +/* 349 */ if (!getClass().equals(other.getClass())) { +/* 350 */ return getClass().getName().compareTo(other.getClass().getName()); +/* */ } +/* */ +/* 353 */ int lastComparison = 0; +/* 354 */ Token typedOther = other; +/* */ +/* 356 */ lastComparison = Boolean.valueOf(isSetExpires()).compareTo(Boolean.valueOf(typedOther.isSetExpires())); +/* 357 */ if (lastComparison != 0) { +/* 358 */ return lastComparison; +/* */ } +/* 360 */ if (isSetExpires()) { +/* 361 */ lastComparison = TBaseHelper.compareTo(this.expires, typedOther.expires); +/* 362 */ if (lastComparison != 0) { +/* 363 */ return lastComparison; +/* */ } +/* */ } +/* 366 */ lastComparison = Boolean.valueOf(isSetId()).compareTo(Boolean.valueOf(typedOther.isSetId())); +/* 367 */ if (lastComparison != 0) { +/* 368 */ return lastComparison; +/* */ } +/* 370 */ if (isSetId()) { +/* 371 */ lastComparison = TBaseHelper.compareTo(this.id, typedOther.id); +/* 372 */ if (lastComparison != 0) { +/* 373 */ return lastComparison; +/* */ } +/* */ } +/* 376 */ lastComparison = Boolean.valueOf(isSetTenantId()).compareTo(Boolean.valueOf(typedOther.isSetTenantId())); +/* 377 */ if (lastComparison != 0) { +/* 378 */ return lastComparison; +/* */ } +/* 380 */ if (isSetTenantId()) { +/* 381 */ lastComparison = TBaseHelper.compareTo(this.tenantId, typedOther.tenantId); +/* 382 */ if (lastComparison != 0) { +/* 383 */ return lastComparison; +/* */ } +/* */ } +/* 386 */ return 0; +/* */ } +/* */ +/* */ public _Fields fieldForId(int fieldId) { +/* 390 */ return _Fields.findByThriftId(fieldId); +/* */ } +/* */ +/* */ public void read(TProtocol iprot) throws TException { +/* 394 */ ((SchemeFactory)schemes.get(iprot.getScheme())).getScheme().read(iprot, this); +/* */ } +/* */ +/* */ public void write(TProtocol oprot) throws TException { +/* 398 */ ((SchemeFactory)schemes.get(oprot.getScheme())).getScheme().write(oprot, this); +/* */ } +/* */ +/* */ public String toString() +/* */ { +/* 403 */ StringBuilder sb = new StringBuilder("Token("); +/* 404 */ boolean first = true; +/* */ +/* 406 */ sb.append("expires:"); +/* 407 */ if (this.expires == null) +/* 408 */ sb.append("null"); +/* */ else { +/* 410 */ sb.append(this.expires); +/* */ } +/* 412 */ first = false; +/* 413 */ if (!first) sb.append(", "); +/* 414 */ sb.append("id:"); +/* 415 */ if (this.id == null) +/* 416 */ sb.append("null"); +/* */ else { +/* 418 */ sb.append(this.id); +/* */ } +/* 420 */ first = false; +/* 421 */ if (isSetTenantId()) { +/* 422 */ if (!first) sb.append(", "); +/* 423 */ sb.append("tenantId:"); +/* 424 */ if (this.tenantId == null) +/* 425 */ sb.append("null"); +/* */ else { +/* 427 */ sb.append(this.tenantId); +/* */ } +/* 429 */ first = false; +/* */ } +/* 431 */ sb.append(")"); +/* 432 */ return sb.toString(); +/* */ } +/* */ +/* */ public void validate() throws TException +/* */ { +/* */ } +/* */ +/* */ private void writeObject(ObjectOutputStream out) throws IOException { +/* */ try { +/* 441 */ write(new TCompactProtocol(new TIOStreamTransport(out))); +/* */ } catch (TException te) { +/* 443 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { +/* */ try { +/* 449 */ read(new TCompactProtocol(new TIOStreamTransport(in))); +/* */ } catch (TException te) { +/* 451 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ static +/* */ { +/* 42 */ schemes.put(StandardScheme.class, new TokenStandardSchemeFactory()); +/* 43 */ schemes.put(TupleScheme.class, new TokenTupleSchemeFactory()); +/* */ +/* 118 */ Map tmpMap = new EnumMap(_Fields.class); +/* 119 */ tmpMap.put(_Fields.EXPIRES, new FieldMetaData("expires", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 121 */ tmpMap.put(_Fields.ID, new FieldMetaData("id", (byte)3, new FieldValueMetaData((byte)11))); +/* */ +/* 123 */ tmpMap.put(_Fields.TENANT_ID, new FieldMetaData("tenantId", (byte)2, new FieldValueMetaData((byte)11))); +/* */ +/* 125 */ metaDataMap = Collections.unmodifiableMap(tmpMap); +/* 126 */ FieldMetaData.addStructMetaDataMap(Token.class, metaDataMap); +/* */ } +/* */ +/* */ private static class TokenTupleScheme extends TupleScheme +/* */ { +/* */ public void write(TProtocol prot, Token struct) +/* */ throws TException +/* */ { +/* 545 */ TTupleProtocol oprot = (TTupleProtocol)prot; +/* 546 */ BitSet optionals = new BitSet(); +/* 547 */ if (struct.isSetExpires()) { +/* 548 */ optionals.set(0); +/* */ } +/* 550 */ if (struct.isSetId()) { +/* 551 */ optionals.set(1); +/* */ } +/* 553 */ if (struct.isSetTenantId()) { +/* 554 */ optionals.set(2); +/* */ } +/* 556 */ oprot.writeBitSet(optionals, 3); +/* 557 */ if (struct.isSetExpires()) { +/* 558 */ oprot.writeString(struct.expires); +/* */ } +/* 560 */ if (struct.isSetId()) { +/* 561 */ oprot.writeString(struct.id); +/* */ } +/* 563 */ if (struct.isSetTenantId()) +/* 564 */ oprot.writeString(struct.tenantId); +/* */ } +/* */ +/* */ public void read(TProtocol prot, Token struct) +/* */ throws TException +/* */ { +/* 570 */ TTupleProtocol iprot = (TTupleProtocol)prot; +/* 571 */ BitSet incoming = iprot.readBitSet(3); +/* 572 */ if (incoming.get(0)) { +/* 573 */ struct.expires = iprot.readString(); +/* 574 */ struct.setExpiresIsSet(true); +/* */ } +/* 576 */ if (incoming.get(1)) { +/* 577 */ struct.id = iprot.readString(); +/* 578 */ struct.setIdIsSet(true); +/* */ } +/* 580 */ if (incoming.get(2)) { +/* 581 */ struct.tenantId = iprot.readString(); +/* 582 */ struct.setTenantIdIsSet(true); +/* */ } +/* */ } +/* */ } +/* */ +/* */ private static class TokenTupleSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public Token.TokenTupleScheme getScheme() +/* */ { +/* 537 */ return new Token.TokenTupleScheme(); +/* */ } +/* */ } +/* */ +/* */ private static class TokenStandardScheme extends StandardScheme +/* */ { +/* */ public void read(TProtocol iprot, Token struct) +/* */ throws TException +/* */ { +/* 465 */ iprot.readStructBegin(); +/* */ while (true) +/* */ { +/* 468 */ TField schemeField = iprot.readFieldBegin(); +/* 469 */ if (schemeField.type == 0) { +/* */ break; +/* */ } +/* 472 */ switch (schemeField.id) { +/* */ case 1: +/* 474 */ if (schemeField.type == 11) { +/* 475 */ struct.expires = iprot.readString(); +/* 476 */ struct.setExpiresIsSet(true); +/* */ } else { +/* 478 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 480 */ break; +/* */ case 2: +/* 482 */ if (schemeField.type == 11) { +/* 483 */ struct.id = iprot.readString(); +/* 484 */ struct.setIdIsSet(true); +/* */ } else { +/* 486 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 488 */ break; +/* */ case 3: +/* 490 */ if (schemeField.type == 11) { +/* 491 */ struct.tenantId = iprot.readString(); +/* 492 */ struct.setTenantIdIsSet(true); +/* */ } else { +/* 494 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 496 */ break; +/* */ default: +/* 498 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 500 */ iprot.readFieldEnd(); +/* */ } +/* 502 */ iprot.readStructEnd(); +/* */ +/* 505 */ struct.validate(); +/* */ } +/* */ +/* */ public void write(TProtocol oprot, Token struct) throws TException { +/* 509 */ struct.validate(); +/* */ +/* 511 */ oprot.writeStructBegin(Token.STRUCT_DESC); +/* 512 */ if (struct.expires != null) { +/* 513 */ oprot.writeFieldBegin(Token.EXPIRES_FIELD_DESC); +/* 514 */ oprot.writeString(struct.expires); +/* 515 */ oprot.writeFieldEnd(); +/* */ } +/* 517 */ if (struct.id != null) { +/* 518 */ oprot.writeFieldBegin(Token.ID_FIELD_DESC); +/* 519 */ oprot.writeString(struct.id); +/* 520 */ oprot.writeFieldEnd(); +/* */ } +/* 522 */ if ((struct.tenantId != null) && +/* 523 */ (struct.isSetTenantId())) { +/* 524 */ oprot.writeFieldBegin(Token.TENANT_ID_FIELD_DESC); +/* 525 */ oprot.writeString(struct.tenantId); +/* 526 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 529 */ oprot.writeFieldStop(); +/* 530 */ oprot.writeStructEnd(); +/* */ } +/* */ } +/* */ +/* */ private static class TokenStandardSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public Token.TokenStandardScheme getScheme() +/* */ { +/* 457 */ return new Token.TokenStandardScheme(); +/* */ } +/* */ } +/* */ +/* */ public static enum _Fields +/* */ implements TFieldIdEnum +/* */ { +/* 52 */ EXPIRES((short)1, "expires"), +/* 53 */ ID((short)2, "id"), +/* 54 */ TENANT_ID((short)3, "tenantId"); +/* */ +/* */ private static final Map byName; +/* */ private final short _thriftId; +/* */ private final String _fieldName; +/* */ +/* */ public static _Fields findByThriftId(int fieldId) +/* */ { +/* 68 */ switch (fieldId) { +/* */ case 1: +/* 70 */ return EXPIRES; +/* */ case 2: +/* 72 */ return ID; +/* */ case 3: +/* 74 */ return TENANT_ID; +/* */ } +/* 76 */ return null; +/* */ } +/* */ +/* */ public static _Fields findByThriftIdOrThrow(int fieldId) +/* */ { +/* 85 */ _Fields fields = findByThriftId(fieldId); +/* 86 */ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); +/* 87 */ return fields; +/* */ } +/* */ +/* */ public static _Fields findByName(String name) +/* */ { +/* 94 */ return (_Fields)byName.get(name); +/* */ } +/* */ +/* */ private _Fields(short thriftId, String fieldName) +/* */ { +/* 101 */ this._thriftId = thriftId; +/* 102 */ this._fieldName = fieldName; +/* */ } +/* */ +/* */ public short getThriftFieldId() { +/* 106 */ return this._thriftId; +/* */ } +/* */ +/* */ public String getFieldName() { +/* 110 */ return this._fieldName; +/* */ } +/* */ +/* */ static +/* */ { +/* 56 */ byName = new HashMap(); +/* */ +/* 59 */ for (_Fields field : EnumSet.allOf(_Fields.class)) +/* 60 */ byName.put(field.getFieldName(), field); +/* */ } +/* */ } +/* */ } + +/* Location: /Users/johnderr/.m2/repository/com/hp/csbu/cc/CsThriftModel/1.2-SNAPSHOT/CsThriftModel-1.2-20140130.160951-1223.jar + * Qualified Name: com.hp.csbu.cc.security.cs.thrift.service.Token + * JD-Core Version: 0.6.2 + */ \ No newline at end of file diff --git a/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/User.java b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/User.java new file mode 100755 index 000000000..8782e3fd3 --- /dev/null +++ b/src/main/java/com/hp/csbu/cc/security/cs/thrift/service/User.java @@ -0,0 +1,940 @@ +/* */ package com.hp.csbu.cc.security.cs.thrift.service; +/* */ +/* */ import java.io.IOException; +/* */ import java.io.ObjectInputStream; +/* */ import java.io.ObjectOutputStream; +/* */ import java.io.Serializable; +/* */ import java.util.ArrayList; +/* */ import java.util.BitSet; +/* */ import java.util.Collections; +/* */ import java.util.EnumMap; +/* */ import java.util.EnumSet; +/* */ import java.util.HashMap; +/* */ import java.util.Iterator; +/* */ import java.util.List; +/* */ import java.util.Map; +/* */ import org.apache.thrift.TBase; +/* */ import org.apache.thrift.TBaseHelper; +/* */ import org.apache.thrift.TException; +/* */ import org.apache.thrift.TFieldIdEnum; +/* */ import org.apache.thrift.meta_data.FieldMetaData; +/* */ import org.apache.thrift.meta_data.FieldValueMetaData; +/* */ import org.apache.thrift.meta_data.ListMetaData; +/* */ import org.apache.thrift.meta_data.StructMetaData; +/* */ import org.apache.thrift.protocol.TCompactProtocol; +/* */ import org.apache.thrift.protocol.TField; +/* */ import org.apache.thrift.protocol.TList; +/* */ import org.apache.thrift.protocol.TProtocol; +/* */ import org.apache.thrift.protocol.TProtocolUtil; +/* */ import org.apache.thrift.protocol.TStruct; +/* */ import org.apache.thrift.protocol.TTupleProtocol; +/* */ import org.apache.thrift.scheme.IScheme; +/* */ import org.apache.thrift.scheme.SchemeFactory; +/* */ import org.apache.thrift.scheme.StandardScheme; +/* */ import org.apache.thrift.scheme.TupleScheme; +/* */ import org.apache.thrift.transport.TIOStreamTransport; +/* */ +/* */ public class User +/* */ implements TBase, Serializable, Cloneable +/* */ { +/* 36 */ private static final TStruct STRUCT_DESC = new TStruct("User"); +/* */ +/* 38 */ private static final TField USERNAME_FIELD_DESC = new TField("username", (byte)11, (short)1); +/* 39 */ private static final TField TENANT_ID_FIELD_DESC = new TField("tenantId", (byte)11, (short)2); +/* 40 */ private static final TField ROLES_FIELD_DESC = new TField("roles", (byte)15, (short)3); +/* 41 */ private static final TField USER_ID_FIELD_DESC = new TField("userId", (byte)11, (short)4); +/* 42 */ private static final TField TENANT_NAME_FIELD_DESC = new TField("tenantName", (byte)11, (short)5); +/* 43 */ private static final TField SWIFT_ACCOUNT_HASH_FIELD_DESC = new TField("swiftAccountHash", (byte)11, (short)6); +/* */ +/* 45 */ private static final Map, SchemeFactory> schemes = new HashMap(); +/* */ public String username; +/* */ public String tenantId; +/* */ public List roles; +/* */ public String userId; +/* */ public String tenantName; +/* */ public String swiftAccountHash; +/* 132 */ private _Fields[] optionals = { _Fields.USERNAME, _Fields.TENANT_ID, _Fields.ROLES, _Fields.USER_ID, _Fields.TENANT_NAME, _Fields.SWIFT_ACCOUNT_HASH }; +/* */ public static final Map<_Fields, FieldMetaData> metaDataMap; +/* */ +/* */ public User() +/* */ { +/* */ } +/* */ +/* */ public User(User other) +/* */ { +/* 160 */ if (other.isSetUsername()) { +/* 161 */ this.username = other.username; +/* */ } +/* 163 */ if (other.isSetTenantId()) { +/* 164 */ this.tenantId = other.tenantId; +/* */ } +/* 166 */ if (other.isSetRoles()) { +/* 167 */ List __this__roles = new ArrayList(); +/* 168 */ for (Role other_element : other.roles) { +/* 169 */ __this__roles.add(new Role(other_element)); +/* */ } +/* 171 */ this.roles = __this__roles; +/* */ } +/* 173 */ if (other.isSetUserId()) { +/* 174 */ this.userId = other.userId; +/* */ } +/* 176 */ if (other.isSetTenantName()) { +/* 177 */ this.tenantName = other.tenantName; +/* */ } +/* 179 */ if (other.isSetSwiftAccountHash()) +/* 180 */ this.swiftAccountHash = other.swiftAccountHash; +/* */ } +/* */ +/* */ public User deepCopy() +/* */ { +/* 185 */ return new User(this); +/* */ } +/* */ +/* */ public void clear() +/* */ { +/* 190 */ this.username = null; +/* 191 */ this.tenantId = null; +/* 192 */ this.roles = null; +/* 193 */ this.userId = null; +/* 194 */ this.tenantName = null; +/* 195 */ this.swiftAccountHash = null; +/* */ } +/* */ +/* */ public String getUsername() { +/* 199 */ return this.username; +/* */ } +/* */ +/* */ public User setUsername(String username) { +/* 203 */ this.username = username; +/* 204 */ return this; +/* */ } +/* */ +/* */ public void unsetUsername() { +/* 208 */ this.username = null; +/* */ } +/* */ +/* */ public boolean isSetUsername() +/* */ { +/* 213 */ return this.username != null; +/* */ } +/* */ +/* */ public void setUsernameIsSet(boolean value) { +/* 217 */ if (!value) +/* 218 */ this.username = null; +/* */ } +/* */ +/* */ public String getTenantId() +/* */ { +/* 223 */ return this.tenantId; +/* */ } +/* */ +/* */ public User setTenantId(String tenantId) { +/* 227 */ this.tenantId = tenantId; +/* 228 */ return this; +/* */ } +/* */ +/* */ public void unsetTenantId() { +/* 232 */ this.tenantId = null; +/* */ } +/* */ +/* */ public boolean isSetTenantId() +/* */ { +/* 237 */ return this.tenantId != null; +/* */ } +/* */ +/* */ public void setTenantIdIsSet(boolean value) { +/* 241 */ if (!value) +/* 242 */ this.tenantId = null; +/* */ } +/* */ +/* */ public int getRolesSize() +/* */ { +/* 247 */ return this.roles == null ? 0 : this.roles.size(); +/* */ } +/* */ +/* */ public Iterator getRolesIterator() { +/* 251 */ return this.roles == null ? null : this.roles.iterator(); +/* */ } +/* */ +/* */ public void addToRoles(Role elem) { +/* 255 */ if (this.roles == null) { +/* 256 */ this.roles = new ArrayList(); +/* */ } +/* 258 */ this.roles.add(elem); +/* */ } +/* */ +/* */ public List getRoles() { +/* 262 */ return this.roles; +/* */ } +/* */ +/* */ public User setRoles(List roles) { +/* 266 */ this.roles = roles; +/* 267 */ return this; +/* */ } +/* */ +/* */ public void unsetRoles() { +/* 271 */ this.roles = null; +/* */ } +/* */ +/* */ public boolean isSetRoles() +/* */ { +/* 276 */ return this.roles != null; +/* */ } +/* */ +/* */ public void setRolesIsSet(boolean value) { +/* 280 */ if (!value) +/* 281 */ this.roles = null; +/* */ } +/* */ +/* */ public String getUserId() +/* */ { +/* 286 */ return this.userId; +/* */ } +/* */ +/* */ public User setUserId(String userId) { +/* 290 */ this.userId = userId; +/* 291 */ return this; +/* */ } +/* */ +/* */ public void unsetUserId() { +/* 295 */ this.userId = null; +/* */ } +/* */ +/* */ public boolean isSetUserId() +/* */ { +/* 300 */ return this.userId != null; +/* */ } +/* */ +/* */ public void setUserIdIsSet(boolean value) { +/* 304 */ if (!value) +/* 305 */ this.userId = null; +/* */ } +/* */ +/* */ public String getTenantName() +/* */ { +/* 310 */ return this.tenantName; +/* */ } +/* */ +/* */ public User setTenantName(String tenantName) { +/* 314 */ this.tenantName = tenantName; +/* 315 */ return this; +/* */ } +/* */ +/* */ public void unsetTenantName() { +/* 319 */ this.tenantName = null; +/* */ } +/* */ +/* */ public boolean isSetTenantName() +/* */ { +/* 324 */ return this.tenantName != null; +/* */ } +/* */ +/* */ public void setTenantNameIsSet(boolean value) { +/* 328 */ if (!value) +/* 329 */ this.tenantName = null; +/* */ } +/* */ +/* */ public String getSwiftAccountHash() +/* */ { +/* 334 */ return this.swiftAccountHash; +/* */ } +/* */ +/* */ public User setSwiftAccountHash(String swiftAccountHash) { +/* 338 */ this.swiftAccountHash = swiftAccountHash; +/* 339 */ return this; +/* */ } +/* */ +/* */ public void unsetSwiftAccountHash() { +/* 343 */ this.swiftAccountHash = null; +/* */ } +/* */ +/* */ public boolean isSetSwiftAccountHash() +/* */ { +/* 348 */ return this.swiftAccountHash != null; +/* */ } +/* */ +/* */ public void setSwiftAccountHashIsSet(boolean value) { +/* 352 */ if (!value) +/* 353 */ this.swiftAccountHash = null; +/* */ } +/* */ +/* */ public void setFieldValue(_Fields field, Object value) +/* */ { +/* 358 */ switch (field.ordinal()) { //1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$User$_Fields[field.ordinal()]) { +/* */ case 1: +/* 360 */ if (value == null) +/* 361 */ unsetUsername(); +/* */ else { +/* 363 */ setUsername((String)value); +/* */ } +/* 365 */ break; +/* */ case 2: +/* 368 */ if (value == null) +/* 369 */ unsetTenantId(); +/* */ else { +/* 371 */ setTenantId((String)value); +/* */ } +/* 373 */ break; +/* */ case 3: +/* 376 */ if (value == null) +/* 377 */ unsetRoles(); +/* */ else { +/* 379 */ setRoles((List)value); +/* */ } +/* 381 */ break; +/* */ case 4: +/* 384 */ if (value == null) +/* 385 */ unsetUserId(); +/* */ else { +/* 387 */ setUserId((String)value); +/* */ } +/* 389 */ break; +/* */ case 5: +/* 392 */ if (value == null) +/* 393 */ unsetTenantName(); +/* */ else { +/* 395 */ setTenantName((String)value); +/* */ } +/* 397 */ break; +/* */ case 6: +/* 400 */ if (value == null) +/* 401 */ unsetSwiftAccountHash(); +/* */ else +/* 403 */ setSwiftAccountHash((String)value); +/* */ break; +/* */ } +/* */ } +/* */ +/* */ public Object getFieldValue(_Fields field) +/* */ { +/* 411 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$User$_Fields[field.ordinal()]) { +/* */ case 1: +/* 413 */ return getUsername(); +/* */ case 2: +/* 416 */ return getTenantId(); +/* */ case 3: +/* 419 */ return getRoles(); +/* */ case 4: +/* 422 */ return getUserId(); +/* */ case 5: +/* 425 */ return getTenantName(); +/* */ case 6: +/* 428 */ return getSwiftAccountHash(); +/* */ } +/* */ +/* 431 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean isSet(_Fields field) +/* */ { +/* 436 */ if (field == null) { +/* 437 */ throw new IllegalArgumentException(); +/* */ } +/* */ +/* 440 */ switch (field.ordinal()) {//1.$SwitchMap$com$hp$csbu$cc$security$cs$thrift$service$User$_Fields[field.ordinal()]) { +/* */ case 1: +/* 442 */ return isSetUsername(); +/* */ case 2: +/* 444 */ return isSetTenantId(); +/* */ case 3: +/* 446 */ return isSetRoles(); +/* */ case 4: +/* 448 */ return isSetUserId(); +/* */ case 5: +/* 450 */ return isSetTenantName(); +/* */ case 6: +/* 452 */ return isSetSwiftAccountHash(); +/* */ } +/* 454 */ throw new IllegalStateException(); +/* */ } +/* */ +/* */ public boolean equals(Object that) +/* */ { +/* 459 */ if (that == null) +/* 460 */ return false; +/* 461 */ if ((that instanceof User)) +/* 462 */ return equals((User)that); +/* 463 */ return false; +/* */ } +/* */ +/* */ public boolean equals(User that) { +/* 467 */ if (that == null) { +/* 468 */ return false; +/* */ } +/* 470 */ boolean this_present_username = isSetUsername(); +/* 471 */ boolean that_present_username = that.isSetUsername(); +/* 472 */ if ((this_present_username) || (that_present_username)) { +/* 473 */ if ((!this_present_username) || (!that_present_username)) +/* 474 */ return false; +/* 475 */ if (!this.username.equals(that.username)) { +/* 476 */ return false; +/* */ } +/* */ } +/* 479 */ boolean this_present_tenantId = isSetTenantId(); +/* 480 */ boolean that_present_tenantId = that.isSetTenantId(); +/* 481 */ if ((this_present_tenantId) || (that_present_tenantId)) { +/* 482 */ if ((!this_present_tenantId) || (!that_present_tenantId)) +/* 483 */ return false; +/* 484 */ if (!this.tenantId.equals(that.tenantId)) { +/* 485 */ return false; +/* */ } +/* */ } +/* 488 */ boolean this_present_roles = isSetRoles(); +/* 489 */ boolean that_present_roles = that.isSetRoles(); +/* 490 */ if ((this_present_roles) || (that_present_roles)) { +/* 491 */ if ((!this_present_roles) || (!that_present_roles)) +/* 492 */ return false; +/* 493 */ if (!this.roles.equals(that.roles)) { +/* 494 */ return false; +/* */ } +/* */ } +/* 497 */ boolean this_present_userId = isSetUserId(); +/* 498 */ boolean that_present_userId = that.isSetUserId(); +/* 499 */ if ((this_present_userId) || (that_present_userId)) { +/* 500 */ if ((!this_present_userId) || (!that_present_userId)) +/* 501 */ return false; +/* 502 */ if (!this.userId.equals(that.userId)) { +/* 503 */ return false; +/* */ } +/* */ } +/* 506 */ boolean this_present_tenantName = isSetTenantName(); +/* 507 */ boolean that_present_tenantName = that.isSetTenantName(); +/* 508 */ if ((this_present_tenantName) || (that_present_tenantName)) { +/* 509 */ if ((!this_present_tenantName) || (!that_present_tenantName)) +/* 510 */ return false; +/* 511 */ if (!this.tenantName.equals(that.tenantName)) { +/* 512 */ return false; +/* */ } +/* */ } +/* 515 */ boolean this_present_swiftAccountHash = isSetSwiftAccountHash(); +/* 516 */ boolean that_present_swiftAccountHash = that.isSetSwiftAccountHash(); +/* 517 */ if ((this_present_swiftAccountHash) || (that_present_swiftAccountHash)) { +/* 518 */ if ((!this_present_swiftAccountHash) || (!that_present_swiftAccountHash)) +/* 519 */ return false; +/* 520 */ if (!this.swiftAccountHash.equals(that.swiftAccountHash)) { +/* 521 */ return false; +/* */ } +/* */ } +/* 524 */ return true; +/* */ } +/* */ +/* */ public int hashCode() +/* */ { +/* 529 */ return 0; +/* */ } +/* */ +/* */ public int compareTo(User other) { +/* 533 */ if (!getClass().equals(other.getClass())) { +/* 534 */ return getClass().getName().compareTo(other.getClass().getName()); +/* */ } +/* */ +/* 537 */ int lastComparison = 0; +/* 538 */ User typedOther = other; +/* */ +/* 540 */ lastComparison = Boolean.valueOf(isSetUsername()).compareTo(Boolean.valueOf(typedOther.isSetUsername())); +/* 541 */ if (lastComparison != 0) { +/* 542 */ return lastComparison; +/* */ } +/* 544 */ if (isSetUsername()) { +/* 545 */ lastComparison = TBaseHelper.compareTo(this.username, typedOther.username); +/* 546 */ if (lastComparison != 0) { +/* 547 */ return lastComparison; +/* */ } +/* */ } +/* 550 */ lastComparison = Boolean.valueOf(isSetTenantId()).compareTo(Boolean.valueOf(typedOther.isSetTenantId())); +/* 551 */ if (lastComparison != 0) { +/* 552 */ return lastComparison; +/* */ } +/* 554 */ if (isSetTenantId()) { +/* 555 */ lastComparison = TBaseHelper.compareTo(this.tenantId, typedOther.tenantId); +/* 556 */ if (lastComparison != 0) { +/* 557 */ return lastComparison; +/* */ } +/* */ } +/* 560 */ lastComparison = Boolean.valueOf(isSetRoles()).compareTo(Boolean.valueOf(typedOther.isSetRoles())); +/* 561 */ if (lastComparison != 0) { +/* 562 */ return lastComparison; +/* */ } +/* 564 */ if (isSetRoles()) { +/* 565 */ lastComparison = TBaseHelper.compareTo(this.roles, typedOther.roles); +/* 566 */ if (lastComparison != 0) { +/* 567 */ return lastComparison; +/* */ } +/* */ } +/* 570 */ lastComparison = Boolean.valueOf(isSetUserId()).compareTo(Boolean.valueOf(typedOther.isSetUserId())); +/* 571 */ if (lastComparison != 0) { +/* 572 */ return lastComparison; +/* */ } +/* 574 */ if (isSetUserId()) { +/* 575 */ lastComparison = TBaseHelper.compareTo(this.userId, typedOther.userId); +/* 576 */ if (lastComparison != 0) { +/* 577 */ return lastComparison; +/* */ } +/* */ } +/* 580 */ lastComparison = Boolean.valueOf(isSetTenantName()).compareTo(Boolean.valueOf(typedOther.isSetTenantName())); +/* 581 */ if (lastComparison != 0) { +/* 582 */ return lastComparison; +/* */ } +/* 584 */ if (isSetTenantName()) { +/* 585 */ lastComparison = TBaseHelper.compareTo(this.tenantName, typedOther.tenantName); +/* 586 */ if (lastComparison != 0) { +/* 587 */ return lastComparison; +/* */ } +/* */ } +/* 590 */ lastComparison = Boolean.valueOf(isSetSwiftAccountHash()).compareTo(Boolean.valueOf(typedOther.isSetSwiftAccountHash())); +/* 591 */ if (lastComparison != 0) { +/* 592 */ return lastComparison; +/* */ } +/* 594 */ if (isSetSwiftAccountHash()) { +/* 595 */ lastComparison = TBaseHelper.compareTo(this.swiftAccountHash, typedOther.swiftAccountHash); +/* 596 */ if (lastComparison != 0) { +/* 597 */ return lastComparison; +/* */ } +/* */ } +/* 600 */ return 0; +/* */ } +/* */ +/* */ public _Fields fieldForId(int fieldId) { +/* 604 */ return _Fields.findByThriftId(fieldId); +/* */ } +/* */ +/* */ public void read(TProtocol iprot) throws TException { +/* 608 */ ((SchemeFactory)schemes.get(iprot.getScheme())).getScheme().read(iprot, this); +/* */ } +/* */ +/* */ public void write(TProtocol oprot) throws TException { +/* 612 */ ((SchemeFactory)schemes.get(oprot.getScheme())).getScheme().write(oprot, this); +/* */ } +/* */ +/* */ public String toString() +/* */ { +/* 617 */ StringBuilder sb = new StringBuilder("User("); +/* 618 */ boolean first = true; +/* */ +/* 620 */ if (isSetUsername()) { +/* 621 */ sb.append("username:"); +/* 622 */ if (this.username == null) +/* 623 */ sb.append("null"); +/* */ else { +/* 625 */ sb.append(this.username); +/* */ } +/* 627 */ first = false; +/* */ } +/* 629 */ if (isSetTenantId()) { +/* 630 */ if (!first) sb.append(", "); +/* 631 */ sb.append("tenantId:"); +/* 632 */ if (this.tenantId == null) +/* 633 */ sb.append("null"); +/* */ else { +/* 635 */ sb.append(this.tenantId); +/* */ } +/* 637 */ first = false; +/* */ } +/* 639 */ if (isSetRoles()) { +/* 640 */ if (!first) sb.append(", "); +/* 641 */ sb.append("roles:"); +/* 642 */ if (this.roles == null) +/* 643 */ sb.append("null"); +/* */ else { +/* 645 */ sb.append(this.roles); +/* */ } +/* 647 */ first = false; +/* */ } +/* 649 */ if (isSetUserId()) { +/* 650 */ if (!first) sb.append(", "); +/* 651 */ sb.append("userId:"); +/* 652 */ if (this.userId == null) +/* 653 */ sb.append("null"); +/* */ else { +/* 655 */ sb.append(this.userId); +/* */ } +/* 657 */ first = false; +/* */ } +/* 659 */ if (isSetTenantName()) { +/* 660 */ if (!first) sb.append(", "); +/* 661 */ sb.append("tenantName:"); +/* 662 */ if (this.tenantName == null) +/* 663 */ sb.append("null"); +/* */ else { +/* 665 */ sb.append(this.tenantName); +/* */ } +/* 667 */ first = false; +/* */ } +/* 669 */ if (isSetSwiftAccountHash()) { +/* 670 */ if (!first) sb.append(", "); +/* 671 */ sb.append("swiftAccountHash:"); +/* 672 */ if (this.swiftAccountHash == null) +/* 673 */ sb.append("null"); +/* */ else { +/* 675 */ sb.append(this.swiftAccountHash); +/* */ } +/* 677 */ first = false; +/* */ } +/* 679 */ sb.append(")"); +/* 680 */ return sb.toString(); +/* */ } +/* */ +/* */ public void validate() throws TException +/* */ { +/* */ } +/* */ +/* */ private void writeObject(ObjectOutputStream out) throws IOException { +/* */ try { +/* 689 */ write(new TCompactProtocol(new TIOStreamTransport(out))); +/* */ } catch (TException te) { +/* 691 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { +/* */ try { +/* 697 */ read(new TCompactProtocol(new TIOStreamTransport(in))); +/* */ } catch (TException te) { +/* 699 */ throw new IOException(te); +/* */ } +/* */ } +/* */ +/* */ static +/* */ { +/* 47 */ schemes.put(StandardScheme.class, new UserStandardSchemeFactory()); +/* 48 */ schemes.put(TupleScheme.class, new UserTupleSchemeFactory()); +/* */ +/* 135 */ Map tmpMap = new EnumMap(_Fields.class); +/* 136 */ tmpMap.put(_Fields.USERNAME, new FieldMetaData("username", (byte)2, new FieldValueMetaData((byte)11))); +/* */ +/* 138 */ tmpMap.put(_Fields.TENANT_ID, new FieldMetaData("tenantId", (byte)2, new FieldValueMetaData((byte)11))); +/* */ +/* 140 */ tmpMap.put(_Fields.ROLES, new FieldMetaData("roles", (byte)2, new ListMetaData((byte)15, new StructMetaData((byte)12, Role.class)))); +/* */ +/* 143 */ tmpMap.put(_Fields.USER_ID, new FieldMetaData("userId", (byte)2, new FieldValueMetaData((byte)11))); +/* */ +/* 145 */ tmpMap.put(_Fields.TENANT_NAME, new FieldMetaData("tenantName", (byte)2, new FieldValueMetaData((byte)11))); +/* */ +/* 147 */ tmpMap.put(_Fields.SWIFT_ACCOUNT_HASH, new FieldMetaData("swiftAccountHash", (byte)2, new FieldValueMetaData((byte)11))); +/* */ +/* 149 */ metaDataMap = Collections.unmodifiableMap(tmpMap); +/* 150 */ FieldMetaData.addStructMetaDataMap(User.class, metaDataMap); +/* */ } +/* */ +/* */ private static class UserTupleScheme extends TupleScheme +/* */ { +/* */ public void write(TProtocol prot, User struct) +/* */ throws TException +/* */ { +/* 860 */ TTupleProtocol oprot = (TTupleProtocol)prot; +/* 861 */ BitSet optionals = new BitSet(); +/* 862 */ if (struct.isSetUsername()) { +/* 863 */ optionals.set(0); +/* */ } +/* 865 */ if (struct.isSetTenantId()) { +/* 866 */ optionals.set(1); +/* */ } +/* 868 */ if (struct.isSetRoles()) { +/* 869 */ optionals.set(2); +/* */ } +/* 871 */ if (struct.isSetUserId()) { +/* 872 */ optionals.set(3); +/* */ } +/* 874 */ if (struct.isSetTenantName()) { +/* 875 */ optionals.set(4); +/* */ } +/* 877 */ if (struct.isSetSwiftAccountHash()) { +/* 878 */ optionals.set(5); +/* */ } +/* 880 */ oprot.writeBitSet(optionals, 6); +/* 881 */ if (struct.isSetUsername()) { +/* 882 */ oprot.writeString(struct.username); +/* */ } +/* 884 */ if (struct.isSetTenantId()) { +/* 885 */ oprot.writeString(struct.tenantId); +/* */ } +/* 887 */ if (struct.isSetRoles()) +/* */ { +/* 889 */ oprot.writeI32(struct.roles.size()); +/* 890 */ for (Role _iter4 : struct.roles) +/* */ { +/* 892 */ _iter4.write(oprot); +/* */ } +/* */ } +/* */ +/* 896 */ if (struct.isSetUserId()) { +/* 897 */ oprot.writeString(struct.userId); +/* */ } +/* 899 */ if (struct.isSetTenantName()) { +/* 900 */ oprot.writeString(struct.tenantName); +/* */ } +/* 902 */ if (struct.isSetSwiftAccountHash()) +/* 903 */ oprot.writeString(struct.swiftAccountHash); +/* */ } +/* */ +/* */ public void read(TProtocol prot, User struct) +/* */ throws TException +/* */ { +/* 909 */ TTupleProtocol iprot = (TTupleProtocol)prot; +/* 910 */ BitSet incoming = iprot.readBitSet(6); +/* 911 */ if (incoming.get(0)) { +/* 912 */ struct.username = iprot.readString(); +/* 913 */ struct.setUsernameIsSet(true); +/* */ } +/* 915 */ if (incoming.get(1)) { +/* 916 */ struct.tenantId = iprot.readString(); +/* 917 */ struct.setTenantIdIsSet(true); +/* */ } +/* 919 */ if (incoming.get(2)) +/* */ { +/* 921 */ TList _list5 = new TList((byte)12, iprot.readI32()); +/* 922 */ struct.roles = new ArrayList(_list5.size); +/* 923 */ for (int _i6 = 0; _i6 < _list5.size; _i6++) +/* */ { +/* 926 */ Role _elem7 = new Role(); +/* 927 */ _elem7.read(iprot); +/* 928 */ struct.roles.add(_elem7); +/* */ } +/* */ +/* 931 */ struct.setRolesIsSet(true); +/* */ } +/* 933 */ if (incoming.get(3)) { +/* 934 */ struct.userId = iprot.readString(); +/* 935 */ struct.setUserIdIsSet(true); +/* */ } +/* 937 */ if (incoming.get(4)) { +/* 938 */ struct.tenantName = iprot.readString(); +/* 939 */ struct.setTenantNameIsSet(true); +/* */ } +/* 941 */ if (incoming.get(5)) { +/* 942 */ struct.swiftAccountHash = iprot.readString(); +/* 943 */ struct.setSwiftAccountHashIsSet(true); +/* */ } +/* */ } +/* */ } +/* */ +/* */ private static class UserTupleSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public User.UserTupleScheme getScheme() +/* */ { +/* 852 */ return new User.UserTupleScheme(); +/* */ } +/* */ } +/* */ +/* */ private static class UserStandardScheme extends StandardScheme +/* */ { +/* */ public void read(TProtocol iprot, User struct) +/* */ throws TException +/* */ { +/* 713 */ iprot.readStructBegin(); +/* */ while (true) +/* */ { +/* 716 */ TField schemeField = iprot.readFieldBegin(); +/* 717 */ if (schemeField.type == 0) { +/* */ break; +/* */ } +/* 720 */ switch (schemeField.id) { +/* */ case 1: +/* 722 */ if (schemeField.type == 11) { +/* 723 */ struct.username = iprot.readString(); +/* 724 */ struct.setUsernameIsSet(true); +/* */ } else { +/* 726 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 728 */ break; +/* */ case 2: +/* 730 */ if (schemeField.type == 11) { +/* 731 */ struct.tenantId = iprot.readString(); +/* 732 */ struct.setTenantIdIsSet(true); +/* */ } else { +/* 734 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 736 */ break; +/* */ case 3: +/* 738 */ if (schemeField.type == 15) +/* */ { +/* 740 */ TList _list0 = iprot.readListBegin(); +/* 741 */ struct.roles = new ArrayList(_list0.size); +/* 742 */ for (int _i1 = 0; _i1 < _list0.size; _i1++) +/* */ { +/* 745 */ Role _elem2 = new Role(); +/* 746 */ _elem2.read(iprot); +/* 747 */ struct.roles.add(_elem2); +/* */ } +/* 749 */ iprot.readListEnd(); +/* */ +/* 751 */ struct.setRolesIsSet(true); +/* */ } else { +/* 753 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 755 */ break; +/* */ case 4: +/* 757 */ if (schemeField.type == 11) { +/* 758 */ struct.userId = iprot.readString(); +/* 759 */ struct.setUserIdIsSet(true); +/* */ } else { +/* 761 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 763 */ break; +/* */ case 5: +/* 765 */ if (schemeField.type == 11) { +/* 766 */ struct.tenantName = iprot.readString(); +/* 767 */ struct.setTenantNameIsSet(true); +/* */ } else { +/* 769 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 771 */ break; +/* */ case 6: +/* 773 */ if (schemeField.type == 11) { +/* 774 */ struct.swiftAccountHash = iprot.readString(); +/* 775 */ struct.setSwiftAccountHashIsSet(true); +/* */ } else { +/* 777 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 779 */ break; +/* */ default: +/* 781 */ TProtocolUtil.skip(iprot, schemeField.type); +/* */ } +/* 783 */ iprot.readFieldEnd(); +/* */ } +/* 785 */ iprot.readStructEnd(); +/* */ +/* 788 */ struct.validate(); +/* */ } +/* */ +/* */ public void write(TProtocol oprot, User struct) throws TException { +/* 792 */ struct.validate(); +/* */ +/* 794 */ oprot.writeStructBegin(User.STRUCT_DESC); +/* 795 */ if ((struct.username != null) && +/* 796 */ (struct.isSetUsername())) { +/* 797 */ oprot.writeFieldBegin(User.USERNAME_FIELD_DESC); +/* 798 */ oprot.writeString(struct.username); +/* 799 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 802 */ if ((struct.tenantId != null) && +/* 803 */ (struct.isSetTenantId())) { +/* 804 */ oprot.writeFieldBegin(User.TENANT_ID_FIELD_DESC); +/* 805 */ oprot.writeString(struct.tenantId); +/* 806 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 809 */ if ((struct.roles != null) && +/* 810 */ (struct.isSetRoles())) { +/* 811 */ oprot.writeFieldBegin(User.ROLES_FIELD_DESC); +/* */ +/* 813 */ oprot.writeListBegin(new TList((byte)12, struct.roles.size())); +/* 814 */ for (Role _iter3 : struct.roles) +/* */ { +/* 816 */ _iter3.write(oprot); +/* */ } +/* 818 */ oprot.writeListEnd(); +/* */ +/* 820 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 823 */ if ((struct.userId != null) && +/* 824 */ (struct.isSetUserId())) { +/* 825 */ oprot.writeFieldBegin(User.USER_ID_FIELD_DESC); +/* 826 */ oprot.writeString(struct.userId); +/* 827 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 830 */ if ((struct.tenantName != null) && +/* 831 */ (struct.isSetTenantName())) { +/* 832 */ oprot.writeFieldBegin(User.TENANT_NAME_FIELD_DESC); +/* 833 */ oprot.writeString(struct.tenantName); +/* 834 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 837 */ if ((struct.swiftAccountHash != null) && +/* 838 */ (struct.isSetSwiftAccountHash())) { +/* 839 */ oprot.writeFieldBegin(User.SWIFT_ACCOUNT_HASH_FIELD_DESC); +/* 840 */ oprot.writeString(struct.swiftAccountHash); +/* 841 */ oprot.writeFieldEnd(); +/* */ } +/* */ +/* 844 */ oprot.writeFieldStop(); +/* 845 */ oprot.writeStructEnd(); +/* */ } +/* */ } +/* */ +/* */ private static class UserStandardSchemeFactory +/* */ implements SchemeFactory +/* */ { +/* */ public User.UserStandardScheme getScheme() +/* */ { +/* 705 */ return new User.UserStandardScheme(); +/* */ } +/* */ } +/* */ +/* */ public static enum _Fields +/* */ implements TFieldIdEnum +/* */ { +/* 60 */ USERNAME((short)1, "username"), +/* 61 */ TENANT_ID((short)2, "tenantId"), +/* 62 */ ROLES((short)3, "roles"), +/* 63 */ USER_ID((short)4, "userId"), +/* 64 */ TENANT_NAME((short)5, "tenantName"), +/* 65 */ SWIFT_ACCOUNT_HASH((short)6, "swiftAccountHash"); +/* */ +/* */ private static final Map byName; +/* */ private final short _thriftId; +/* */ private final String _fieldName; +/* */ +/* */ public static _Fields findByThriftId(int fieldId) +/* */ { +/* 79 */ switch (fieldId) { +/* */ case 1: +/* 81 */ return USERNAME; +/* */ case 2: +/* 83 */ return TENANT_ID; +/* */ case 3: +/* 85 */ return ROLES; +/* */ case 4: +/* 87 */ return USER_ID; +/* */ case 5: +/* 89 */ return TENANT_NAME; +/* */ case 6: +/* 91 */ return SWIFT_ACCOUNT_HASH; +/* */ } +/* 93 */ return null; +/* */ } +/* */ +/* */ public static _Fields findByThriftIdOrThrow(int fieldId) +/* */ { +/* 102 */ _Fields fields = findByThriftId(fieldId); +/* 103 */ if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!"); +/* 104 */ return fields; +/* */ } +/* */ +/* */ public static _Fields findByName(String name) +/* */ { +/* 111 */ return (_Fields)byName.get(name); +/* */ } +/* */ +/* */ private _Fields(short thriftId, String fieldName) +/* */ { +/* 118 */ this._thriftId = thriftId; +/* 119 */ this._fieldName = fieldName; +/* */ } +/* */ +/* */ public short getThriftFieldId() { +/* 123 */ return this._thriftId; +/* */ } +/* */ +/* */ public String getFieldName() { +/* 127 */ return this._fieldName; +/* */ } +/* */ +/* */ static +/* */ { +/* 67 */ byName = new HashMap(); +/* */ +/* 70 */ for (_Fields field : EnumSet.allOf(_Fields.class)) +/* 71 */ byName.put(field.getFieldName(), field); +/* */ } +/* */ } +/* */ } + +/* Location: /Users/johnderr/.m2/repository/com/hp/csbu/cc/CsThriftModel/1.2-SNAPSHOT/CsThriftModel-1.2-20140130.160951-1223.jar + * Qualified Name: com.hp.csbu.cc.security.cs.thrift.service.User + * JD-Core Version: 0.6.2 + */ \ No newline at end of file diff --git a/src/main/java/com/hpcloud/mon/MonApiApplication.java b/src/main/java/com/hpcloud/mon/MonApiApplication.java index f180a96b8..20715e1e0 100644 --- a/src/main/java/com/hpcloud/mon/MonApiApplication.java +++ b/src/main/java/com/hpcloud/mon/MonApiApplication.java @@ -121,6 +121,10 @@ public class MonApiApplication extends Application { authInitParams.put("ConnRetryTimes", config.middleware.connRetryTimes); authInitParams.put("ConnRetryInterval", config.middleware.connRetryInterval); authInitParams.put("AdminToken", config.middleware.adminToken); + authInitParams.put("AdminAuthMethod", config.middleware.adminToken); + authInitParams.put("AdminUser", "admin"); + authInitParams.put("AdminPassword", "password"); + Dynamic tokenAuthFilter = environment.servlets().addFilter("token-auth", new TokenAuth());