Amazon-SQS-Client

 view release on metacpan or  search on metacpan

lib/Amazon/SQS/Exception.pm  view on Meta::CPAN

  else {
    $self->{_message}    = $errorInfo->{Message}    // q{};
    $self->{_statusCode} = $errorInfo->{StatusCode} // q{};
    $self->{_errorCode}  = $errorInfo->{ErrorCode}  // q{};
    $self->{_errorType}  = $errorInfo->{ErrorType}  // q{};
    $self->{_requestId}  = $errorInfo->{RequestId}  // q{};
    $self->{_xml}        = $errorInfo->{XML}        // q{};
    $self->{_httpError}  = $errorInfo->{HTTPError}  // q{};
  }

  return bless $self, $class;
}

#
# Gets error type returned by the service if available.
#
sub getErrorCode {
  return shift->{_errorCode};
}

#

lib/Amazon/SQS/Model/AddPermissionRequest.pm  view on Meta::CPAN

        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            QueueUrl => { FieldValue => undef, FieldType => "string"},
            Label => { FieldValue => undef, FieldType => "string"},
            AWSAccountId => {FieldValue => [], FieldType => ["string"]},
            ActionName => {FieldValue => [], FieldType => ["string"]},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

    
    sub getQueueUrl {
        return shift->{_fields}->{QueueUrl}->{FieldValue};

lib/Amazon/SQS/Model/AddPermissionResponse.pm  view on Meta::CPAN

    # 
    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            ResponseMetadata => {FieldValue => undef, FieldType => "Amazon::SQS::Model::ResponseMetadata"},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

       
     #
     # Construct Amazon::SQS::Model::AddPermissionResponse from XML string

lib/Amazon/SQS/Model/Attribute.pm  view on Meta::CPAN

sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
            
		      Name => { FieldValue => undef, FieldType => "string"},
		      Value => { FieldValue => undef, FieldType => "string"},
		     };

  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

    
sub getName {
  return shift->{_fields}->{Name}->{FieldValue};

lib/Amazon/SQS/Model/ChangeMessageVisibilityBatchRequest.pm  view on Meta::CPAN

# 
# 
sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      QueueUrl => { FieldValue => undef, FieldType => "string"},
		      BatchRequest => {FieldValue => [], FieldType => ["Amazon::SQS::Model::ChangeMessageVisibilityBatchRequestEntry"]},
		     };

  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}
    
sub getQueueUrl {
  return shift->{_fields}->{QueueUrl}->{FieldValue};
}

lib/Amazon/SQS/Model/ChangeMessageVisibilityBatchRequestEntry.pm  view on Meta::CPAN

sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      Id => { FieldValue => undef, FieldType => "string"},
		      ReceiptHandle => { FieldValue => undef, FieldType => "string"},
		      VisibilityTimeout => {FieldValue => undef, FieldType => "int"},
        };
  
  bless ($self, $class);
  
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
  
  return $self;
}

sub getId {
  return shift->{_fields}->{Id}->{FieldValue};

lib/Amazon/SQS/Model/ChangeMessageVisibilityBatchResponse.pm  view on Meta::CPAN

# 
# 
sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      ChangeMessageVisibilityBatchResult => {FieldValue => undef, FieldType => "Amazon::SQS::Model::ChangeMessageVisibilityBatchResult"},
		      ResponseMetadata => {FieldValue => undef, FieldType => "Amazon::SQS::Model::ResponseMetadata"},
		     };

  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

       
#
# Construct Amazon::SQS::Model::ChangeMessageVisibilityBatchResponse from XML string

lib/Amazon/SQS/Model/ChangeMessageVisibilityBatchResult.pm  view on Meta::CPAN

sub new {
  my ($class, $data) = @_;
  my $self = {};
  
  $self->{_fields} = {
		      ChangeMessageVisibilityBatchResultEntry => {
								  FieldValue => [],
								  FieldType   => ["Amazon::SQS::Model::ChangeMessageVisibilityBatchResultEntry"]},
		     };
  
  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

sub getChangeMessageVisibilityBatchResultEntry {
  return shift->{_fields}->{ChangeMessageVisibilityBatchResultEntry}->{FieldValue};
}

lib/Amazon/SQS/Model/ChangeMessageVisibilityBatchResultEntry.pm  view on Meta::CPAN

# Id: "string"
#

sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      Id  => {FieldValue => undef, FieldType => "string"}
		     };

  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

sub getId {
  return shift->{_fields}->{Id}->{FieldValue};
}

