incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [1/7] Inital commit of the top command in the blur-shell.
Date Sat, 22 Jun 2013 21:07:02 GMT
Updated Branches:
  refs/heads/master b2d9f8bcf -> 3f197a101


http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/7137006b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
index e001421..225d00e 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Blur.pm
@@ -100,15 +100,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size156 = 0;
+          my $_size183 = 0;
           $self->{success} = [];
-          my $_etype159 = 0;
-          $xfer += $input->readListBegin(\$_etype159, \$_size156);
-          for (my $_i160 = 0; $_i160 < $_size156; ++$_i160)
+          my $_etype186 = 0;
+          $xfer += $input->readListBegin(\$_etype186, \$_size183);
+          for (my $_i187 = 0; $_i187 < $_size183; ++$_i187)
           {
-            my $elem161 = undef;
-            $xfer += $input->readString(\$elem161);
-            push(@{$self->{success}},$elem161);
+            my $elem188 = undef;
+            $xfer += $input->readString(\$elem188);
+            push(@{$self->{success}},$elem188);
           }
           $xfer += $input->readListEnd();
         }
@@ -140,9 +140,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter162 (@{$self->{success}}) 
+        foreach my $iter189 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter162);
+          $xfer += $output->writeString($iter189);
         }
       }
       $xfer += $output->writeListEnd();
@@ -265,15 +265,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size163 = 0;
+          my $_size190 = 0;
           $self->{success} = [];
-          my $_etype166 = 0;
-          $xfer += $input->readListBegin(\$_etype166, \$_size163);
-          for (my $_i167 = 0; $_i167 < $_size163; ++$_i167)
+          my $_etype193 = 0;
+          $xfer += $input->readListBegin(\$_etype193, \$_size190);
+          for (my $_i194 = 0; $_i194 < $_size190; ++$_i194)
           {
-            my $elem168 = undef;
-            $xfer += $input->readString(\$elem168);
-            push(@{$self->{success}},$elem168);
+            my $elem195 = undef;
+            $xfer += $input->readString(\$elem195);
+            push(@{$self->{success}},$elem195);
           }
           $xfer += $input->readListEnd();
         }
@@ -305,9 +305,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter169 (@{$self->{success}}) 
+        foreach my $iter196 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter169);
+          $xfer += $output->writeString($iter196);
         }
       }
       $xfer += $output->writeListEnd();
@@ -412,15 +412,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size170 = 0;
+          my $_size197 = 0;
           $self->{success} = [];
-          my $_etype173 = 0;
-          $xfer += $input->readListBegin(\$_etype173, \$_size170);
-          for (my $_i174 = 0; $_i174 < $_size170; ++$_i174)
+          my $_etype200 = 0;
+          $xfer += $input->readListBegin(\$_etype200, \$_size197);
+          for (my $_i201 = 0; $_i201 < $_size197; ++$_i201)
           {
-            my $elem175 = undef;
-            $xfer += $input->readString(\$elem175);
-            push(@{$self->{success}},$elem175);
+            my $elem202 = undef;
+            $xfer += $input->readString(\$elem202);
+            push(@{$self->{success}},$elem202);
           }
           $xfer += $input->readListEnd();
         }
@@ -452,9 +452,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter176 (@{$self->{success}}) 
+        foreach my $iter203 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter176);
+          $xfer += $output->writeString($iter203);
         }
       }
       $xfer += $output->writeListEnd();
@@ -577,18 +577,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size177 = 0;
+          my $_size204 = 0;
           $self->{success} = {};
-          my $_ktype178 = 0;
-          my $_vtype179 = 0;
-          $xfer += $input->readMapBegin(\$_ktype178, \$_vtype179, \$_size177);
-          for (my $_i181 = 0; $_i181 < $_size177; ++$_i181)
+          my $_ktype205 = 0;
+          my $_vtype206 = 0;
+          $xfer += $input->readMapBegin(\$_ktype205, \$_vtype206, \$_size204);
+          for (my $_i208 = 0; $_i208 < $_size204; ++$_i208)
           {
-            my $key182 = '';
-            my $val183 = '';
-            $xfer += $input->readString(\$key182);
-            $xfer += $input->readString(\$val183);
-            $self->{success}->{$key182} = $val183;
+            my $key209 = '';
+            my $val210 = '';
+            $xfer += $input->readString(\$key209);
+            $xfer += $input->readString(\$val210);
+            $self->{success}->{$key209} = $val210;
           }
           $xfer += $input->readMapEnd();
         }
