incubator-blur-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From amccu...@apache.org
Subject [3/29] Added the distribution project to allow for automatically creating build artifacts during a maven build.
Date Fri, 04 Jan 2013 22:42:52 GMT
http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/70b69ecb/src/distribution/src/main/scripts/interface/gen-perl/Blur/Constants.pm
----------------------------------------------------------------------
diff --git a/src/distribution/src/main/scripts/interface/gen-perl/Blur/Constants.pm b/src/distribution/src/main/scripts/interface/gen-perl/Blur/Constants.pm
new file mode 100644
index 0000000..c8e01e3
--- /dev/null
+++ b/src/distribution/src/main/scripts/interface/gen-perl/Blur/Constants.pm
@@ -0,0 +1,13 @@
+#
+# Autogenerated by Thrift Compiler (0.9.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+package Blur::Constants;
+require 5.6.0;
+use strict;
+use warnings;
+use Thrift;
+
+
+1;

http://git-wip-us.apache.org/repos/asf/incubator-blur/blob/70b69ecb/src/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
----------------------------------------------------------------------
diff --git a/src/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm b/src/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
new file mode 100644
index 0000000..a8416e8
--- /dev/null
+++ b/src/distribution/src/main/scripts/interface/gen-perl/Blur/Types.pm
@@ -0,0 +1,2672 @@
+#
+# Autogenerated by Thrift Compiler (0.9.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+require 5.6.0;
+use strict;
+use warnings;
+use Thrift;
+
+package Blur::QueryState;
+use constant RUNNING => 0;
+use constant INTERRUPTED => 1;
+use constant COMPLETE => 2;
+package Blur::TYPE;
+use constant TEXT => 0;
+use constant STRING => 1;
+use constant INT => 2;
+use constant LONG => 3;
+use constant FLOAT => 4;
+use constant DOUBLE => 5;
+use constant BINARY => 6;
+package Blur::SortType;
+use constant SCORE => 0;
+use constant DOC => 1;
+use constant STRING => 2;
+use constant INT => 3;
+use constant FLOAT => 4;
+use constant LONG => 5;
+use constant DOUBLE => 6;
+use constant SHORT => 7;
+use constant BYTE => 8;
+use constant STRING_VAL => 9;
+use constant BYTES => 10;
+package Blur::QueryType;
+use constant STRING => 0;
+use constant JSON => 1;
+use constant BINARY => 2;
+package Blur::BlurException;
+use base qw(Thrift::TException);
+use base qw(Class::Accessor);
+Blur::BlurException->mk_accessors( qw( message stackTraceStr ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{message} = undef;
+  $self->{stackTraceStr} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{message}) {
+      $self->{message} = $vals->{message};
+    }
+    if (defined $vals->{stackTraceStr}) {
+      $self->{stackTraceStr} = $vals->{stackTraceStr};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'BlurException';
+}
+
+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->{message});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{stackTraceStr});
+      } 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('BlurException');
+  if (defined $self->{message}) {
+    $xfer += $output->writeFieldBegin('message', TType::STRING, 1);
+    $xfer += $output->writeString($self->{message});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{stackTraceStr}) {
+    $xfer += $output->writeFieldBegin('stackTraceStr', TType::STRING, 2);
+    $xfer += $output->writeString($self->{stackTraceStr});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::CpuTime;
+use base qw(Class::Accessor);
+Blur::CpuTime->mk_accessors( qw( cpuTime realTime ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{cpuTime} = undef;
+  $self->{realTime} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{cpuTime}) {
+      $self->{cpuTime} = $vals->{cpuTime};
+    }
+    if (defined $vals->{realTime}) {
+      $self->{realTime} = $vals->{realTime};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'CpuTime';
+}
+
+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::I64) {
+        $xfer += $input->readI64(\$self->{cpuTime});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{realTime});
+      } 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('CpuTime');
+  if (defined $self->{cpuTime}) {
+    $xfer += $output->writeFieldBegin('cpuTime', TType::I64, 1);
+    $xfer += $output->writeI64($self->{cpuTime});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{realTime}) {
+    $xfer += $output->writeFieldBegin('realTime', TType::I64, 2);
+    $xfer += $output->writeI64($self->{realTime});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::QueryStatus;
+use base qw(Class::Accessor);
+Blur::QueryStatus->mk_accessors( qw( cpuTimes completeShards totalShards state ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{cpuTimes} = undef;
+  $self->{completeShards} = undef;
+  $self->{totalShards} = undef;
+  $self->{state} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{cpuTimes}) {
+      $self->{cpuTimes} = $vals->{cpuTimes};
+    }
+    if (defined $vals->{completeShards}) {
+      $self->{completeShards} = $vals->{completeShards};
+    }
+    if (defined $vals->{totalShards}) {
+      $self->{totalShards} = $vals->{totalShards};
+    }
+    if (defined $vals->{state}) {
+      $self->{state} = $vals->{state};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'QueryStatus';
+}
+
+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::MAP) {
+        {
+          my $_size0 = 0;
+          $self->{cpuTimes} = {};
+          my $_ktype1 = 0;
+          my $_vtype2 = 0;
+          $xfer += $input->readMapBegin(\$_ktype1, \$_vtype2, \$_size0);
+          for (my $_i4 = 0; $_i4 < $_size0; ++$_i4)
+          {
+            my $key5 = '';
+            my $val6 = new Blur::CpuTime();
+            $xfer += $input->readString(\$key5);
+            $val6 = new Blur::CpuTime();
+            $xfer += $val6->read($input);
+            $self->{cpuTimes}->{$key5} = $val6;
+          }
+          $xfer += $input->readMapEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{completeShards});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{totalShards});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{state});
+      } 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('QueryStatus');
+  if (defined $self->{cpuTimes}) {
+    $xfer += $output->writeFieldBegin('cpuTimes', TType::MAP, 1);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRUCT, scalar(keys %{$self->{cpuTimes}}));
+      {
+        while( my ($kiter7,$viter8) = each %{$self->{cpuTimes}}) 
+        {
+          $xfer += $output->writeString($kiter7);
+          $xfer += ${viter8}->write($output);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{completeShards}) {
+    $xfer += $output->writeFieldBegin('completeShards', TType::I32, 2);
+    $xfer += $output->writeI32($self->{completeShards});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{totalShards}) {
+    $xfer += $output->writeFieldBegin('totalShards', TType::I32, 3);
+    $xfer += $output->writeI32($self->{totalShards});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{state}) {
+    $xfer += $output->writeFieldBegin('state', TType::I32, 4);
+    $xfer += $output->writeI32($self->{state});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::TableStats;
+use base qw(Class::Accessor);
+Blur::TableStats->mk_accessors( qw( bytes documentCount queries ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{bytes} = undef;
+  $self->{documentCount} = undef;
+  $self->{queries} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{bytes}) {
+      $self->{bytes} = $vals->{bytes};
+    }
+    if (defined $vals->{documentCount}) {
+      $self->{documentCount} = $vals->{documentCount};
+    }
+    if (defined $vals->{queries}) {
+      $self->{queries} = $vals->{queries};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'TableStats';
+}
+
+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::I64) {
+        $xfer += $input->readI64(\$self->{bytes});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{documentCount});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{queries});
+      } 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('TableStats');
+  if (defined $self->{bytes}) {
+    $xfer += $output->writeFieldBegin('bytes', TType::I64, 1);
+    $xfer += $output->writeI64($self->{bytes});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{documentCount}) {
+    $xfer += $output->writeFieldBegin('documentCount', TType::I64, 2);
+    $xfer += $output->writeI64($self->{documentCount});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{queries}) {
+    $xfer += $output->writeFieldBegin('queries', TType::I64, 3);
+    $xfer += $output->writeI64($self->{queries});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::LiveSchema;
+use base qw(Class::Accessor);
+Blur::LiveSchema->mk_accessors( qw( table columnFamilies ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{table} = undef;
+  $self->{columnFamilies} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{columnFamilies}) {
+      $self->{columnFamilies} = $vals->{columnFamilies};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'LiveSchema';
+}
+
+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::MAP) {
+        {
+          my $_size9 = 0;
+          $self->{columnFamilies} = {};
+          my $_ktype10 = 0;
+          my $_vtype11 = 0;
+          $xfer += $input->readMapBegin(\$_ktype10, \$_vtype11, \$_size9);
+          for (my $_i13 = 0; $_i13 < $_size9; ++$_i13)
+          {
+            my $key14 = '';
+            my $val15 = [];
+            $xfer += $input->readString(\$key14);
+            {
+              my $_size16 = 0;
+              $val15 = {};
+              my $_etype19 = 0;
+              $xfer += $input->readSetBegin(\$_etype19, \$_size16);
+              for (my $_i20 = 0; $_i20 < $_size16; ++$_i20)
+              {
+                my $elem21 = undef;
+                $xfer += $input->readString(\$elem21);
+                $val15->{$elem21} = 1;
+              }
+              $xfer += $input->readSetEnd();
+            }
+            $self->{columnFamilies}->{$key14} = $val15;
+          }
+          $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('LiveSchema');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{columnFamilies}) {
+    $xfer += $output->writeFieldBegin('columnFamilies', TType::MAP, 2);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::SET, scalar(keys %{$self->{columnFamilies}}));
+      {
+        while( my ($kiter22,$viter23) = each %{$self->{columnFamilies}}) 
+        {
+          $xfer += $output->writeString($kiter22);
+          {
+            $xfer += $output->writeSetBegin(TType::STRING, scalar(@{${viter23}}));
+            {
+              foreach my $iter24 (@{${viter23}})
+              {
+                $xfer += $output->writeString($iter24);
+              }
+            }
+            $xfer += $output->writeSetEnd();
+          }
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::ClassDefinition;
+use base qw(Class::Accessor);
+Blur::ClassDefinition->mk_accessors( qw( className arguments ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{className} = undef;
+  $self->{arguments} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{className}) {
+      $self->{className} = $vals->{className};
+    }
+    if (defined $vals->{arguments}) {
+      $self->{arguments} = $vals->{arguments};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'ClassDefinition';
+}
+
+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->{className});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size25 = 0;
+          $self->{arguments} = {};
+          my $_ktype26 = 0;
+          my $_vtype27 = 0;
+          $xfer += $input->readMapBegin(\$_ktype26, \$_vtype27, \$_size25);
+          for (my $_i29 = 0; $_i29 < $_size25; ++$_i29)
+          {
+            my $key30 = '';
+            my $val31 = '';
+            $xfer += $input->readString(\$key30);
+            $xfer += $input->readString(\$val31);
+            $self->{arguments}->{$key30} = $val31;
+          }
+          $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('ClassDefinition');
+  if (defined $self->{className}) {
+    $xfer += $output->writeFieldBegin('className', TType::STRING, 1);
+    $xfer += $output->writeString($self->{className});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{arguments}) {
+    $xfer += $output->writeFieldBegin('arguments', TType::MAP, 2);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{arguments}}));
+      {
+        while( my ($kiter32,$viter33) = each %{$self->{arguments}}) 
+        {
+          $xfer += $output->writeString($kiter32);
+          $xfer += $output->writeString($viter33);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::AnalyzerSubType;
+use base qw(Class::Accessor);
+Blur::AnalyzerSubType->mk_accessors( qw( subFieldName classDefinition ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{subFieldName} = undef;
+  $self->{classDefinition} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{subFieldName}) {
+      $self->{subFieldName} = $vals->{subFieldName};
+    }
+    if (defined $vals->{classDefinition}) {
+      $self->{classDefinition} = $vals->{classDefinition};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'AnalyzerSubType';
+}
+
+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->{subFieldName});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{classDefinition} = new Blur::ClassDefinition();
+        $xfer += $self->{classDefinition}->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('AnalyzerSubType');
+  if (defined $self->{subFieldName}) {
+    $xfer += $output->writeFieldBegin('subFieldName', TType::STRING, 1);
+    $xfer += $output->writeString($self->{subFieldName});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{classDefinition}) {
+    $xfer += $output->writeFieldBegin('classDefinition', TType::STRUCT, 2);
+    $xfer += $self->{classDefinition}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::AnalyzerType;
+use base qw(Class::Accessor);
+Blur::AnalyzerType->mk_accessors( qw( fieldName classDefinition analyzerSubTypes ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{fieldName} = undef;
+  $self->{classDefinition} = undef;
+  $self->{analyzerSubTypes} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{fieldName}) {
+      $self->{fieldName} = $vals->{fieldName};
+    }
+    if (defined $vals->{classDefinition}) {
+      $self->{classDefinition} = $vals->{classDefinition};
+    }
+    if (defined $vals->{analyzerSubTypes}) {
+      $self->{analyzerSubTypes} = $vals->{analyzerSubTypes};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'AnalyzerType';
+}
+
+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->{fieldName});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{classDefinition} = new Blur::ClassDefinition();
+        $xfer += $self->{classDefinition}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size34 = 0;
+          $self->{analyzerSubTypes} = [];
+          my $_etype37 = 0;
+          $xfer += $input->readListBegin(\$_etype37, \$_size34);
+          for (my $_i38 = 0; $_i38 < $_size34; ++$_i38)
+          {
+            my $elem39 = undef;
+            $elem39 = new Blur::AnalyzerSubType();
+            $xfer += $elem39->read($input);
+            push(@{$self->{analyzerSubTypes}},$elem39);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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('AnalyzerType');
+  if (defined $self->{fieldName}) {
+    $xfer += $output->writeFieldBegin('fieldName', TType::STRING, 1);
+    $xfer += $output->writeString($self->{fieldName});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{classDefinition}) {
+    $xfer += $output->writeFieldBegin('classDefinition', TType::STRUCT, 2);
+    $xfer += $self->{classDefinition}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{analyzerSubTypes}) {
+    $xfer += $output->writeFieldBegin('analyzerSubTypes', TType::LIST, 3);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{analyzerSubTypes}}));
+      {
+        foreach my $iter40 (@{$self->{analyzerSubTypes}}) 
+        {
+          $xfer += ${iter40}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Analyzer;
+use base qw(Class::Accessor);
+Blur::Analyzer->mk_accessors( qw( analyzerTypes ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{analyzerTypes} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{analyzerTypes}) {
+      $self->{analyzerTypes} = $vals->{analyzerTypes};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Analyzer';
+}
+
+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::LIST) {
+        {
+          my $_size41 = 0;
+          $self->{analyzerTypes} = [];
+          my $_etype44 = 0;
+          $xfer += $input->readListBegin(\$_etype44, \$_size41);
+          for (my $_i45 = 0; $_i45 < $_size41; ++$_i45)
+          {
+            my $elem46 = undef;
+            $elem46 = new Blur::AnalyzerType();
+            $xfer += $elem46->read($input);
+            push(@{$self->{analyzerTypes}},$elem46);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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('Analyzer');
+  if (defined $self->{analyzerTypes}) {
+    $xfer += $output->writeFieldBegin('analyzerTypes', TType::LIST, 1);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{analyzerTypes}}));
+      {
+        foreach my $iter47 (@{$self->{analyzerTypes}}) 
+        {
+          $xfer += ${iter47}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::TableDescriptor;
+use base qw(Class::Accessor);
+Blur::TableDescriptor->mk_accessors( qw( name enabled shardCount storagePath analyzer readOnly defaultFieldName properties ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{name} = undef;
+  $self->{enabled} = 1;
+  $self->{shardCount} = 1;
+  $self->{storagePath} = undef;
+  $self->{analyzer} = undef;
+  $self->{readOnly} = 0;
+  $self->{defaultFieldName} = "body";
+  $self->{properties} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{name}) {
+      $self->{name} = $vals->{name};
+    }
+    if (defined $vals->{enabled}) {
+      $self->{enabled} = $vals->{enabled};
+    }
+    if (defined $vals->{shardCount}) {
+      $self->{shardCount} = $vals->{shardCount};
+    }
+    if (defined $vals->{storagePath}) {
+      $self->{storagePath} = $vals->{storagePath};
+    }
+    if (defined $vals->{analyzer}) {
+      $self->{analyzer} = $vals->{analyzer};
+    }
+    if (defined $vals->{readOnly}) {
+      $self->{readOnly} = $vals->{readOnly};
+    }
+    if (defined $vals->{defaultFieldName}) {
+      $self->{defaultFieldName} = $vals->{defaultFieldName};
+    }
+    if (defined $vals->{properties}) {
+      $self->{properties} = $vals->{properties};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'TableDescriptor';
+}
+
+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::BOOL) {
+        $xfer += $input->readBool(\$self->{enabled});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{shardCount});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{storagePath});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^5$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{analyzer} = new Blur::Analyzer();
+        $xfer += $self->{analyzer}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^6$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{readOnly});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^7$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{defaultFieldName});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^8$/ && do{      if ($ftype == TType::MAP) {
+        {
+          my $_size48 = 0;
+          $self->{properties} = {};
+          my $_ktype49 = 0;
+          my $_vtype50 = 0;
+          $xfer += $input->readMapBegin(\$_ktype49, \$_vtype50, \$_size48);
+          for (my $_i52 = 0; $_i52 < $_size48; ++$_i52)
+          {
+            my $key53 = '';
+            my $val54 = '';
+            $xfer += $input->readString(\$key53);
+            $xfer += $input->readString(\$val54);
+            $self->{properties}->{$key53} = $val54;
+          }
+          $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('TableDescriptor');
+  if (defined $self->{name}) {
+    $xfer += $output->writeFieldBegin('name', TType::STRING, 1);
+    $xfer += $output->writeString($self->{name});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{enabled}) {
+    $xfer += $output->writeFieldBegin('enabled', TType::BOOL, 2);
+    $xfer += $output->writeBool($self->{enabled});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{shardCount}) {
+    $xfer += $output->writeFieldBegin('shardCount', TType::I32, 3);
+    $xfer += $output->writeI32($self->{shardCount});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{storagePath}) {
+    $xfer += $output->writeFieldBegin('storagePath', TType::STRING, 4);
+    $xfer += $output->writeString($self->{storagePath});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{analyzer}) {
+    $xfer += $output->writeFieldBegin('analyzer', TType::STRUCT, 5);
+    $xfer += $self->{analyzer}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{readOnly}) {
+    $xfer += $output->writeFieldBegin('readOnly', TType::BOOL, 6);
+    $xfer += $output->writeBool($self->{readOnly});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{defaultFieldName}) {
+    $xfer += $output->writeFieldBegin('defaultFieldName', TType::STRING, 7);
+    $xfer += $output->writeString($self->{defaultFieldName});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{properties}) {
+    $xfer += $output->writeFieldBegin('properties', TType::MAP, 8);
+    {
+      $xfer += $output->writeMapBegin(TType::STRING, TType::STRING, scalar(keys %{$self->{properties}}));
+      {
+        while( my ($kiter55,$viter56) = each %{$self->{properties}}) 
+        {
+          $xfer += $output->writeString($kiter55);
+          $xfer += $output->writeString($viter56);
+        }
+      }
+      $xfer += $output->writeMapEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Session;
+use base qw(Class::Accessor);
+Blur::Session->mk_accessors( qw( sessionId tableName ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{sessionId} = undef;
+  $self->{tableName} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{sessionId}) {
+      $self->{sessionId} = $vals->{sessionId};
+    }
+    if (defined $vals->{tableName}) {
+      $self->{tableName} = $vals->{tableName};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Session';
+}
+
+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->{sessionId});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{tableName});
+      } 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('Session');
+  if (defined $self->{sessionId}) {
+    $xfer += $output->writeFieldBegin('sessionId', TType::STRING, 1);
+    $xfer += $output->writeString($self->{sessionId});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{tableName}) {
+    $xfer += $output->writeFieldBegin('tableName', TType::STRING, 2);
+    $xfer += $output->writeString($self->{tableName});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::SortField;
+use base qw(Class::Accessor);
+Blur::SortField->mk_accessors( qw( field type reverse ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{field} = undef;
+  $self->{type} = undef;
+  $self->{reverse} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{field}) {
+      $self->{field} = $vals->{field};
+    }
+    if (defined $vals->{type}) {
+      $self->{type} = $vals->{type};
+    }
+    if (defined $vals->{reverse}) {
+      $self->{reverse} = $vals->{reverse};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'SortField';
+}
+
+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->{field});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{type});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{reverse});
+      } 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('SortField');
+  if (defined $self->{field}) {
+    $xfer += $output->writeFieldBegin('field', TType::STRING, 1);
+    $xfer += $output->writeString($self->{field});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{type}) {
+    $xfer += $output->writeFieldBegin('type', TType::I32, 2);
+    $xfer += $output->writeI32($self->{type});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{reverse}) {
+    $xfer += $output->writeFieldBegin('reverse', TType::BOOL, 3);
+    $xfer += $output->writeBool($self->{reverse});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Sort;
+use base qw(Class::Accessor);
+Blur::Sort->mk_accessors( qw( fields ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{fields} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{fields}) {
+      $self->{fields} = $vals->{fields};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Sort';
+}
+
+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::LIST) {
+        {
+          my $_size57 = 0;
+          $self->{fields} = [];
+          my $_etype60 = 0;
+          $xfer += $input->readListBegin(\$_etype60, \$_size57);
+          for (my $_i61 = 0; $_i61 < $_size57; ++$_i61)
+          {
+            my $elem62 = undef;
+            $elem62 = new Blur::SortField();
+            $xfer += $elem62->read($input);
+            push(@{$self->{fields}},$elem62);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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('Sort');
+  if (defined $self->{fields}) {
+    $xfer += $output->writeFieldBegin('fields', TType::LIST, 1);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
+      {
+        foreach my $iter63 (@{$self->{fields}}) 
+        {
+          $xfer += ${iter63}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::ScoreDoc;
+use base qw(Class::Accessor);
+Blur::ScoreDoc->mk_accessors( qw( score docLocation fields ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{score} = undef;
+  $self->{docLocation} = undef;
+  $self->{fields} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{score}) {
+      $self->{score} = $vals->{score};
+    }
+    if (defined $vals->{docLocation}) {
+      $self->{docLocation} = $vals->{docLocation};
+    }
+    if (defined $vals->{fields}) {
+      $self->{fields} = $vals->{fields};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'ScoreDoc';
+}
+
+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::DOUBLE) {
+        $xfer += $input->readDouble(\$self->{score});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{docLocation});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size64 = 0;
+          $self->{fields} = [];
+          my $_etype67 = 0;
+          $xfer += $input->readListBegin(\$_etype67, \$_size64);
+          for (my $_i68 = 0; $_i68 < $_size64; ++$_i68)
+          {
+            my $elem69 = undef;
+            $xfer += $input->readString(\$elem69);
+            push(@{$self->{fields}},$elem69);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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('ScoreDoc');
+  if (defined $self->{score}) {
+    $xfer += $output->writeFieldBegin('score', TType::DOUBLE, 1);
+    $xfer += $output->writeDouble($self->{score});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{docLocation}) {
+    $xfer += $output->writeFieldBegin('docLocation', TType::I64, 2);
+    $xfer += $output->writeI64($self->{docLocation});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{fields}) {
+    $xfer += $output->writeFieldBegin('fields', TType::LIST, 4);
+    {
+      $xfer += $output->writeListBegin(TType::STRING, scalar(@{$self->{fields}}));
+      {
+        foreach my $iter70 (@{$self->{fields}}) 
+        {
+          $xfer += $output->writeString($iter70);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Query;
+use base qw(Class::Accessor);
+Blur::Query->mk_accessors( qw( type queryString queryBinary ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{type} = undef;
+  $self->{queryString} = undef;
+  $self->{queryBinary} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{type}) {
+      $self->{type} = $vals->{type};
+    }
+    if (defined $vals->{queryString}) {
+      $self->{queryString} = $vals->{queryString};
+    }
+    if (defined $vals->{queryBinary}) {
+      $self->{queryBinary} = $vals->{queryBinary};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Query';
+}
+
+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::I32) {
+        $xfer += $input->readI32(\$self->{type});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{queryString});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{queryBinary});
+      } 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('Query');
+  if (defined $self->{type}) {
+    $xfer += $output->writeFieldBegin('type', TType::I32, 1);
+    $xfer += $output->writeI32($self->{type});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{queryString}) {
+    $xfer += $output->writeFieldBegin('queryString', TType::STRING, 2);
+    $xfer += $output->writeString($self->{queryString});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{queryBinary}) {
+    $xfer += $output->writeFieldBegin('queryBinary', TType::STRING, 3);
+    $xfer += $output->writeString($self->{queryBinary});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::QueryArgs;
+use base qw(Class::Accessor);
+Blur::QueryArgs->mk_accessors( qw( id after query filter numberToFetch aggregateResults sort doDocScores doMaxScore shardIndexes ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{id} = undef;
+  $self->{after} = undef;
+  $self->{query} = undef;
+  $self->{filter} = undef;
+  $self->{numberToFetch} = 100;
+  $self->{aggregateResults} = 1;
+  $self->{sort} = undef;
+  $self->{doDocScores} = 1;
+  $self->{doMaxScore} = 0;
+  $self->{shardIndexes} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{id}) {
+      $self->{id} = $vals->{id};
+    }
+    if (defined $vals->{after}) {
+      $self->{after} = $vals->{after};
+    }
+    if (defined $vals->{query}) {
+      $self->{query} = $vals->{query};
+    }
+    if (defined $vals->{filter}) {
+      $self->{filter} = $vals->{filter};
+    }
+    if (defined $vals->{numberToFetch}) {
+      $self->{numberToFetch} = $vals->{numberToFetch};
+    }
+    if (defined $vals->{aggregateResults}) {
+      $self->{aggregateResults} = $vals->{aggregateResults};
+    }
+    if (defined $vals->{sort}) {
+      $self->{sort} = $vals->{sort};
+    }
+    if (defined $vals->{doDocScores}) {
+      $self->{doDocScores} = $vals->{doDocScores};
+    }
+    if (defined $vals->{doMaxScore}) {
+      $self->{doMaxScore} = $vals->{doMaxScore};
+    }
+    if (defined $vals->{shardIndexes}) {
+      $self->{shardIndexes} = $vals->{shardIndexes};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'QueryArgs';
+}
+
+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::I64) {
+        $xfer += $input->readI64(\$self->{id});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{after} = new Blur::ScoreDoc();
+        $xfer += $self->{after}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{query} = new Blur::Query();
+        $xfer += $self->{query}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{filter});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^5$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{numberToFetch});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^6$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{aggregateResults});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^7$/ && do{      if ($ftype == TType::STRUCT) {
+        $self->{sort} = new Blur::Sort();
+        $xfer += $self->{sort}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^8$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{doDocScores});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^9$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{doMaxScore});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^10$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size71 = 0;
+          $self->{shardIndexes} = [];
+          my $_etype74 = 0;
+          $xfer += $input->readListBegin(\$_etype74, \$_size71);
+          for (my $_i75 = 0; $_i75 < $_size71; ++$_i75)
+          {
+            my $elem76 = undef;
+            $xfer += $input->readI32(\$elem76);
+            push(@{$self->{shardIndexes}},$elem76);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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('QueryArgs');
+  if (defined $self->{id}) {
+    $xfer += $output->writeFieldBegin('id', TType::I64, 1);
+    $xfer += $output->writeI64($self->{id});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{after}) {
+    $xfer += $output->writeFieldBegin('after', TType::STRUCT, 2);
+    $xfer += $self->{after}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{query}) {
+    $xfer += $output->writeFieldBegin('query', TType::STRUCT, 3);
+    $xfer += $self->{query}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{filter}) {
+    $xfer += $output->writeFieldBegin('filter', TType::STRING, 4);
+    $xfer += $output->writeString($self->{filter});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{numberToFetch}) {
+    $xfer += $output->writeFieldBegin('numberToFetch', TType::I32, 5);
+    $xfer += $output->writeI32($self->{numberToFetch});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{aggregateResults}) {
+    $xfer += $output->writeFieldBegin('aggregateResults', TType::BOOL, 6);
+    $xfer += $output->writeBool($self->{aggregateResults});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{sort}) {
+    $xfer += $output->writeFieldBegin('sort', TType::STRUCT, 7);
+    $xfer += $self->{sort}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{doDocScores}) {
+    $xfer += $output->writeFieldBegin('doDocScores', TType::BOOL, 8);
+    $xfer += $output->writeBool($self->{doDocScores});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{doMaxScore}) {
+    $xfer += $output->writeFieldBegin('doMaxScore', TType::BOOL, 9);
+    $xfer += $output->writeBool($self->{doMaxScore});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{shardIndexes}) {
+    $xfer += $output->writeFieldBegin('shardIndexes', TType::LIST, 10);
+    {
+      $xfer += $output->writeListBegin(TType::I32, scalar(@{$self->{shardIndexes}}));
+      {
+        foreach my $iter77 (@{$self->{shardIndexes}}) 
+        {
+          $xfer += $output->writeI32($iter77);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::TopFieldDocs;
+use base qw(Class::Accessor);
+Blur::TopFieldDocs->mk_accessors( qw( shardIndex totalHits scoreDocs maxScore fields ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{shardIndex} = undef;
+  $self->{totalHits} = undef;
+  $self->{scoreDocs} = undef;
+  $self->{maxScore} = undef;
+  $self->{fields} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{shardIndex}) {
+      $self->{shardIndex} = $vals->{shardIndex};
+    }
+    if (defined $vals->{totalHits}) {
+      $self->{totalHits} = $vals->{totalHits};
+    }
+    if (defined $vals->{scoreDocs}) {
+      $self->{scoreDocs} = $vals->{scoreDocs};
+    }
+    if (defined $vals->{maxScore}) {
+      $self->{maxScore} = $vals->{maxScore};
+    }
+    if (defined $vals->{fields}) {
+      $self->{fields} = $vals->{fields};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'TopFieldDocs';
+}
+
+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::I32) {
+        $xfer += $input->readI32(\$self->{shardIndex});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{totalHits});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size78 = 0;
+          $self->{scoreDocs} = [];
+          my $_etype81 = 0;
+          $xfer += $input->readListBegin(\$_etype81, \$_size78);
+          for (my $_i82 = 0; $_i82 < $_size78; ++$_i82)
+          {
+            my $elem83 = undef;
+            $elem83 = new Blur::ScoreDoc();
+            $xfer += $elem83->read($input);
+            push(@{$self->{scoreDocs}},$elem83);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::DOUBLE) {
+        $xfer += $input->readDouble(\$self->{maxScore});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^5$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size84 = 0;
+          $self->{fields} = [];
+          my $_etype87 = 0;
+          $xfer += $input->readListBegin(\$_etype87, \$_size84);
+          for (my $_i88 = 0; $_i88 < $_size84; ++$_i88)
+          {
+            my $elem89 = undef;
+            $elem89 = new Blur::SortField();
+            $xfer += $elem89->read($input);
+            push(@{$self->{fields}},$elem89);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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('TopFieldDocs');
+  if (defined $self->{shardIndex}) {
+    $xfer += $output->writeFieldBegin('shardIndex', TType::I32, 1);
+    $xfer += $output->writeI32($self->{shardIndex});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{totalHits}) {
+    $xfer += $output->writeFieldBegin('totalHits', TType::I64, 2);
+    $xfer += $output->writeI64($self->{totalHits});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{scoreDocs}) {
+    $xfer += $output->writeFieldBegin('scoreDocs', TType::LIST, 3);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{scoreDocs}}));
+      {
+        foreach my $iter90 (@{$self->{scoreDocs}}) 
+        {
+          $xfer += ${iter90}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{maxScore}) {
+    $xfer += $output->writeFieldBegin('maxScore', TType::DOUBLE, 4);
+    $xfer += $output->writeDouble($self->{maxScore});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{fields}) {
+    $xfer += $output->writeFieldBegin('fields', TType::LIST, 5);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
+      {
+        foreach my $iter91 (@{$self->{fields}}) 
+        {
+          $xfer += ${iter91}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Field;
+use base qw(Class::Accessor);
+Blur::Field->mk_accessors( qw( name value type boost ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{name} = undef;
+  $self->{value} = undef;
+  $self->{type} = undef;
+  $self->{boost} = 1;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{name}) {
+      $self->{name} = $vals->{name};
+    }
+    if (defined $vals->{value}) {
+      $self->{value} = $vals->{value};
+    }
+    if (defined $vals->{type}) {
+      $self->{type} = $vals->{type};
+    }
+    if (defined $vals->{boost}) {
+      $self->{boost} = $vals->{boost};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Field';
+}
+
+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::STRING) {
+        $xfer += $input->readString(\$self->{value});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::I32) {
+        $xfer += $input->readI32(\$self->{type});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::DOUBLE) {
+        $xfer += $input->readDouble(\$self->{boost});
+      } 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('Field');
+  if (defined $self->{name}) {
+    $xfer += $output->writeFieldBegin('name', TType::STRING, 1);
+    $xfer += $output->writeString($self->{name});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{value}) {
+    $xfer += $output->writeFieldBegin('value', TType::STRING, 2);
+    $xfer += $output->writeString($self->{value});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{type}) {
+    $xfer += $output->writeFieldBegin('type', TType::I32, 3);
+    $xfer += $output->writeI32($self->{type});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{boost}) {
+    $xfer += $output->writeFieldBegin('boost', TType::DOUBLE, 4);
+    $xfer += $output->writeDouble($self->{boost});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Document;
+use base qw(Class::Accessor);
+Blur::Document->mk_accessors( qw( fields ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{fields} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{fields}) {
+      $self->{fields} = $vals->{fields};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Document';
+}
+
+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::LIST) {
+        {
+          my $_size92 = 0;
+          $self->{fields} = [];
+          my $_etype95 = 0;
+          $xfer += $input->readListBegin(\$_etype95, \$_size92);
+          for (my $_i96 = 0; $_i96 < $_size92; ++$_i96)
+          {
+            my $elem97 = undef;
+            $elem97 = new Blur::Field();
+            $xfer += $elem97->read($input);
+            push(@{$self->{fields}},$elem97);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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('Document');
+  if (defined $self->{fields}) {
+    $xfer += $output->writeFieldBegin('fields', TType::LIST, 1);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{fields}}));
+      {
+        foreach my $iter98 (@{$self->{fields}}) 
+        {
+          $xfer += ${iter98}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Term;
+use base qw(Class::Accessor);
+Blur::Term->mk_accessors( qw( field bytes ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{field} = undef;
+  $self->{bytes} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{field}) {
+      $self->{field} = $vals->{field};
+    }
+    if (defined $vals->{bytes}) {
+      $self->{bytes} = $vals->{bytes};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Term';
+}
+
+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->{field});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::STRING) {
+        $xfer += $input->readString(\$self->{bytes});
+      } 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('Term');
+  if (defined $self->{field}) {
+    $xfer += $output->writeFieldBegin('field', TType::STRING, 1);
+    $xfer += $output->writeString($self->{field});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{bytes}) {
+    $xfer += $output->writeFieldBegin('bytes', TType::STRING, 2);
+    $xfer += $output->writeString($self->{bytes});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::MutateOptions;
+use base qw(Class::Accessor);
+Blur::MutateOptions->mk_accessors( qw( table shardIndex waitToBeVisible writeAheadLog ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{table} = undef;
+  $self->{shardIndex} = undef;
+  $self->{waitToBeVisible} = 0;
+  $self->{writeAheadLog} = 1;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{shardIndex}) {
+      $self->{shardIndex} = $vals->{shardIndex};
+    }
+    if (defined $vals->{waitToBeVisible}) {
+      $self->{waitToBeVisible} = $vals->{waitToBeVisible};
+    }
+    if (defined $vals->{writeAheadLog}) {
+      $self->{writeAheadLog} = $vals->{writeAheadLog};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'MutateOptions';
+}
+
+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::I32) {
+        $xfer += $input->readI32(\$self->{shardIndex});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{waitToBeVisible});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^4$/ && do{      if ($ftype == TType::BOOL) {
+        $xfer += $input->readBool(\$self->{writeAheadLog});
+      } 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('MutateOptions');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{shardIndex}) {
+    $xfer += $output->writeFieldBegin('shardIndex', TType::I32, 2);
+    $xfer += $output->writeI32($self->{shardIndex});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{waitToBeVisible}) {
+    $xfer += $output->writeFieldBegin('waitToBeVisible', TType::BOOL, 3);
+    $xfer += $output->writeBool($self->{waitToBeVisible});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{writeAheadLog}) {
+    $xfer += $output->writeFieldBegin('writeAheadLog', TType::BOOL, 4);
+    $xfer += $output->writeBool($self->{writeAheadLog});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::UpdatePackage;
+use base qw(Class::Accessor);
+Blur::UpdatePackage->mk_accessors( qw( term documents ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{term} = undef;
+  $self->{documents} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{term}) {
+      $self->{term} = $vals->{term};
+    }
+    if (defined $vals->{documents}) {
+      $self->{documents} = $vals->{documents};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'UpdatePackage';
+}
+
+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::STRUCT) {
+        $self->{term} = new Blur::Term();
+        $xfer += $self->{term}->read($input);
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size99 = 0;
+          $self->{documents} = [];
+          my $_etype102 = 0;
+          $xfer += $input->readListBegin(\$_etype102, \$_size99);
+          for (my $_i103 = 0; $_i103 < $_size99; ++$_i103)
+          {
+            my $elem104 = undef;
+            $elem104 = new Blur::Document();
+            $xfer += $elem104->read($input);
+            push(@{$self->{documents}},$elem104);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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('UpdatePackage');
+  if (defined $self->{term}) {
+    $xfer += $output->writeFieldBegin('term', TType::STRUCT, 1);
+    $xfer += $self->{term}->write($output);
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{documents}) {
+    $xfer += $output->writeFieldBegin('documents', TType::LIST, 2);
+    {
+      $xfer += $output->writeListBegin(TType::STRUCT, scalar(@{$self->{documents}}));
+      {
+        foreach my $iter105 (@{$self->{documents}}) 
+        {
+          $xfer += ${iter105}->write($output);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::Generation;
+use base qw(Class::Accessor);
+Blur::Generation->mk_accessors( qw( table shardIndex generation ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{table} = undef;
+  $self->{shardIndex} = undef;
+  $self->{generation} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{table}) {
+      $self->{table} = $vals->{table};
+    }
+    if (defined $vals->{shardIndex}) {
+      $self->{shardIndex} = $vals->{shardIndex};
+    }
+    if (defined $vals->{generation}) {
+      $self->{generation} = $vals->{generation};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'Generation';
+}
+
+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::I32) {
+        $xfer += $input->readI32(\$self->{shardIndex});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^3$/ && do{      if ($ftype == TType::I64) {
+        $xfer += $input->readI64(\$self->{generation});
+      } 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('Generation');
+  if (defined $self->{table}) {
+    $xfer += $output->writeFieldBegin('table', TType::STRING, 1);
+    $xfer += $output->writeString($self->{table});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{shardIndex}) {
+    $xfer += $output->writeFieldBegin('shardIndex', TType::I32, 2);
+    $xfer += $output->writeI32($self->{shardIndex});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{generation}) {
+    $xfer += $output->writeFieldBegin('generation', TType::I64, 3);
+    $xfer += $output->writeI64($self->{generation});
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+package Blur::ShardLayout;
+use base qw(Class::Accessor);
+Blur::ShardLayout->mk_accessors( qw( server shards ) );
+
+sub new {
+  my $classname = shift;
+  my $self      = {};
+  my $vals      = shift || {};
+  $self->{server} = undef;
+  $self->{shards} = undef;
+  if (UNIVERSAL::isa($vals,'HASH')) {
+    if (defined $vals->{server}) {
+      $self->{server} = $vals->{server};
+    }
+    if (defined $vals->{shards}) {
+      $self->{shards} = $vals->{shards};
+    }
+  }
+  return bless ($self, $classname);
+}
+
+sub getName {
+  return 'ShardLayout';
+}
+
+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->{server});
+      } else {
+        $xfer += $input->skip($ftype);
+      }
+      last; };
+      /^2$/ && do{      if ($ftype == TType::LIST) {
+        {
+          my $_size106 = 0;
+          $self->{shards} = [];
+          my $_etype109 = 0;
+          $xfer += $input->readListBegin(\$_etype109, \$_size106);
+          for (my $_i110 = 0; $_i110 < $_size106; ++$_i110)
+          {
+            my $elem111 = undef;
+            $xfer += $input->readI32(\$elem111);
+            push(@{$self->{shards}},$elem111);
+          }
+          $xfer += $input->readListEnd();
+        }
+      } 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('ShardLayout');
+  if (defined $self->{server}) {
+    $xfer += $output->writeFieldBegin('server', TType::STRING, 1);
+    $xfer += $output->writeString($self->{server});
+    $xfer += $output->writeFieldEnd();
+  }
+  if (defined $self->{shards}) {
+    $xfer += $output->writeFieldBegin('shards', TType::LIST, 2);
+    {
+      $xfer += $output->writeListBegin(TType::I32, scalar(@{$self->{shards}}));
+      {
+        foreach my $iter112 (@{$self->{shards}}) 
+        {
+          $xfer += $output->writeI32($iter112);
+        }
+      }
+      $xfer += $output->writeListEnd();
+    }
+    $xfer += $output->writeFieldEnd();
+  }
+  $xfer += $output->writeFieldStop();
+  $xfer += $output->writeStructEnd();
+  return $xfer;
+}
+
+1;


Mime
View raw message