lib/Amazon/SQS/Model/ChangeMessageVisibilityRequest.pm  view on Meta::CPAN

        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            QueueUrl => { FieldValue => undef, FieldType => "string"},
            ReceiptHandle => { FieldValue => undef, FieldType => "string"},
            VisibilityTimeout => { FieldValue => undef, FieldType => "int"},
            Attribute => {FieldValue => [], FieldType => ["Amazon::SQS::Model::Attribute"]},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

    
    sub getQueueUrl {
        return shift->{_fields}->{QueueUrl}->{FieldValue};

lib/Amazon/SQS/Model/ChangeMessageVisibilityResponse.pm  view on Meta::CPAN

#
# 
# 
sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      ResponseMetadata => {FieldValue => undef, FieldType => "Amazon::SQS::Model::ResponseMetadata"},
		     };
  
  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

       
#
# Construct Amazon::SQS::Model::ChangeMessageVisibilityResponse from XML string

lib/Amazon/SQS/Model/CreateQueueRequest.pm  view on Meta::CPAN

sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      QueueName => { FieldValue => undef, FieldType => "string"},
		      DefaultVisibilityTimeout => { FieldValue => undef, FieldType => "int"},
		      Attribute => {FieldValue => [], FieldType => ["Amazon::SQS::Model::Attribute"]},
		     };

  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

    
sub getQueueName {
  return shift->{_fields}->{QueueName}->{FieldValue};

lib/Amazon/SQS/Model/CreateQueueResponse.pm  view on Meta::CPAN

    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            CreateQueueResult => {FieldValue => undef, FieldType => "Amazon::SQS::Model::CreateQueueResult"},
            ResponseMetadata => {FieldValue => undef, FieldType => "Amazon::SQS::Model::ResponseMetadata"},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

       
     #
     # Construct Amazon::SQS::Model::CreateQueueResponse from XML string

lib/Amazon/SQS/Model/CreateQueueResult.pm  view on Meta::CPAN

    # 
    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            QueueUrl => { FieldValue => undef, FieldType => "string"},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

    
    sub getQueueUrl {
        return shift->{_fields}->{QueueUrl}->{FieldValue};

lib/Amazon/SQS/Model/DeleteMessageBatchRequest.pm  view on Meta::CPAN

# 
# 
sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      QueueUrl => { FieldValue => undef, FieldType => "string"},
		      DeleteMessageBatchRequestEntry => { FieldValue => [], FieldType => ["Amazon::SQS::Model::DeleteMessageBatchRequestEntry"]}
		     };
  
  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
  
  return $self;
}
    

sub getQueueUrl {
  return shift->{_fields}->{QueueUrl}->{FieldValue};

lib/Amazon/SQS/Model/DeleteMessageBatchRequestEntry.pm  view on Meta::CPAN

=cut

sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      Id => { FieldValue => undef, FieldType => "string"},
		      ReceiptHandle => { FieldValue => undef, FieldType => "string" }
        };
  
  bless ($self, $class);
  
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
  
  return $self;
}

sub getId {
  return shift->{_fields}->{Id}->{FieldValue};

lib/Amazon/SQS/Model/DeleteMessageBatchResponse.pm  view on Meta::CPAN

#

sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      DeleteMessageBatchResult => { FieldValue => undef, FieldType => "Amazon::SQS::Model::DeleteMessageBatchResult" },
		      ResponseMetadata => {FieldValue => undef, FieldType => "Amazon::SQS::Model::ResponseMetadata"},
		     };

  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

       
#
# Construct Amazon::SQS::Model::DeleteMessageBatchResponse from XML string

lib/Amazon/SQS/Model/DeleteMessageBatchResult.pm  view on Meta::CPAN