@@ -620,10 +620,10 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter184,$viter185) = each %{$self->{success}}) 
+        while( my ($kiter211,$viter212) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter184);
-          $xfer += $output->writeString($viter185);
+          $xfer += $output->writeString($kiter211);
+          $xfer += $output->writeString($viter212);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -746,33 +746,33 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size186 = 0;
+          my $_size213 = 0;
           $self->{success} = {};
-          my $_ktype187 = 0;
-          my $_vtype188 = 0;
-          $xfer += $input->readMapBegin(\$_ktype187, \$_vtype188, \$_size186);
-          for (my $_i190 = 0; $_i190 < $_size186; ++$_i190)
+          my $_ktype214 = 0;
+          my $_vtype215 = 0;
+          $xfer += $input->readMapBegin(\$_ktype214, \$_vtype215, \$_size213);
+          for (my $_i217 = 0; $_i217 < $_size213; ++$_i217)
           {
-            my $key191 = '';
-            my $val192 = [];
-            $xfer += $input->readString(\$key191);
+            my $key218 = '';
+            my $val219 = [];
+            $xfer += $input->readString(\$key218);
             {
-              my $_size193 = 0;
-              $val192 = {};
-              my $_ktype194 = 0;
-              my $_vtype195 = 0;
-              $xfer += $input->readMapBegin(\$_ktype194, \$_vtype195, \$_size193);
-              for (my $_i197 = 0; $_i197 < $_size193; ++$_i197)
+              my $_size220 = 0;
+              $val219 = {};
+              my $_ktype221 = 0;
+              my $_vtype222 = 0;
+              $xfer += $input->readMapBegin(\$_ktype221, \$_vtype222, \$_size220);
+              for (my $_i224 = 0; $_i224 < $_size220; ++$_i224)
               {
-                my $key198 = '';
-                my $val199 = 0;
-                $xfer += $input->readString(\$key198);
-                $xfer += $input->readI32(\$val199);
-                $val192->{$key198} = $val199;
+                my $key225 = '';
+                my $val226 = 0;
+                $xfer += $input->readString(\$key225);
+                $xfer += $input->readI32(\$val226);
+                $val219->{$key225} = $val226;
               }
               $xfer += $input->readMapEnd();
             }
-            $self->{success}->{$key191} = $val192;
+            $self->{success}->{$key218} = $val219;
           }
           $xfer += $input->readMapEnd();
         }
@@ -804,16 +804,16 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::MAP, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter200,$viter201) = each %{$self->{success}}) 
+        while( my ($kiter227,$viter228) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter200);
+          $xfer += $output->writeString($kiter227);
           {
-            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter201}}));
+            $xfer += $output->writeMapBegin(TType::STRING, TType::I32, scalar(keys %{${viter228}}));
             {
-              while( my ($kiter202,$viter203) = each %{${viter201}}) 
+              while( my ($kiter229,$viter230) = each %{${viter228}}) 
               {
-                $xfer += $output->writeString($kiter202);
-                $xfer += $output->writeI32($viter203);
+                $xfer += $output->writeString($kiter229);
+                $xfer += $output->writeI32($viter230);
               }
             }
             $xfer += $output->writeMapEnd();
@@ -922,15 +922,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size204 = 0;
+          my $_size231 = 0;
           $self->{success} = [];
-          my $_etype207 = 0;
-          $xfer += $input->readListBegin(\$_etype207, \$_size204);
-          for (my $_i208 = 0; $_i208 < $_size204; ++$_i208)
+          my $_etype234 = 0;
+          $xfer += $input->readListBegin(\$_etype234, \$_size231);
+          for (my $_i235 = 0; $_i235 < $_size231; ++$_i235)
           {
-            my $elem209 = undef;
-            $xfer += $input->readString(\$elem209);
-            push(@{$self->{success}},$elem209);
+            my $elem236 = undef;
+            $xfer += $input->readString(\$elem236);
+            push(@{$self->{success}},$elem236);
           }
           $xfer += $input->readListEnd();
         }
@@ -962,9 +962,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter210 (@{$self->{success}}) 
+        foreach my $iter237 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter210);
+          $xfer += $output->writeString($iter237);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1087,15 +1087,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size211 = 0;
+          my $_size238 = 0;
           $self->{success} = [];
-          my $_etype214 = 0;
-          $xfer += $input->readListBegin(\$_etype214, \$_size211);
-          for (my $_i215 = 0; $_i215 < $_size211; ++$_i215)
+          my $_etype241 = 0;
+          $xfer += $input->readListBegin(\$_etype241, \$_size238);
+          for (my $_i242 = 0; $_i242 < $_size238; ++$_i242)
           {
-            my $elem216 = undef;
-            $xfer += $input->readString(\$elem216);
-            push(@{$self->{success}},$elem216);
+            my $elem243 = undef;
+            $xfer += $input->readString(\$elem243);
+            push(@{$self->{success}},$elem243);
           }
           $xfer += $input->readListEnd();
         }
