cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From eev...@apache.org
Subject svn commit: r981070 - in /cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift: Cassandra.java KsDef.java
Date Sat, 31 Jul 2010 15:42:35 GMT
Author: eevans
Date: Sat Jul 31 15:42:34 2010
New Revision: 981070

URL: http://svn.apache.org/viewvc?rev=981070&view=rev
Log:
regenerated thrift code

Patch by eevans for CASSANDRA-1066

Modified:
    cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java
    cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/KsDef.java

Modified: cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java
URL: http://svn.apache.org/viewvc/cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java?rev=981070&r1=981069&r2=981070&view=diff
==============================================================================
--- cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java (original)
+++ cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/Cassandra.java Sat
Jul 31 15:42:34 2010
@@ -7154,14 +7154,14 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list37 = iprot.readListBegin();
-                this.success = new ArrayList<ColumnOrSuperColumn>(_list37.size);
-                for (int _i38 = 0; _i38 < _list37.size; ++_i38)
+                TList _list42 = iprot.readListBegin();
+                this.success = new ArrayList<ColumnOrSuperColumn>(_list42.size);
+                for (int _i43 = 0; _i43 < _list42.size; ++_i43)
                 {
-                  ColumnOrSuperColumn _elem39;
-                  _elem39 = new ColumnOrSuperColumn();
-                  _elem39.read(iprot);
-                  this.success.add(_elem39);
+                  ColumnOrSuperColumn _elem44;
+                  _elem44 = new ColumnOrSuperColumn();
+                  _elem44.read(iprot);
+                  this.success.add(_elem44);
                 }
                 iprot.readListEnd();
               }