sub new {
  my ($class, $data) = @_;
  my $self = {};
  
  $self->{_fields} = {
		      DeleteMessageBatchResultEntry => {
							FieldValue => [],
							FieldType   => ["Amazon::SQS::Model::DeleteMessageBatchResultEntry"]},
		     };
  
  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

sub getDeleteMessageBatchResultEntry {
  return shift->{_fields}->{DeleteMessageBatchResultEntry}->{FieldValue};
}

lib/Amazon/SQS/Model/DeleteMessageBatchResultEntry.pm  view on Meta::CPAN

# Id: "string"
#

sub new {
  my ($class, $data) = @_;
  my $self = {};
  $self->{_fields} = {
		      Id  => {FieldValue => undef, FieldType => "string"}
		     };

  bless ($self, $class);
  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

sub getId {
  return shift->{_fields}->{Id}->{FieldValue};
}

lib/Amazon/SQS/Model/DeleteMessageRequest.pm  view on Meta::CPAN

    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            QueueUrl => { FieldValue => undef, FieldType => "string"},
            ReceiptHandle => { FieldValue => undef, FieldType => "string"},
            Attribute => {FieldValue => [], FieldType => ["Amazon::SQS::Model::Attribute"]},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

    
    sub getQueueUrl {
        return shift->{_fields}->{QueueUrl}->{FieldValue};

lib/Amazon/SQS/Model/DeleteMessageResponse.pm  view on Meta::CPAN

    # 
    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            ResponseMetadata => {FieldValue => undef, FieldType => "Amazon::SQS::Model::ResponseMetadata"},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

       
     #
     # Construct Amazon::SQS::Model::DeleteMessageResponse from XML string

lib/Amazon/SQS/Model/DeleteQueueRequest.pm  view on Meta::CPAN

    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            QueueUrl => { FieldValue => undef, FieldType => "string"},
            Attribute => {FieldValue => [], FieldType => ["Amazon::SQS::Model::Attribute"]},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

    
    sub getQueueUrl {
        return shift->{_fields}->{QueueUrl}->{FieldValue};

lib/Amazon/SQS/Model/DeleteQueueResponse.pm  view on Meta::CPAN

    # 
    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            ResponseMetadata => {FieldValue => undef, FieldType => "Amazon::SQS::Model::ResponseMetadata"},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

       
     #
     # Construct Amazon::SQS::Model::DeleteQueueResponse from XML string

lib/Amazon/SQS/Model/Error.pm  view on Meta::CPAN

        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            Type => { FieldValue => undef, FieldType => "string"},
            Code => { FieldValue => undef, FieldType => "string"},
            Message => { FieldValue => undef, FieldType => "string"},
            Detail => {FieldValue => undef, FieldType => "Amazon::SQS::Model::Object"},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

    
    sub getType {
        return shift->{_fields}->{Type}->{FieldValue};

lib/Amazon/SQS/Model/ErrorResponse.pm  view on Meta::CPAN

    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            Error => {FieldValue => [], FieldType => ["Amazon::SQS::Model::Error"]},
            RequestId => { FieldValue => undef, FieldType => "string"},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

       
     #
     # Construct Amazon::SQS::Model::ErrorResponse from XML string

lib/Amazon/SQS/Model/GetQueueAttributesRequest.pm  view on Meta::CPAN

    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            QueueUrl => { FieldValue => undef, FieldType => "string"},
            AttributeName => {FieldValue => [], FieldType => ["string"]},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

    
    sub getQueueUrl {
        return shift->{_fields}->{QueueUrl}->{FieldValue};

lib/Amazon/SQS/Model/GetQueueAttributesResponse.pm  view on Meta::CPAN

    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            GetQueueAttributesResult => {FieldValue => undef, FieldType => "Amazon::SQS::Model::GetQueueAttributesResult"},
            ResponseMetadata => {FieldValue => undef, FieldType => "Amazon::SQS::Model::ResponseMetadata"},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

       
     #
     # Construct Amazon::SQS::Model::GetQueueAttributesResponse from XML string

lib/Amazon/SQS/Model/GetQueueAttributesResult.pm  view on Meta::CPAN

    # 
    # 
    sub new {
        my ($class, $data) = @_;
        my $self = {};
        $self->{_fields} = {
            
            Attribute => {FieldValue => [], FieldType => ["Amazon::SQS::Model::Attribute"]},
        };

        bless ($self, $class);
        if (defined $data) {
           $self->_fromHashRef($data); 
        }
        
        return $self;
    }

        sub getAttribute {
        return shift->{_fields}->{Attribute}->{FieldValue};
    }

lib/Amazon/SQS/Model/ListDeadLetterSourceQueuesRequest.pm  view on Meta::CPAN

sub new {
  my ($class, $data) = @_;

  my $self = {};

  $self->{_fields} = {
		      QueueUrl => { FieldValue => undef, FieldType => "string"}
		     };
  
  bless ($self, $class);

  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

    
sub getQueueUrl {

lib/Amazon/SQS/Model/ListDeadLetterSourceQueuesResponse.pm  view on Meta::CPAN

							   FieldValue => undef,
							   FieldType => "Amazon::SQS::Model::ListDeadLetterSourceQueuesResult"
							  },

		      ResponseMetadata => {
					   FieldValue => undef, 
					   FieldType => "Amazon::SQS::Model::ResponseMetadata"
					  },
		     };

  bless ($self, $class);

  if (defined $data) {
    $self->_fromHashRef($data); 
  }
        
  return $self;
}

       
#