@@ -1127,9 +1127,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter217 (@{$self->{success}}) 
+        foreach my $iter244 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter217);
+          $xfer += $output->writeString($iter244);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1452,6 +1452,166 @@ sub write {
   return $xfer;
 }
 
+package Blur::Blur_parseQuery_args;
+use base qw(Class::Accessor);
+Blur::Blur_parseQuery_args->mk_accessors( qw( table simpleQuery ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{table} = undef;
+  $self->{simpleQuery} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{simpleQuery}) {
+      $self->{simpleQuery} = $vals->{simpleQuery};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_parseQuery_args';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{table});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{simpleQuery} = new Blur::SimpleQuery();
+        $xfer += $self->{simpleQuery}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_parseQuery_args');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{simpleQuery}) {
+    $xfer += $output->writeFieldBegin('simpleQuery', TType::STRUCT, 2);
+    $xfer += $self->{simpleQuery}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_parseQuery_result;
+use base qw(Class::Accessor);
+Blur::Blur_parseQuery_result->mk_accessors( qw( success ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{success} = undef;
+  $self->{ex} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{success}) {
+      $self->{success} = $vals->{success};
+    }
+    if (defined $vals->{ex}) {
+      $self->{ex} = $vals->{ex};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_parseQuery_result';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^0$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{success});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{ex} = new Blur::BlurException();
+        $xfer += $self->{ex}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_parseQuery_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::STRING, 0);
+    $xfer += $output->writeString($self->{success});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{ex}) {
+    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+    $xfer += $self->{ex}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 package Blur::Blur_cancelQuery_args;
 use base qw(Class::Accessor);
 Blur::Blur_cancelQuery_args->mk_accessors( qw( table uuid ) );
@@ -1702,16 +1862,16 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size218 = 0;
+          my $_size245 = 0;
           $self->{success} = [];
-          my $_etype221 = 0;
-          $xfer += $input->readListBegin(\$_etype221, \$_size218);
-          for (my $_i222 = 0; $_i222 < $_size218; ++$_i222)
+          my $_etype248 = 0;
+          $xfer += $input->readListBegin(\$_etype248, \$_size245);
+          for (my $_i249 = 0; $_i249 < $_size245; ++$_i249)
           {
-            my $elem223 = undef;
-            $elem223 = new Blur::BlurQueryStatus();
-            $xfer += $elem223->read($input);
-            push(@{$self->{success}},$elem223);
+            my $elem250 = undef;
+            $elem250 = new Blur::BlurQueryStatus();
+            $xfer += $elem250->read($input);
+            push(@{$self->{success}},$elem250);
           }
           $xfer += $input->readListEnd();
         }
@@ -1743,9 +1903,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{success}}));
       {
-        foreach my $iter224 (@{$self->{success}}) 
+        foreach my $iter251 (@{$self->{success}}) 
         {
-          $xfer += ${iter224}->write($output);
+          $xfer += ${iter251}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -1868,15 +2028,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size225 = 0;
+          my $_size252 = 0;
           $self->{success} = [];
-          my $_etype228 = 0;
-          $xfer += $input->readListBegin(\$_etype228, \$_size225);
-          for (my $_i229 = 0; $_i229 < $_size225; ++$_i229)
+          my $_etype255 = 0;
+          $xfer += $input->readListBegin(\$_etype255, \$_size252);
+          for (my $_i256 = 0; $_i256 < $_size252; ++$_i256)
           {
-            my $elem230 = undef;
-            $xfer += $input->readI64(\$elem230);
-            push(@{$self->{success}},$elem230);
+            my $elem257 = undef;
+            $xfer += $input->readI64(\$elem257);
+            push(@{$self->{success}},$elem257);
           }
           $xfer += $input->readListEnd();
         }
@@ -1908,9 +2068,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::I64, scalar(@{$self->{success}}));
       {
-        foreach my $iter231 (@{$self->{success}}) 
+        foreach my $iter258 (@{$self->{success}}) 
         {
-          $xfer += $output->writeI64($iter231);
+          $xfer += $output->writeI64($iter258);
         }
       }
       $xfer += $output->writeListEnd();
@@ -2688,15 +2848,15 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size232 = 0;
+          my $_size259 = 0;
           $self->{success} = [];