@@ -7211,9 +7211,9 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (ColumnOrSuperColumn _iter40 : this.success)
+          for (ColumnOrSuperColumn _iter45 : this.success)
           {
-            _iter40.write(oprot);
+            _iter45.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -7756,13 +7756,13 @@ public class Cassandra {
           case 1: // KEYS
             if (field.type == TType.LIST) {
               {
-                TList _list41 = iprot.readListBegin();
-                this.keys = new ArrayList<byte[]>(_list41.size);
-                for (int _i42 = 0; _i42 < _list41.size; ++_i42)
+                TList _list46 = iprot.readListBegin();
+                this.keys = new ArrayList<byte[]>(_list46.size);
+                for (int _i47 = 0; _i47 < _list46.size; ++_i47)
                 {
-                  byte[] _elem43;
-                  _elem43 = iprot.readBinary();
-                  this.keys.add(_elem43);
+                  byte[] _elem48;
+                  _elem48 = iprot.readBinary();
+                  this.keys.add(_elem48);
                 }
                 iprot.readListEnd();
               }
@@ -7812,9 +7812,9 @@ public class Cassandra {
         oprot.writeFieldBegin(KEYS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.keys.size()));
-          for (byte[] _iter44 : this.keys)
+          for (byte[] _iter49 : this.keys)
           {
-            oprot.writeBinary(_iter44);
+            oprot.writeBinary(_iter49);
           }
           oprot.writeListEnd();
         }
@@ -8362,26 +8362,26 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.MAP) {
               {
-                TMap _map45 = iprot.readMapBegin();
-                this.success = new HashMap<byte[],List<ColumnOrSuperColumn>>(2*_map45.size);
-                for (int _i46 = 0; _i46 < _map45.size; ++_i46)
+                TMap _map50 = iprot.readMapBegin();
+                this.success = new HashMap<byte[],List<ColumnOrSuperColumn>>(2*_map50.size);
+                for (int _i51 = 0; _i51 < _map50.size; ++_i51)
                 {
-                  byte[] _key47;
-                  List<ColumnOrSuperColumn> _val48;
-                  _key47 = iprot.readBinary();
+                  byte[] _key52;
+                  List<ColumnOrSuperColumn> _val53;
+                  _key52 = iprot.readBinary();
                   {
-                    TList _list49 = iprot.readListBegin();
-                    _val48 = new ArrayList<ColumnOrSuperColumn>(_list49.size);
-                    for (int _i50 = 0; _i50 < _list49.size; ++_i50)
+                    TList _list54 = iprot.readListBegin();
+                    _val53 = new ArrayList<ColumnOrSuperColumn>(_list54.size);
+                    for (int _i55 = 0; _i55 < _list54.size; ++_i55)
                     {
-                      ColumnOrSuperColumn _elem51;
-                      _elem51 = new ColumnOrSuperColumn();
-                      _elem51.read(iprot);
-                      _val48.add(_elem51);
+                      ColumnOrSuperColumn _elem56;
+                      _elem56 = new ColumnOrSuperColumn();
+                      _elem56.read(iprot);
+                      _val53.add(_elem56);
                     }
                     iprot.readListEnd();
                   }
-                  this.success.put(_key47, _val48);
+                  this.success.put(_key52, _val53);
                 }
                 iprot.readMapEnd();
               }
@@ -8431,14 +8431,14 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeMapBegin(new TMap(TType.STRING, TType.LIST, this.success.size()));
-          for (Map.Entry<byte[], List<ColumnOrSuperColumn>> _iter52 : this.success.entrySet())
+          for (Map.Entry<byte[], List<ColumnOrSuperColumn>> _iter57 : this.success.entrySet())
           {
-            oprot.writeBinary(_iter52.getKey());
+            oprot.writeBinary(_iter57.getKey());
             {
-              oprot.writeListBegin(new TList(TType.STRUCT, _iter52.getValue().size()));
-              for (ColumnOrSuperColumn _iter53 : _iter52.getValue())
+              oprot.writeListBegin(new TList(TType.STRUCT, _iter57.getValue().size()));
+              for (ColumnOrSuperColumn _iter58 : _iter57.getValue())
               {
-                _iter53.write(oprot);
+                _iter58.write(oprot);
               }
               oprot.writeListEnd();
             }
@@ -10184,13 +10184,13 @@ public class Cassandra {
           case 2: // KEYS
             if (field.type == TType.LIST) {
               {
-                TList _list54 = iprot.readListBegin();
-                this.keys = new ArrayList<byte[]>(_list54.size);
-                for (int _i55 = 0; _i55 < _list54.size; ++_i55)
+                TList _list59 = iprot.readListBegin();
+                this.keys = new ArrayList<byte[]>(_list59.size);
+                for (int _i60 = 0; _i60 < _list59.size; ++_i60)
                 {
-                  byte[] _elem56;
-                  _elem56 = iprot.readBinary();
-                  this.keys.add(_elem56);
+                  byte[] _elem61;
+                  _elem61 = iprot.readBinary();
+                  this.keys.add(_elem61);
                 }
                 iprot.readListEnd();
               }
@@ -10245,9 +10245,9 @@ public class Cassandra {
         oprot.writeFieldBegin(KEYS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.keys.size()));
-          for (byte[] _iter57 : this.keys)
+          for (byte[] _iter62 : this.keys)
           {
-            oprot.writeBinary(_iter57);
+            oprot.writeBinary(_iter62);
           }
           oprot.writeListEnd();
         }
@@ -10802,15 +10802,15 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.MAP) {
               {
-                TMap _map58 = iprot.readMapBegin();
-                this.success = new HashMap<byte[],Integer>(2*_map58.size);
-                for (int _i59 = 0; _i59 < _map58.size; ++_i59)
+                TMap _map63 = iprot.readMapBegin();
+                this.success = new HashMap<byte[],Integer>(2*_map63.size);
+                for (int _i64 = 0; _i64 < _map63.size; ++_i64)
                 {
-                  byte[] _key60;
-                  int _val61;
-                  _key60 = iprot.readBinary();
-                  _val61 = iprot.readI32();
-                  this.success.put(_key60, _val61);
+                  byte[] _key65;
+                  int _val66;
+                  _key65 = iprot.readBinary();
+                  _val66 = iprot.readI32();
+                  this.success.put(_key65, _val66);
                 }
                 iprot.readMapEnd();
               }
@@ -10860,10 +10860,10 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeMapBegin(new TMap(TType.STRING, TType.I32, this.success.size()));
-          for (Map.Entry<byte[], Integer> _iter62 : this.success.entrySet())
+          for (Map.Entry<byte[], Integer> _iter67 : this.success.entrySet())
           {
-            oprot.writeBinary(_iter62.getKey());
-            oprot.writeI32(_iter62.getValue());
+            oprot.writeBinary(_iter67.getKey());
+            oprot.writeI32(_iter67.getValue());
           }
           oprot.writeMapEnd();
         }
@@ -11964,14 +11964,14 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list63 = iprot.readListBegin();
-                this.success = new ArrayList<KeySlice>(_list63.size);
-                for (int _i64 = 0; _i64 < _list63.size; ++_i64)
+                TList _list68 = iprot.readListBegin();
+                this.success = new ArrayList<KeySlice>(_list68.size);
+                for (int _i69 = 0; _i69 < _list68.size; ++_i69)
                 {
-                  KeySlice _elem65;
-                  _elem65 = new KeySlice();
-                  _elem65.read(iprot);
-                  this.success.add(_elem65);
+                  KeySlice _elem70;
+                  _elem70 = new KeySlice();
+                  _elem70.read(iprot);
+                  this.success.add(_elem70);
                 }
                 iprot.readListEnd();
               }
@@ -12021,9 +12021,9 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (KeySlice _iter66 : this.success)
+          for (KeySlice _iter71 : this.success)
           {
-            _iter66.write(oprot);
+            _iter71.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -13124,14 +13124,14 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list67 = iprot.readListBegin();
-                this.success = new ArrayList<KeySlice>(_list67.size);
-                for (int _i68 = 0; _i68 < _list67.size; ++_i68)
+                TList _list72 = iprot.readListBegin();
+                this.success = new ArrayList<KeySlice>(_list72.size);
+                for (int _i73 = 0; _i73 < _list72.size; ++_i73)
                 {
-                  KeySlice _elem69;
-                  _elem69 = new KeySlice();
-                  _elem69.read(iprot);
-                  this.success.add(_elem69);
+                  KeySlice _elem74;
+                  _elem74 = new KeySlice();
+                  _elem74.read(iprot);
+                  this.success.add(_elem74);
                 }
                 iprot.readListEnd();
               }
@@ -13181,9 +13181,9 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (KeySlice _iter70 : this.success)
+          for (KeySlice _iter75 : this.success)
           {
-            _iter70.write(oprot);
+            _iter75.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -14284,14 +14284,14 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list71 = iprot.readListBegin();
-                this.success = new ArrayList<KeyCount>(_list71.size);
-                for (int _i72 = 0; _i72 < _list71.size; ++_i72)
+                TList _list76 = iprot.readListBegin();
+                this.success = new ArrayList<KeyCount>(_list76.size);
+                for (int _i77 = 0; _i77 < _list76.size; ++_i77)
                 {
-                  KeyCount _elem73;
-                  _elem73 = new KeyCount();
-                  _elem73.read(iprot);
-                  this.success.add(_elem73);
+                  KeyCount _elem78;
+                  _elem78 = new KeyCount();
+                  _elem78.read(iprot);
+                  this.success.add(_elem78);
                 }
                 iprot.readListEnd();
               }
@@ -14341,9 +14341,9 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (KeyCount _iter74 : this.success)
+          for (KeyCount _iter79 : this.success)
           {
-            _iter74.write(oprot);
+            _iter79.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -16852,38 +16852,38 @@ public class Cassandra {
           case 1: // MUTATION_MAP
             if (field.type == TType.MAP) {
               {
-                TMap _map75 = iprot.readMapBegin();
-                this.mutation_map = new HashMap<byte[],Map<String,List<Mutation>>>(2*_map75.size);
-                for (int _i76 = 0; _i76 < _map75.size; ++_i76)
+                TMap _map80 = iprot.readMapBegin();
+                this.mutation_map = new HashMap<byte[],Map<String,List<Mutation>>>(2*_map80.size);
+                for (int _i81 = 0; _i81 < _map80.size; ++_i81)
                 {
-                  byte[] _key77;
-                  Map<String,List<Mutation>> _val78;
-                  _key77 = iprot.readBinary();
+                  byte[] _key82;
+                  Map<String,List<Mutation>> _val83;
+                  _key82 = iprot.readBinary();
                   {
-                    TMap _map79 = iprot.readMapBegin();
-                    _val78 = new HashMap<String,List<Mutation>>(2*_map79.size);
-                    for (int _i80 = 0; _i80 < _map79.size; ++_i80)
+                    TMap _map84 = iprot.readMapBegin();
+                    _val83 = new HashMap<String,List<Mutation>>(2*_map84.size);
+                    for (int _i85 = 0; _i85 < _map84.size; ++_i85)
                     {
-                      String _key81;
-                      List<Mutation> _val82;
-                      _key81 = iprot.readString();
+                      String _key86;
+                      List<Mutation> _val87;
+                      _key86 = iprot.readString();
                       {
-                        TList _list83 = iprot.readListBegin();
-                        _val82 = new ArrayList<Mutation>(_list83.size);
-                        for (int _i84 = 0; _i84 < _list83.size; ++_i84)
+                        TList _list88 = iprot.readListBegin();
+                        _val87 = new ArrayList<Mutation>(_list88.size);
+                        for (int _i89 = 0; _i89 < _list88.size; ++_i89)
                         {
-                          Mutation _elem85;
-                          _elem85 = new Mutation();
-                          _elem85.read(iprot);
-                          _val82.add(_elem85);
+                          Mutation _elem90;
+                          _elem90 = new Mutation();
+                          _elem90.read(iprot);
+                          _val87.add(_elem90);
                         }
                         iprot.readListEnd();
                       }
-                      _val78.put(_key81, _val82);
+                      _val83.put(_key86, _val87);
                     }
                     iprot.readMapEnd();
                   }
-                  this.mutation_map.put(_key77, _val78);
+                  this.mutation_map.put(_key82, _val83);
                 }
                 iprot.readMapEnd();
               }
@@ -16917,19 +16917,19 @@ public class Cassandra {
         oprot.writeFieldBegin(MUTATION_MAP_FIELD_DESC);
         {
           oprot.writeMapBegin(new TMap(TType.STRING, TType.MAP, this.mutation_map.size()));
-          for (Map.Entry<byte[], Map<String,List<Mutation>>> _iter86 :
this.mutation_map.entrySet())
+          for (Map.Entry<byte[], Map<String,List<Mutation>>> _iter91 :
this.mutation_map.entrySet())
           {
-            oprot.writeBinary(_iter86.getKey());
+            oprot.writeBinary(_iter91.getKey());
             {
-              oprot.writeMapBegin(new TMap(TType.STRING, TType.LIST, _iter86.getValue().size()));
-              for (Map.Entry<String, List<Mutation>> _iter87 : _iter86.getValue().entrySet())
+              oprot.writeMapBegin(new TMap(TType.STRING, TType.LIST, _iter91.getValue().size()));
+              for (Map.Entry<String, List<Mutation>> _iter92 : _iter91.getValue().entrySet())
               {
-                oprot.writeString(_iter87.getKey());
+                oprot.writeString(_iter92.getKey());
                 {
-                  oprot.writeListBegin(new TList(TType.STRUCT, _iter87.getValue().size()));
-                  for (Mutation _iter88 : _iter87.getValue())
+                  oprot.writeListBegin(new TList(TType.STRUCT, _iter92.getValue().size()));
+                  for (Mutation _iter93 : _iter92.getValue())
                   {
-                    _iter88.write(oprot);
+                    _iter93.write(oprot);
                   }
                   oprot.writeListEnd();
                 }
@@ -18623,25 +18623,25 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.MAP) {
               {
-                TMap _map89 = iprot.readMapBegin();
-                this.success = new HashMap<String,List<String>>(2*_map89.size);
-                for (int _i90 = 0; _i90 < _map89.size; ++_i90)
+                TMap _map94 = iprot.readMapBegin();
+                this.success = new HashMap<String,List<String>>(2*_map94.size);
+                for (int _i95 = 0; _i95 < _map94.size; ++_i95)
                 {
-                  String _key91;
-                  List<String> _val92;
-                  _key91 = iprot.readString();
+                  String _key96;
+                  List<String> _val97;
+                  _key96 = iprot.readString();
                   {
-                    TList _list93 = iprot.readListBegin();
-                    _val92 = new ArrayList<String>(_list93.size);
-                    for (int _i94 = 0; _i94 < _list93.size; ++_i94)
+                    TList _list98 = iprot.readListBegin();
+                    _val97 = new ArrayList<String>(_list98.size);
+                    for (int _i99 = 0; _i99 < _list98.size; ++_i99)
                     {
-                      String _elem95;
-                      _elem95 = iprot.readString();
-                      _val92.add(_elem95);
+                      String _elem100;
+                      _elem100 = iprot.readString();
+                      _val97.add(_elem100);
                     }
                     iprot.readListEnd();
                   }
-                  this.success.put(_key91, _val92);
+                  this.success.put(_key96, _val97);
                 }
                 iprot.readMapEnd();
               }
@@ -18675,14 +18675,14 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeMapBegin(new TMap(TType.STRING, TType.LIST, this.success.size()));
-          for (Map.Entry<String, List<String>> _iter96 : this.success.entrySet())
+          for (Map.Entry<String, List<String>> _iter101 : this.success.entrySet())
           {
-            oprot.writeString(_iter96.getKey());
+            oprot.writeString(_iter101.getKey());
             {
-              oprot.writeListBegin(new TList(TType.STRING, _iter96.getValue().size()));
-              for (String _iter97 : _iter96.getValue())
+              oprot.writeListBegin(new TList(TType.STRING, _iter101.getValue().size()));
+              for (String _iter102 : _iter101.getValue())
               {
-                oprot.writeString(_iter97);
+                oprot.writeString(_iter102);
               }
               oprot.writeListEnd();
             }
@@ -19174,13 +19174,13 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.SET) {
               {
-                TSet _set98 = iprot.readSetBegin();
-                this.success = new HashSet<String>(2*_set98.size);
-                for (int _i99 = 0; _i99 < _set98.size; ++_i99)
+                TSet _set103 = iprot.readSetBegin();
+                this.success = new HashSet<String>(2*_set103.size);
+                for (int _i104 = 0; _i104 < _set103.size; ++_i104)
                 {
-                  String _elem100;
-                  _elem100 = iprot.readString();
-                  this.success.add(_elem100);
+                  String _elem105;
+                  _elem105 = iprot.readString();
+                  this.success.add(_elem105);
                 }
                 iprot.readSetEnd();
               }
@@ -19206,9 +19206,9 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeSetBegin(new TSet(TType.STRING, this.success.size()));
-          for (String _iter101 : this.success)
+          for (String _iter106 : this.success)
           {
-            oprot.writeString(_iter101);
+            oprot.writeString(_iter106);
           }
           oprot.writeSetEnd();
         }
@@ -20796,14 +20796,14 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list102 = iprot.readListBegin();
-                this.success = new ArrayList<TokenRange>(_list102.size);
-                for (int _i103 = 0; _i103 < _list102.size; ++_i103)
+                TList _list107 = iprot.readListBegin();
+                this.success = new ArrayList<TokenRange>(_list107.size);
+                for (int _i108 = 0; _i108 < _list107.size; ++_i108)
                 {
-                  TokenRange _elem104;
-                  _elem104 = new TokenRange();
-                  _elem104.read(iprot);
-                  this.success.add(_elem104);
+                  TokenRange _elem109;
+                  _elem109 = new TokenRange();
+                  _elem109.read(iprot);
+                  this.success.add(_elem109);
                 }
                 iprot.readListEnd();
               }
@@ -20837,9 +20837,9 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (TokenRange _iter105 : this.success)
+          for (TokenRange _iter110 : this.success)
           {
-            _iter105.write(oprot);
+            _iter110.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -21983,27 +21983,27 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.MAP) {
               {
-                TMap _map106 = iprot.readMapBegin();
-                this.success = new HashMap<String,Map<String,String>>(2*_map106.size);
-                for (int _i107 = 0; _i107 < _map106.size; ++_i107)
+                TMap _map111 = iprot.readMapBegin();
+                this.success = new HashMap<String,Map<String,String>>(2*_map111.size);
+                for (int _i112 = 0; _i112 < _map111.size; ++_i112)
                 {
-                  String _key108;
-                  Map<String,String> _val109;
-                  _key108 = iprot.readString();
+                  String _key113;
+                  Map<String,String> _val114;
+                  _key113 = iprot.readString();
                   {
-                    TMap _map110 = iprot.readMapBegin();
-                    _val109 = new HashMap<String,String>(2*_map110.size);
-                    for (int _i111 = 0; _i111 < _map110.size; ++_i111)
+                    TMap _map115 = iprot.readMapBegin();
+                    _val114 = new HashMap<String,String>(2*_map115.size);
+                    for (int _i116 = 0; _i116 < _map115.size; ++_i116)
                     {
-                      String _key112;
-                      String _val113;
-                      _key112 = iprot.readString();
-                      _val113 = iprot.readString();
-                      _val109.put(_key112, _val113);
+                      String _key117;
+                      String _val118;
+                      _key117 = iprot.readString();
+                      _val118 = iprot.readString();
+                      _val114.put(_key117, _val118);
                     }
                     iprot.readMapEnd();
                   }
-                  this.success.put(_key108, _val109);
+                  this.success.put(_key113, _val114);
                 }
                 iprot.readMapEnd();
               }
@@ -22037,15 +22037,15 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeMapBegin(new TMap(TType.STRING, TType.MAP, this.success.size()));
-          for (Map.Entry<String, Map<String,String>> _iter114 : this.success.entrySet())
+          for (Map.Entry<String, Map<String,String>> _iter119 : this.success.entrySet())
           {
-            oprot.writeString(_iter114.getKey());
+            oprot.writeString(_iter119.getKey());
             {
-              oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, _iter114.getValue().size()));
-              for (Map.Entry<String, String> _iter115 : _iter114.getValue().entrySet())
+              oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, _iter119.getValue().size()));
+              for (Map.Entry<String, String> _iter120 : _iter119.getValue().entrySet())
               {
-                oprot.writeString(_iter115.getKey());
-                oprot.writeString(_iter115.getValue());
+                oprot.writeString(_iter120.getKey());
+                oprot.writeString(_iter120.getValue());
               }
               oprot.writeMapEnd();
             }
@@ -22991,13 +22991,13 @@ public class Cassandra {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list116 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list116.size);
-                for (int _i117 = 0; _i117 < _list116.size; ++_i117)
+                TList _list121 = iprot.readListBegin();
+                this.success = new ArrayList<String>(_list121.size);
+                for (int _i122 = 0; _i122 < _list121.size; ++_i122)
                 {
-                  String _elem118;
-                  _elem118 = iprot.readString();
-                  this.success.add(_elem118);
+                  String _elem123;
+                  _elem123 = iprot.readString();
+                  this.success.add(_elem123);
                 }
                 iprot.readListEnd();
               }
@@ -23023,9 +23023,9 @@ public class Cassandra {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
-          for (String _iter119 : this.success)
+          for (String _iter124 : this.success)
           {
-            oprot.writeString(_iter119);
+            oprot.writeString(_iter124);
           }
           oprot.writeListEnd();
         }

Modified: cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/KsDef.java
URL: http://svn.apache.org/viewvc/cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/KsDef.java?rev=981070&r1=981069&r2=981070&view=diff
==============================================================================
--- cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/KsDef.java (original)
+++ cassandra/trunk/interface/thrift/gen-java/org/apache/cassandra/thrift/KsDef.java Sat Jul
31 15:42:34 2010
@@ -51,11 +51,13 @@ public class KsDef implements TBase<KsDe
 
   private static final TField NAME_FIELD_DESC = new TField("name", TType.STRING, (short)1);
   private static final TField STRATEGY_CLASS_FIELD_DESC = new TField("strategy_class", TType.STRING,
(short)2);
-  private static final TField REPLICATION_FACTOR_FIELD_DESC = new TField("replication_factor",
TType.I32, (short)3);
+  private static final TField STRATEGY_OPTIONS_FIELD_DESC = new TField("strategy_options",
TType.MAP, (short)3);
+  private static final TField REPLICATION_FACTOR_FIELD_DESC = new TField("replication_factor",
TType.I32, (short)4);
   private static final TField CF_DEFS_FIELD_DESC = new TField("cf_defs", TType.LIST, (short)5);
 
   public String name;
   public String strategy_class;
+  public Map<String,String> strategy_options;
   public int replication_factor;
   public List<CfDef> cf_defs;
 
@@ -63,7 +65,8 @@ public class KsDef implements TBase<KsDe
   public enum _Fields implements TFieldIdEnum {
     NAME((short)1, "name"),
     STRATEGY_CLASS((short)2, "strategy_class"),
-    REPLICATION_FACTOR((short)3, "replication_factor"),
+    STRATEGY_OPTIONS((short)3, "strategy_options"),
+    REPLICATION_FACTOR((short)4, "replication_factor"),
     CF_DEFS((short)5, "cf_defs");
 
     private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
@@ -83,7 +86,9 @@ public class KsDef implements TBase<KsDe
           return NAME;
         case 2: // STRATEGY_CLASS
           return STRATEGY_CLASS;
-        case 3: // REPLICATION_FACTOR
+        case 3: // STRATEGY_OPTIONS
+          return STRATEGY_OPTIONS;
+        case 4: // REPLICATION_FACTOR
           return REPLICATION_FACTOR;
         case 5: // CF_DEFS
           return CF_DEFS;
@@ -137,6 +142,10 @@ public class KsDef implements TBase<KsDe
         new FieldValueMetaData(TType.STRING)));
     tmpMap.put(_Fields.STRATEGY_CLASS, new FieldMetaData("strategy_class", TFieldRequirementType.REQUIRED,

         new FieldValueMetaData(TType.STRING)));
+    tmpMap.put(_Fields.STRATEGY_OPTIONS, new FieldMetaData("strategy_options", TFieldRequirementType.OPTIONAL,

+        new MapMetaData(TType.MAP, 
+            new FieldValueMetaData(TType.STRING), 
+            new FieldValueMetaData(TType.STRING))));
     tmpMap.put(_Fields.REPLICATION_FACTOR, new FieldMetaData("replication_factor", TFieldRequirementType.REQUIRED,

         new FieldValueMetaData(TType.I32)));
     tmpMap.put(_Fields.CF_DEFS, new FieldMetaData("cf_defs", TFieldRequirementType.REQUIRED,

@@ -175,6 +184,21 @@ public class KsDef implements TBase<KsDe
     if (other.isSetStrategy_class()) {
       this.strategy_class = other.strategy_class;
     }
+    if (other.isSetStrategy_options()) {
+      Map<String,String> __this__strategy_options = new HashMap<String,String>();
+      for (Map.Entry<String, String> other_element : other.strategy_options.entrySet())
{
+
+        String other_element_key = other_element.getKey();
+        String other_element_value = other_element.getValue();
+
+        String __this__strategy_options_copy_key = other_element_key;
+
+        String __this__strategy_options_copy_value = other_element_value;
+
+        __this__strategy_options.put(__this__strategy_options_copy_key, __this__strategy_options_copy_value);
+      }
+      this.strategy_options = __this__strategy_options;
+    }
     this.replication_factor = other.replication_factor;
     if (other.isSetCf_defs()) {
       List<CfDef> __this__cf_defs = new ArrayList<CfDef>();
@@ -242,6 +266,41 @@ public class KsDef implements TBase<KsDe
     }
   }
 
+  public int getStrategy_optionsSize() {
+    return (this.strategy_options == null) ? 0 : this.strategy_options.size();
+  }
+
+  public void putToStrategy_options(String key, String val) {
+    if (this.strategy_options == null) {
+      this.strategy_options = new HashMap<String,String>();
+    }
+    this.strategy_options.put(key, val);
+  }
+
+  public Map<String,String> getStrategy_options() {
+    return this.strategy_options;
+  }
+
+  public KsDef setStrategy_options(Map<String,String> strategy_options) {
+    this.strategy_options = strategy_options;
+    return this;
+  }
+
+  public void unsetStrategy_options() {
+    this.strategy_options = null;
+  }
+
+  /** Returns true if field strategy_options is set (has been asigned a value) and false
otherwise */
+  public boolean isSetStrategy_options() {
+    return this.strategy_options != null;
+  }
+
+  public void setStrategy_optionsIsSet(boolean value) {
+    if (!value) {
+      this.strategy_options = null;
+    }
+  }
+
   public int getReplication_factor() {
     return this.replication_factor;
   }
@@ -322,6 +381,14 @@ public class KsDef implements TBase<KsDe
       }
       break;
 
+    case STRATEGY_OPTIONS:
+      if (value == null) {
+        unsetStrategy_options();
+      } else {
+        setStrategy_options((Map<String,String>)value);
+      }
+      break;
+
     case REPLICATION_FACTOR:
       if (value == null) {
         unsetReplication_factor();
@@ -353,6 +420,9 @@ public class KsDef implements TBase<KsDe
     case STRATEGY_CLASS:
       return getStrategy_class();
 
+    case STRATEGY_OPTIONS:
+      return getStrategy_options();
+
     case REPLICATION_FACTOR:
       return new Integer(getReplication_factor());
 
@@ -374,6 +444,8 @@ public class KsDef implements TBase<KsDe
       return isSetName();
     case STRATEGY_CLASS:
       return isSetStrategy_class();
+    case STRATEGY_OPTIONS:
+      return isSetStrategy_options();
     case REPLICATION_FACTOR:
       return isSetReplication_factor();
     case CF_DEFS:
@@ -417,6 +489,15 @@ public class KsDef implements TBase<KsDe
         return false;
     }
 
+    boolean this_present_strategy_options = true && this.isSetStrategy_options();
+    boolean that_present_strategy_options = true && that.isSetStrategy_options();
+    if (this_present_strategy_options || that_present_strategy_options) {
+      if (!(this_present_strategy_options && that_present_strategy_options))
+        return false;
+      if (!this.strategy_options.equals(that.strategy_options))
+        return false;
+    }
+
     boolean this_present_replication_factor = true;
     boolean that_present_replication_factor = true;
     if (this_present_replication_factor || that_present_replication_factor) {
@@ -469,6 +550,15 @@ public class KsDef implements TBase<KsDe
         return lastComparison;
       }
     }
+    lastComparison = Boolean.valueOf(isSetStrategy_options()).compareTo(typedOther.isSetStrategy_options());
+    if (lastComparison != 0) {
+      return lastComparison;
+    }
+    if (isSetStrategy_options()) {      lastComparison = TBaseHelper.compareTo(this.strategy_options,
typedOther.strategy_options);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+    }
     lastComparison = Boolean.valueOf(isSetReplication_factor()).compareTo(typedOther.isSetReplication_factor());
     if (lastComparison != 0) {
       return lastComparison;
@@ -514,7 +604,26 @@ public class KsDef implements TBase<KsDe
             TProtocolUtil.skip(iprot, field.type);
           }
           break;
-        case 3: // REPLICATION_FACTOR
+        case 3: // STRATEGY_OPTIONS
+          if (field.type == TType.MAP) {
+            {
+              TMap _map33 = iprot.readMapBegin();
+              this.strategy_options = new HashMap<String,String>(2*_map33.size);
+              for (int _i34 = 0; _i34 < _map33.size; ++_i34)
+              {
+                String _key35;
+                String _val36;
+                _key35 = iprot.readString();
+                _val36 = iprot.readString();
+                this.strategy_options.put(_key35, _val36);
+              }
+              iprot.readMapEnd();
+            }
+          } else { 
+            TProtocolUtil.skip(iprot, field.type);
+          }
+          break;
+        case 4: // REPLICATION_FACTOR
           if (field.type == TType.I32) {
             this.replication_factor = iprot.readI32();
             setReplication_factorIsSet(true);
@@ -525,14 +634,14 @@ public class KsDef implements TBase<KsDe
         case 5: // CF_DEFS
           if (field.type == TType.LIST) {
             {
-              TList _list33 = iprot.readListBegin();
-              this.cf_defs = new ArrayList<CfDef>(_list33.size);
-              for (int _i34 = 0; _i34 < _list33.size; ++_i34)
+              TList _list37 = iprot.readListBegin();
+              this.cf_defs = new ArrayList<CfDef>(_list37.size);
+              for (int _i38 = 0; _i38 < _list37.size; ++_i38)
               {
-                CfDef _elem35;
-                _elem35 = new CfDef();
-                _elem35.read(iprot);
-                this.cf_defs.add(_elem35);
+                CfDef _elem39;
+                _elem39 = new CfDef();
+                _elem39.read(iprot);
+                this.cf_defs.add(_elem39);
               }
               iprot.readListEnd();
             }
@@ -568,6 +677,21 @@ public class KsDef implements TBase<KsDe
       oprot.writeString(this.strategy_class);
       oprot.writeFieldEnd();
     }
+    if (this.strategy_options != null) {
+      if (isSetStrategy_options()) {
+        oprot.writeFieldBegin(STRATEGY_OPTIONS_FIELD_DESC);
+        {
+          oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.strategy_options.size()));
+          for (Map.Entry<String, String> _iter40 : this.strategy_options.entrySet())
+          {
+            oprot.writeString(_iter40.getKey());
+            oprot.writeString(_iter40.getValue());
+          }
+          oprot.writeMapEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+    }
     oprot.writeFieldBegin(REPLICATION_FACTOR_FIELD_DESC);
     oprot.writeI32(this.replication_factor);
     oprot.writeFieldEnd();
@@ -575,9 +699,9 @@ public class KsDef implements TBase<KsDe
       oprot.writeFieldBegin(CF_DEFS_FIELD_DESC);
       {
         oprot.writeListBegin(new TList(TType.STRUCT, this.cf_defs.size()));
-        for (CfDef _iter36 : this.cf_defs)
+        for (CfDef _iter41 : this.cf_defs)
         {
-          _iter36.write(oprot);
+          _iter41.write(oprot);
         }
         oprot.writeListEnd();
       }
@@ -607,6 +731,16 @@ public class KsDef implements TBase<KsDe
       sb.append(this.strategy_class);
     }
     first = false;
+    if (isSetStrategy_options()) {
+      if (!first) sb.append(", ");
+      sb.append("strategy_options:");
+      if (this.strategy_options == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.strategy_options);
+      }
+      first = false;
+    }
     if (!first) sb.append(", ");
     sb.append("replication_factor:");
     sb.append(this.replication_factor);



Mime
View raw message