-          my $_etype235 = 0;
-          $xfer += $input->readListBegin(\$_etype235, \$_size232);
-          for (my $_i236 = 0; $_i236 < $_size232; ++$_i236)
+          my $_etype262 = 0;
+          $xfer += $input->readListBegin(\$_etype262, \$_size259);
+          for (my $_i263 = 0; $_i263 < $_size259; ++$_i263)
           {
-            my $elem237 = undef;
-            $xfer += $input->readString(\$elem237);
-            push(@{$self->{success}},$elem237);
+            my $elem264 = undef;
+            $xfer += $input->readString(\$elem264);
+            push(@{$self->{success}},$elem264);
           }
           $xfer += $input->readListEnd();
         }
@@ -2728,9 +2888,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{success}}));
       {
-        foreach my $iter238 (@{$self->{success}}) 
+        foreach my $iter265 (@{$self->{success}}) 
         {
-          $xfer += $output->writeString($iter238);
+          $xfer += $output->writeString($iter265);
         }
       }
       $xfer += $output->writeListEnd();
@@ -3265,16 +3425,16 @@ sub read {
     {
       /^1$/ && do{      if ($ftype == TType::LIST) {
         {
-          my $_size239 = 0;
+          my $_size266 = 0;
           $self->{mutations} = [];
-          my $_etype242 = 0;
-          $xfer += $input->readListBegin(\$_etype242, \$_size239);
-          for (my $_i243 = 0; $_i243 < $_size239; ++$_i243)
+          my $_etype269 = 0;
+          $xfer += $input->readListBegin(\$_etype269, \$_size266);
+          for (my $_i270 = 0; $_i270 < $_size266; ++$_i270)
           {
-            my $elem244 = undef;
-            $elem244 = new Blur::RowMutation();
-            $xfer += $elem244->read($input);
-            push(@{$self->{mutations}},$elem244);
+            my $elem271 = undef;
+            $elem271 = new Blur::RowMutation();
+            $xfer += $elem271->read($input);
+            push(@{$self->{mutations}},$elem271);
           }
           $xfer += $input->readListEnd();
         }
@@ -3299,9 +3459,9 @@ sub write {
     {
       $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{mutations}}));
       {
-        foreach my $iter245 (@{$self->{mutations}}) 
+        foreach my $iter272 (@{$self->{mutations}}) 
         {
-          $xfer += ${iter245}->write($output);
+          $xfer += ${iter272}->write($output);
         }
       }
       $xfer += $output->writeListEnd();
@@ -4286,18 +4446,18 @@ sub read {
     {
       /^0$/ && do{      if ($ftype == TType::MAP) {
         {
-          my $_size246 = 0;
+          my $_size273 = 0;
           $self->{success} = {};
-          my $_ktype247 = 0;
-          my $_vtype248 = 0;
-          $xfer += $input->readMapBegin(\$_ktype247, \$_vtype248, \$_size246);
-          for (my $_i250 = 0; $_i250 < $_size246; ++$_i250)
+          my $_ktype274 = 0;
+          my $_vtype275 = 0;
+          $xfer += $input->readMapBegin(\$_ktype274, \$_vtype275, \$_size273);
+          for (my $_i277 = 0; $_i277 < $_size273; ++$_i277)
           {
-            my $key251 = '';
-            my $val252 = '';
-            $xfer += $input->readString(\$key251);
-            $xfer += $input->readString(\$val252);
-            $self->{success}->{$key251} = $val252;
+            my $key278 = '';
+            my $val279 = '';
+            $xfer += $input->readString(\$key278);
+            $xfer += $input->readString(\$val279);
+            $self->{success}->{$key278} = $val279;
           }
           $xfer += $input->readMapEnd();
         }
@@ -4329,10 +4489,201 @@ sub write {
     {
       $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{success}}));
       {
-        while( my ($kiter253,$viter254) = each %{$self->{success}}) 
+        while( my ($kiter280,$viter281) = each %{$self->{success}}) 
+        {
+          $xfer += $output->writeString($kiter280);
+          $xfer += $output->writeString($viter281);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{ex}) {
+    $xfer += $output->writeFieldBegin('ex', TType::STRUCT, 1);
+    $xfer += $self->{ex}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_metrics_args;
+use base qw(Class::Accessor);
+Blur::Blur_metrics_args->mk_accessors( qw( metrics ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{metrics} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{metrics}) {
+      $self->{metrics} = $vals->{metrics};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_metrics_args';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::SET) {
+        {
+          my $_size282 = 0;
+          $self->{metrics} = {};
+          my $_etype285 = 0;
+          $xfer += $input->readSetBegin(\$_etype285, \$_size282);
+          for (my $_i286 = 0; $_i286 < $_size282; ++$_i286)
+          {
+            my $elem287 = undef;
+            $xfer += $input->readString(\$elem287);
+            $self->{metrics}->{$elem287} = 1;
+          }
+          $xfer += $input->readSetEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_metrics_args');
+  if (defined $self->{metrics}) {
+    $xfer += $output->writeFieldBegin('metrics', TType::SET, 1);
+    {
+      $xfer += $output->writeSetBegin(TType::STRING, scalar(@{$self->{metrics}}));
+      {
+        foreach my $iter288 (@{$self->{metrics}})
+        {
+          $xfer += $output->writeString($iter288);
+        }
+      }
+      $xfer += $output->writeSetEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Blur_metrics_result;
+use base qw(Class::Accessor);
+Blur::Blur_metrics_result->mk_accessors( qw( success ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{success} = undef;
+  $self->{ex} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{success}) {
+      $self->{success} = $vals->{success};
+    }
+    if (defined $vals->{ex}) {
+      $self->{ex} = $vals->{ex};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Blur_metrics_result';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^0$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size289 = 0;
+          $self->{success} = {};
+          my $_ktype290 = 0;
+          my $_vtype291 = 0;
+          $xfer += $input->readMapBegin(\$_ktype290, \$_vtype291, \$_size289);
+          for (my $_i293 = 0; $_i293 < $_size289; ++$_i293)
+          {
+            my $key294 = '';
+            my $val295 = new Blur::Metric();
+            $xfer += $input->readString(\$key294);
+            $val295 = new Blur::Metric();
+            $xfer += $val295->read($input);
+            $self->{success}->{$key294} = $val295;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^1$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{ex} = new Blur::BlurException();
+        $xfer += $self->{ex}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Blur_metrics_result');
+  if (defined $self->{success}) {
+    $xfer += $output->writeFieldBegin('success', TType::MAP, 0);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{success}}));
+      {
+        while( my ($kiter296,$viter297) = each %{$self->{success}}) 
         {
-          $xfer += $output->writeString($kiter253);
-          $xfer += $output->writeString($viter254);
+          $xfer += $output->writeString($kiter296);
+          $xfer += ${viter297}->write($output);
         }
       }
       $xfer += $output->writeMapEnd();
@@ -4415,6 +4766,14 @@ sub query{
   die 'implement interface';
 }
 
+sub parseQuery{
+  my $self = shift;
+  my $table = shift;
+  my $simpleQuery = shift;
+
+  die 'implement interface';
+}
+
 sub cancelQuery{
   my $self = shift;
   my $table = shift;
@@ -4559,6 +4918,13 @@ sub configuration{
   die 'implement interface';
 }
 
+sub metrics{
+  my $self = shift;
+  my $metrics = shift;
+
+  die 'implement interface';
+}
+
 package Blur::BlurRest;
 
 use strict;
@@ -4632,6 +4998,14 @@ sub query{
   return $self->{impl}->query($table, $blurQuery);
 }
 
+sub parseQuery{
+  my ($self, $request) = @_;
+
+  my $table = ($request->{'table'}) ? $request->{'table'} : undef;
+  my $simpleQuery = ($request->{'simpleQuery'}) ? $request->{'simpleQuery'} : undef;
+  return $self->{impl}->parseQuery($table, $simpleQuery);
+}
+
 sub cancelQuery{
   my ($self, $request) = @_;
 
@@ -4776,6 +5150,13 @@ sub configuration{
   return $self->{impl}->configuration();
 }
 
+sub metrics{
+  my ($self, $request) = @_;
+
+  my $metrics = ($request->{'metrics'}) ? $request->{'metrics'} : undef;
+  return $self->{impl}->metrics($metrics);
+}
+
 package Blur::BlurClient;
 
 
@@ -5197,6 +5578,55 @@ sub recv_query{
   }
   die "query failed: unknown result";
 }
+sub parseQuery{
+  my $self = shift;
+  my $table = shift;
+  my $simpleQuery = shift;
+
+    $self->send_parseQuery($table, $simpleQuery);
+  return $self->recv_parseQuery();
+}
+
+sub send_parseQuery{
+  my $self = shift;
+  my $table = shift;
+  my $simpleQuery = shift;
+
+  $self->{output}->writeMessageBegin('parseQuery', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_parseQuery_args();
+  $args->{table} = $table;
+  $args->{simpleQuery} = $simpleQuery;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_parseQuery{
+  my $self = shift;
+
+  my $rseqid = 0;
+  my $fname;
+  my $mtype = 0;
+
+  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
+  if ($mtype == TMessageType::EXCEPTION) {
+    my $x = new TApplicationException();
+    $x->read($self->{input});
+    $self->{input}->readMessageEnd();
+    die $x;
+  }
+  my $result = new Blur::Blur_parseQuery_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  die "parseQuery failed: unknown result";
+}
 sub cancelQuery{
   my $self = shift;
   my $table = shift;
@@ -6080,6 +6510,52 @@ sub recv_configuration{
   }
   die "configuration failed: unknown result";
 }
+sub metrics{
+  my $self = shift;
+  my $metrics = shift;
+
+    $self->send_metrics($metrics);
+  return $self->recv_metrics();
+}
+
+sub send_metrics{
+  my $self = shift;
+  my $metrics = shift;
+
+  $self->{output}->writeMessageBegin('metrics', TMessageType::CALL, $self->{seqid});
+  my $args = new Blur::Blur_metrics_args();
+  $args->{metrics} = $metrics;
+  $args->write($self->{output});
+  $self->{output}->writeMessageEnd();
+  $self->{output}->getTransport()->flush();
+}
+
+sub recv_metrics{
+  my $self = shift;
+
+  my $rseqid = 0;
+  my $fname;
+  my $mtype = 0;
+
+  $self->{input}->readMessageBegin(\$fname, \$mtype, \$rseqid);
+  if ($mtype == TMessageType::EXCEPTION) {
+    my $x = new TApplicationException();
+    $x->read($self->{input});
+    $self->{input}->readMessageEnd();
+    die $x;
+  }
+  my $result = new Blur::Blur_metrics_result();
+  $result->read($self->{input});
+  $self->{input}->readMessageEnd();
+
+  if (defined $result->{success} ) {
+    return $result->{success};
+  }
+  if (defined $result->{ex}) {
+    die $result->{ex};
+  }
+  die "metrics failed: unknown result";
+}
 package Blur::BlurProcessor;
 
 use strict;
@@ -6267,6 +6743,23 @@ sub process_query {
     $output->getTransport()->flush();
 }
 
+sub process_parseQuery {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_parseQuery_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_parseQuery_result();
+    eval {
+      $result->{success} = $self->{handler}->parseQuery($args->table, $args->simpleQuery);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('parseQuery', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
 sub process_cancelQuery {
     my ($self, $seqid, $input, $output) = @_;
     my $args = new Blur::Blur_cancelQuery_args();
@@ -6590,4 +7083,21 @@ sub process_configuration {
     $output->getTransport()->flush();
 }
 
+sub process_metrics {
+    my ($self, $seqid, $input, $output) = @_;
+    my $args = new Blur::Blur_metrics_args();
+    $args->read($input);
+    $input->readMessageEnd();
+    my $result = new Blur::Blur_metrics_result();
+    eval {
+      $result->{success} = $self->{handler}->metrics($args->metrics);
+    }; if( UNIVERSAL::isa($@,'Blur::BlurException') ){ 
+      $result->{ex} = $@;
+    }
+    $output->writeMessageBegin('metrics', TMessageType::REPLY, $seqid);
+    $result->write($output);
+    $output->writeMessageEnd();
+    $output->getTransport()->flush();
+}
+
 1;

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/7137006b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
index 42a1a87..563c6a7 100644
--- a/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
+++ b/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
@@ -3501,4 +3501,188 @@ sub write {
   return $xfer;
 }
 
+package Blur::Metric;
+use base qw(Class::Accessor);
+Blur::Metric->mk_accessors( qw( name strMap longMap doubleMap ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{name} = undef;
+  $self->{strMap} = undef;
+  $self->{longMap} = undef;
+  $self->{doubleMap} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{name}) {
+      $self->{name} = $vals->{name};
+    }
+    if (defined $vals->{strMap}) {
+      $self->{strMap} = $vals->{strMap};
+    }
+    if (defined $vals->{longMap}) {
+      $self->{longMap} = $vals->{longMap};
+    }
+    if (defined $vals->{doubleMap}) {
+      $self->{doubleMap} = $vals->{doubleMap};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Metric';
+}
+
+sub read {
+  my ($self, $input) = @_;
+  my $xfer  = 0;
+  my $fname;
+  my $ftype = 0;
+  my $fid   = 0;
+  $xfer += $input->readStructBegin(\$fname);
+  while (1) 
+  {
+    $xfer += $input->readFieldBegin(\$fname, \$ftype, \$fid);
+    if ($ftype == TType::STOP) {
+      last;
+    }
+    SWITCH: for($fid)
+    {
+      /^1$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{name});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size156 = 0;
+          $self->{strMap} = {};
+          my $_ktype157 = 0;
+          my $_vtype158 = 0;
+          $xfer += $input->readMapBegin(\$_ktype157, \$_vtype158, \$_size156);
+          for (my $_i160 = 0; $_i160 < $_size156; ++$_i160)
+          {
+            my $key161 = '';
+            my $val162 = '';
+            $xfer += $input->readString(\$key161);
+            $xfer += $input->readString(\$val162);
+            $self->{strMap}->{$key161} = $val162;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size163 = 0;
+          $self->{longMap} = {};
+          my $_ktype164 = 0;
+          my $_vtype165 = 0;
+          $xfer += $input->readMapBegin(\$_ktype164, \$_vtype165, \$_size163);
+          for (my $_i167 = 0; $_i167 < $_size163; ++$_i167)
+          {
+            my $key168 = '';
+            my $val169 = 0;
+            $xfer += $input->readString(\$key168);
+            $xfer += $input->readI64(\$val169);
+            $self->{longMap}->{$key168} = $val169;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size170 = 0;
+          $self->{doubleMap} = {};
+          my $_ktype171 = 0;
+          my $_vtype172 = 0;
+          $xfer += $input->readMapBegin(\$_ktype171, \$_vtype172, \$_size170);
+          for (my $_i174 = 0; $_i174 < $_size170; ++$_i174)
+          {
+            my $key175 = '';
+            my $val176 = 0.0;
+            $xfer += $input->readString(\$key175);
+            $xfer += $input->readDouble(\$val176);
+            $self->{doubleMap}->{$key175} = $val176;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+        $xfer += $input->skip($ftype);
+    }
+    $xfer += $input->readFieldEnd();
+  }
+  $xfer += $input->readStructEnd();
+  return $xfer;
+}
+
+sub write {
+  my ($self, $output) = @_;
+  my $xfer   = 0;
+  $xfer += $output->writeStructBegin('Metric');
+  if (defined $self->{name}) {
+    $xfer += $output->writeFieldBegin('name', TType::STRING, 1);
+    $xfer += $output->writeString($self->{name});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{strMap}) {
+    $xfer += $output->writeFieldBegin('strMap', TType::MAP, 2);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{strMap}}));
+      {
+        while( my ($kiter177,$viter178) = each %{$self->{strMap}}) 
+        {
+          $xfer += $output->writeString($kiter177);
+          $xfer += $output->writeString($viter178);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{longMap}) {
+    $xfer += $output->writeFieldBegin('longMap', TType::MAP, 3);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::I64, scalar(keys %{$self->{longMap}}));
+      {
+        while( my ($kiter179,$viter180) = each %{$self->{longMap}}) 
+        {
+          $xfer += $output->writeString($kiter179);
+          $xfer += $output->writeI64($viter180);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{doubleMap}) {
+    $xfer += $output->writeFieldBegin('doubleMap', TType::MAP, 4);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::DOUBLE, scalar(keys %{$self->{doubleMap}}));
+      {
+        while( my ($kiter181,$viter182) = each %{$self->{doubleMap}}) 
+        {
+          $xfer += $output->writeString($kiter181);
+          $xfer += $output->writeDouble($viter182);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
 1;

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/7137006b/distribution/src/main/scripts/interface/gen-rb/blur.rb
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-rb/blur.rb b/distribution/src/main/scripts/interface/gen-rb/blur.rb
index 27043c9..2a277c7 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur.rb
@@ -156,6 +156,22 @@ module Blur
         raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT,
'query failed: unknown result')
       end
 
+      def parseQuery(table, simpleQuery)
+        send_parseQuery(table, simpleQuery)
+        return recv_parseQuery()
+      end
+
+      def send_parseQuery(table, simpleQuery)
+        send_message('parseQuery', ParseQuery_args, :table => table, :simpleQuery =>
simpleQuery)
+      end
+
+      def recv_parseQuery()
+        result = receive_message(ParseQuery_result)
+        return result.success unless result.success.nil?
+        raise result.ex unless result.ex.nil?
+        raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT,
'parseQuery failed: unknown result')
+      end
+
       def cancelQuery(table, uuid)
         send_cancelQuery(table, uuid)
         recv_cancelQuery()
@@ -452,6 +468,22 @@ module Blur
         raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT,
'configuration failed: unknown result')
       end
 
+      def metrics(metrics)
+        send_metrics(metrics)
+        return recv_metrics()
+      end
+
+      def send_metrics(metrics)
+        send_message('metrics', Metrics_args, :metrics => metrics)
+      end
+
+      def recv_metrics()
+        result = receive_message(Metrics_result)
+        return result.success unless result.success.nil?
+        raise result.ex unless result.ex.nil?
+        raise ::Thrift::ApplicationException.new(::Thrift::ApplicationException::MISSING_RESULT,
'metrics failed: unknown result')
+      end
+
     end
 
     class Processor
@@ -556,6 +588,17 @@ module Blur
         write_result(result, oprot, 'query', seqid)
       end
 
+      def process_parseQuery(seqid, iprot, oprot)
+        args = read_args(iprot, ParseQuery_args)
+        result = ParseQuery_result.new()
+        begin
+          result.success = @handler.parseQuery(args.table, args.simpleQuery)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'parseQuery', seqid)
+      end
+
       def process_cancelQuery(seqid, iprot, oprot)
         args = read_args(iprot, CancelQuery_args)
         result = CancelQuery_result.new()
@@ -765,6 +808,17 @@ module Blur
         write_result(result, oprot, 'configuration', seqid)
       end
 
+      def process_metrics(seqid, iprot, oprot)
+        args = read_args(iprot, Metrics_args)
+        result = Metrics_result.new()
+        begin
+          result.success = @handler.metrics(args.metrics)
+        rescue ::Blur::BlurException => ex
+          result.ex = ex
+        end
+        write_result(result, oprot, 'metrics', seqid)
+      end
+
     end
 
     # HELPER FUNCTIONS AND STRUCTURES
@@ -1074,6 +1128,42 @@ module Blur
       ::Thrift::Struct.generate_accessors self
     end
 
+    class ParseQuery_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      TABLE = 1
+      SIMPLEQUERY = 2
+
+      FIELDS = {
+        TABLE => {:type => ::Thrift::Types::STRING, :name => 'table'},
+        SIMPLEQUERY => {:type => ::Thrift::Types::STRUCT, :name => 'simpleQuery',
:class => ::Blur::SimpleQuery}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class ParseQuery_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      SUCCESS = 0
+      EX = 1
+
+      FIELDS = {
+        SUCCESS => {:type => ::Thrift::Types::STRING, :name => 'success'},
+        EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
     class CancelQuery_args
       include ::Thrift::Struct, ::Thrift::Struct_Union
       TABLE = 1
@@ -1727,6 +1817,40 @@ module Blur
       ::Thrift::Struct.generate_accessors self
     end
 
+    class Metrics_args
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      METRICS = 1
+
+      FIELDS = {
+        METRICS => {:type => ::Thrift::Types::SET, :name => 'metrics', :element
=> {:type => ::Thrift::Types::STRING}}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
+    class Metrics_result
+      include ::Thrift::Struct, ::Thrift::Struct_Union
+      SUCCESS = 0
+      EX = 1
+
+      FIELDS = {
+        SUCCESS => {:type => ::Thrift::Types::MAP, :name => 'success', :key =>
{:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRUCT,
:class => ::Blur::Metric}},
+        EX => {:type => ::Thrift::Types::STRUCT, :name => 'ex', :class => ::Blur::BlurException}
+      }
+
+      def struct_fields; FIELDS; end
+
+      def validate
+      end
+
+      ::Thrift::Struct.generate_accessors self
+    end
+
   end
 
 end

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/7137006b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
----------------------------------------------------------------------
diff --git a/distribution/src/main/scripts/interface/gen-rb/blur_types.rb b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
index 646d5eb..d2e0a8a 100644
--- a/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
+++ b/distribution/src/main/scripts/interface/gen-rb/blur_types.rb
@@ -815,4 +815,26 @@ module Blur
     ::Thrift::Struct.generate_accessors self
   end
 
+  class Metric
+    include ::Thrift::Struct, ::Thrift::Struct_Union
+    NAME = 1
+    STRMAP = 2
+    LONGMAP = 3
+    DOUBLEMAP = 4
+
+    FIELDS = {
+      NAME => {:type => ::Thrift::Types::STRING, :name => 'name'},
+      STRMAP => {:type => ::Thrift::Types::MAP, :name => 'strMap', :key => {:type
=> ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::STRING}},
+      LONGMAP => {:type => ::Thrift::Types::MAP, :name => 'longMap', :key =>
{:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::I64}},
+      DOUBLEMAP => {:type => ::Thrift::Types::MAP, :name => 'doubleMap', :key =>
{:type => ::Thrift::Types::STRING}, :value => {:type => ::Thrift::Types::DOUBLE}}
+    }
+
+    def struct_fields; FIELDS; end
+
+    def validate
+    end
+
+    ::Thrift::Struct.generate_accessors self
+  end
+
 end

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/7137006b/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index b44cdc4..f488d48 100644
--- a/pom.xml
+++ b/pom.xml
@@ -47,7 +47,7 @@ under the License.
 		<slf4j.version>1.6.1</slf4j.version>
 		<commons-cli.version>1.2</commons-cli.version>
 		<concurrentlinkedhashmap-lru.version>1.3.2</concurrentlinkedhashmap-lru.version>
-		<jline.version>2.7</jline.version>
+		<jline.version>2.10</jline.version>
 		<guava.version>14.0</guava.version>
 		<metrics.version>2.2.0</metrics.version>
 		<metrics-ganglia.version>2.2.0</metrics-ganglia.version>


Mime
View raw message