<?xml version="1.0" encoding="UTF-8"?>
<commit>
  <added type="array"/>
  <modified type="array">
    <modified>
      <diff>@@ -1,5 +1,8 @@
 Revision history for Net-Jabber-Bot
 
+2.1.0 
+MOOSE!!!
+
 2.0.9
 New subroutines (AddUser, RmUser, GetStatus, GetRoster) to track ??? 
 IsConnected reports connect status now.</diff>
      <filename>Changes</filename>
    </modified>
    <modified>
      <diff>@@ -1,6 +1,6 @@
 --- #YAML:1.0
 name:                Net-Jabber-Bot
-version:             2.0.9
+version:             2.1.0
 abstract:            Automated Bot creation with safeties
 license:             ~
 generated_by:   Todd Rinaldo &lt;toddr@null.net&gt;</diff>
      <filename>META.yml</filename>
    </modified>
    <modified>
      <diff>@@ -1,19 +1,21 @@
-use strict;
-use warnings;
-use ExtUtils::MakeMaker;
-
-WriteMakefile(
-    NAME                =&gt; 'Net::Jabber::Bot',
-    AUTHOR              =&gt; 'Todd E Rinaldo &lt;perl-net-jabber-bot@googlegroups.com&gt;',
-    VERSION_FROM        =&gt; 'lib/Net/Jabber/Bot.pm',
-    ABSTRACT_FROM       =&gt; 'lib/Net/Jabber/Bot.pm',
-    PL_FILES            =&gt; {},
-    PREREQ_PM =&gt; {
-        'Class::Std' =&gt; 0,  # For testing
-        'Test::More' =&gt; 0,  # For testing
-        'Net::Jabber' =&gt; 2.0,  # The whole thing is based on Net::Jabber. 
-        'Log::Log4perl' =&gt; 0,  # We use log4perl. not sure how bad this'll screw people over... should consider removal later or make it optional
-    },
-    dist                =&gt; { COMPRESS =&gt; 'gzip -9f', SUFFIX =&gt; 'gz', },
-    clean               =&gt; { FILES =&gt; 'Net-Jabber-Bot-*' },
-);
+use strict;
+use warnings;
+use ExtUtils::MakeMaker;
+
+WriteMakefile(
+    NAME                =&gt; 'Net::Jabber::Bot',
+    AUTHOR              =&gt; 'Todd E Rinaldo &lt;perl-net-jabber-bot@googlegroups.com&gt;',
+    VERSION_FROM        =&gt; 'lib/Net/Jabber/Bot.pm',
+    ABSTRACT_FROM       =&gt; 'lib/Net/Jabber/Bot.pm',
+    PL_FILES            =&gt; {},
+    PREREQ_PM =&gt; {
+        'Moose' =&gt; 0,  # Object Base
+	'Moose::Util::TypeConstraints' =&gt; 0, # New variable types
+	'Time::HiRes' =&gt; 0, # Partial second sleeping
+        'Test::More' =&gt; 0,  # For testing
+        'Net::Jabber' =&gt; 2.0,  # The whole thing is based on Net::Jabber. 
+        'Log::Log4perl' =&gt; 0,  # We use log4perl. not sure how bad this'll screw people over... should consider removal later or make it optional
+    },
+    dist                =&gt; { COMPRESS =&gt; 'gzip -9f', SUFFIX =&gt; 'gz', },
+    clean               =&gt; { FILES =&gt; 'Net-Jabber-Bot-*' },
+);</diff>
      <filename>Makefile.PL</filename>
    </modified>
    <modified>
      <diff>@@ -3,7 +3,7 @@ Net-Jabber-Bot
 This is the readme on how to install Jabber Bot
 
 Pre-Reqs - 
-Class::Std
+Moose
 Net::Jabber
 
 INSTALLATION</diff>
      <filename>README</filename>
    </modified>
    <modified>
      <diff>@@ -9,25 +9,71 @@ use Net::Jabber;
 use Time::HiRes;
 use Log::Log4perl qw(:easy);
 #use Data::Dumper; #For testing only.
-use Class::Std;
-
-my %jabber_client   : ATTR; # Keep track of the jabber object we are using.
-my %connection_hash : ATTR; # Keep track of connection options fed to client.
-my %connection_session_id : ATTR; # Reverse hash where we'll figure out what object we are...
-my %message_function : ATTR; # What is called if we are fed a new message once we are logged in.
-my %bot_background_activity : ATTR; # What is called if we are fed a new message once we are logged in.
-my %forum_join_time : ATTR; # Tells us if we've parsed historical messages yet.
-my %client_start_time :ATTR; # Track when we came online. Also used to determine if we're online.
-my %process_timeout : ATTR; # Time to take in process loop if no messages found
-my %loop_sleep_time : ATTR; # Time to sleep each time we go through a Start() loop.
-my %ignore_messages : ATTR; #Messages to ignore if we recieve them.
-my %forums_and_responses: ATTR; # List of forums we have joined and who we respond to in each forum
-my %message_delay: ATTR; # Allows us to limit Messages per second
-my %max_message_size: ATTR; # Maximum allowed message size before we chunk them.
-my %forum_join_grace: ATTR; # Time before we start responding to forum messages.
-my %messages_sent_today: ATTR; # Tracks messages sent in 2 dimentional hash by day/hour
-my %max_messages_per_hour: ATTR; # Limits the number of messages per hour.
-my %safety_mode: ATTR; # Tracks if we are in safety mode.
+use Moose;
+use Moose::Util::TypeConstraints;
+
+coerce 'Bool'
+    =&gt; from 'Str'
+            =&gt; via {($_ =~ m/(^on$)|(^true$)/i) + 0}; # True if it's on or true. Otherwise false.
+
+subtype 'JabberClientObject'    =&gt; as 'Object' =&gt; where { $_-&gt;isa('Net::Jabber::Client') };
+has jabber_client               =&gt; (isa =&gt; 'JabberClientObject', 
+                                    is =&gt; 'rw',
+                                    default =&gt; sub {Net::Jabber::Client-&gt;new});
+#my %connection_hash : ATTR; # Keep track of connection options fed to client.
+
+has 'client_session_id' =&gt; (isa =&gt; 'Int', is =&gt; 'rw');
+has 'connect_time'        =&gt; (isa =&gt; 'Int', is =&gt; 'rw', where { $_ &gt; 0 });
+has 'forum_join_grace'    =&gt; (isa =&gt; 'Num', is =&gt; 'rw', where { $_ &gt; 0 });
+has 'server_host '        =&gt; (isa =&gt; 'Str', is =&gt; 'rw');
+has 'server'              =&gt; (isa =&gt; 'Str', is =&gt; 'rw');
+has 'port'                =&gt; (isa =&gt; 'Int', is =&gt; 'rw', default =&gt; 5222, where { $_ &gt; 0 });
+has 'tls'                 =&gt; (isa =&gt; 'Bool', is =&gt; 'rw');
+has 'conference_server'   =&gt; (isa =&gt; 'Str', is =&gt; 'rw');
+has 'username'            =&gt; (isa =&gt; 'Str', is =&gt; 'rw');
+has 'password'            =&gt; (isa =&gt; 'Str', is =&gt; 'rw');
+has 'alias'               =&gt; (isa =&gt; 'Str', is =&gt; 'rw', default =&gt; sub{'net_jabber_bot'});
+has 'message_function'    =&gt; (isa =&gt; 'Maybe[CodeRef]', is =&gt; 'rw', default =&gt; undef);
+has 'background_function' =&gt; (isa =&gt; 'Maybe[CodeRef]', is =&gt; 'rw', default =&gt; undef);
+has 'loop_sleep_time'     =&gt; (isa =&gt; 'Num', is =&gt; 'rw', default =&gt; 5, where { $_ &gt; 0 });
+has 'process_timeout'     =&gt; (isa =&gt; 'Num', is =&gt; 'rw', default =&gt; 5, where { $_ &gt; 0 });
+has 'from_full'           =&gt; (isa =&gt; 'Str', is =&gt; 'rw', default =&gt; sub{my $self = shift; 
+                                                                       $self-&gt;username . 
+                                                                       '@' . 
+                                                                       $self-&gt;server .
+                                                                       '/' .
+                                                                       $self-&gt;alias});
+
+has 'safety_mode'            =&gt; (isa =&gt; 'Bool', is =&gt; 'rw', default =&gt; 1, coerce =&gt; 1);
+has 'gtalk'                  =&gt; (isa =&gt; 'Bool', is =&gt; 'rw', default =&gt; 0, coerce =&gt; 1);
+has 'ignore_server_messages' =&gt; (isa =&gt; 'Bool', is =&gt; 'rw', default =&gt; 1, coerce =&gt; 1);
+has 'ignore_self_messages'   =&gt; (isa =&gt; 'Bool', is =&gt; 'rw', default =&gt; 1, coerce =&gt; 1);
+has 'forums_and_responses'   =&gt; (isa =&gt; 'HashRef[Str]', is =&gt; 'rw'); # List of forums we're in and the strings we monitor for.
+has 'forum_join_time'        =&gt; (isa =&gt; 'HashRef[Int]', is =&gt; 'rw'); # List of when we joined each forum
+has 'out_messages_per_second' =&gt; (isa =&gt; 'Num', is =&gt; 'rw', default =&gt; 5, where { $_ &gt; 0 });
+has 'message_delay'           =&gt; (isa =&gt; 'Num', is =&gt; 'rw', where { $_ &gt; 0 }, default =&gt; sub {1/shift-&gt;out_messages_per_second});
+
+has 'max_message_size'        =&gt; (isa =&gt; 'Int', is =&gt; 'rw', default =&gt; 1,000,000 , where { $_ &gt; 100 });
+has 'max_messages_per_hour'   =&gt; (isa =&gt; 'Int', is =&gt; 'rw', default =&gt; 1,000,000 , where { $_ &gt; 100 });
+
+# Initialize this hour's message count.
+has 'messages_sent_today'     =&gt; (isa =&gt; 'HashRef', is =&gt; 'ro', default =&gt; {(localtime)[7] =&gt; {(localtime)[2] =&gt; 0}}); 
+
+
+#my %message_function : ATTR; # What is called if we are fed a new message once we are logged in.
+#my %bot_background_activity : ATTR; # What is called if we are fed a new message once we are logged in.
+#my %forum_join_time : ATTR;  # Tells us if we've parsed historical messages yet.
+#my %client_start_time :ATTR; # Track when we came online. Also used to determine if we're online.
+#my %process_timeout : ATTR;  # Time to take in process loop if no messages found
+#my %loop_sleep_time : ATTR;  # Time to sleep each time we go through a Start() loop.
+#my %ignore_messages : ATTR;  # Messages to ignore if we recieve them.
+#my %forums_and_responses: ATTR; # List of forums we have joined and who we respond to in each forum
+#my %message_delay: ATTR;    # Allows us to limit Messages per second
+#my %max_message_size: ATTR; # Maximum allowed message size before we chunk them.
+#my %forum_join_grace: ATTR; # Time before we start responding to forum messages.
+#my %messages_sent_today: ATTR;   # Tracks messages sent in 2 dimentional hash by day/hour
+#my %max_messages_per_hour: ATTR; # Limits the number of messages per hour.
+#my %safety_mode: ATTR; # Tracks if we are in safety mode.
 
 =head1 NAME
 
@@ -35,16 +81,16 @@ Net::Jabber::Bot - Automated Bot creation with safeties
 
 =head1 VERSION
 
-Version 2.0.9
+Version 2.1.0
 
 =cut
 
-our $VERSION = '2.0.9';
+our $VERSION = '2.1.0';
 
 =head1 SYNOPSIS
 
 Program design:
-This module is an inside out Perl Module leveraging Class::Std.
+This is a Moose based Class.
 
 The idea behind the module is that someone creating a bot should not really have to know a whole lot about how the Jabber protocol works in order to use it. It also allows us to abstract away all the things that can get a bot maker into trouble. Essentially the object helps protect the coders from their own mistakes.
 
@@ -93,7 +139,7 @@ if you do not export anything, such as for a purely object-oriented module.
 
 =item B&lt;new&gt;
 
-    my $bot = Net::Jabber::Bot-&gt;new({
+    my $bot = Net::Jabber::Bot-&gt;new(
                                  server =&gt; 'host.domain.com' # Name of server when sending messages internally.
                                 , conference_server =&gt; 'conference.host.domain.com'
                                 , server_host =&gt; 'talk.domain.com', # used to specify what jabber server to connect to on connect?
@@ -113,10 +159,10 @@ if you do not export anything, such as for a purely object-oriented module.
                                 , max_message_size =&gt; 1000
                                 , max_messages_per_hour =&gt; 100
                                 , gtalk =&gt; 0 # Default to off, 1 for on. needed now due to gtalk differences from std jabber server.
-                            });
+                            );
 
 
-Setup the object and connect to the server. Hash values are passed to new as a ref (I think) uses Class::Std
+Setup the object and connect to the server. Hash values are passed to new as a hash.
 
 The following initialization variables can be passed. Only marked variables are required (TODO)
 
@@ -223,123 +269,37 @@ safetey: 166
 
 # Handle initialization of objects of this class...
 sub BUILD {
-    my ($self, $obj_ID, $arg_ref) = @_;
+    my ($self, $params) = @_;
 
 
-    $client_start_time{$obj_ID} = 0; # Initially disconnected.
-    
-    $forum_join_grace{$obj_ID} = 20;
-
-    # Safety mode is on unless they feed us 0 or off explicitly
-    $safety_mode{$obj_ID} = $arg_ref-&gt;{'safety_mode'};
-    if(!defined $safety_mode{$obj_ID}
-       || $safety_mode{$obj_ID} !~ m/^\s*off\s*$/i
-       || $safety_mode{$obj_ID} != 0) {
-    $safety_mode{$obj_ID} = 0;
-    } else {
-    $safety_mode{$obj_ID} = 1;
-    }
-
-    if($arg_ref-&gt;{'gtalk'}) { # Google settings we're auto-setting
-        $connection_hash{$obj_ID}{'server_host'} = 'gmail.com';
-        $connection_hash{$obj_ID}{'tls'} = 1;
+    if($self-&gt;gtalk) { # Google settings we're auto-setting
+        $self-&gt;server_host('gmail.com');
+        $self-&gt;tls(1);
     }
 
-    if(defined $arg_ref-&gt;{'server_host'}) {
-        $connection_hash{$obj_ID}{'server_host'} = $arg_ref-&gt;{'server_host'} # Actual server to connect to.
-    }
-
-    # Added tls option (used for gtalk for sure)
-    $connection_hash{$obj_ID}{'tls'} = $arg_ref-&gt;{'tls'};
-
-    $connection_hash{$obj_ID}{'server'} = $arg_ref-&gt;{'server'};
-    $connection_hash{$obj_ID}{'conference_server'} = $arg_ref-&gt;{'conference_server'};
-
-
-    $connection_hash{$obj_ID}{'port'} = $arg_ref-&gt;{'port'};
-    $connection_hash{$obj_ID}{'port'} = 5222 if(!defined $connection_hash{$obj_ID}{'port'});
-
-    $connection_hash{$obj_ID}{'username'} = $arg_ref-&gt;{'username'};
-    $connection_hash{$obj_ID}{'password'} = $arg_ref-&gt;{'password'};
-
-    $connection_hash{$obj_ID}{'alias'} = $arg_ref-&gt;{'alias'}
-    or $connection_hash{$obj_ID}{'alias'} = 'net_jabber_bot';
-
-    $message_function{$obj_ID} = $arg_ref-&gt;{'message_callback'};
-    $bot_background_activity{$obj_ID} = $arg_ref-&gt;{'background_activity'};
-
-    $loop_sleep_time{$obj_ID} = $arg_ref-&gt;{'loop_sleep_time'}
-    or $loop_sleep_time{$obj_ID} = 5;
 
-    $process_timeout{$obj_ID} = $arg_ref-&gt;{'process_timeout'}
-    or $process_timeout{$obj_ID} = 5;
-
-    $connection_hash{$obj_ID}{'from_full'} =
-    &quot;$connection_hash{$obj_ID}{'username'}\@$connection_hash{$obj_ID}{'server'}/$connection_hash{$obj_ID}{'alias'}&quot;;
-
-    $ignore_messages{$obj_ID}{ignore_server_messages} = $arg_ref-&gt;{'ignore_server_messages'};
-    $ignore_messages{$obj_ID}{ignore_server_messages} = 1 if(!defined $ignore_messages{$obj_ID}{ignore_server_messages});
-
-    $ignore_messages{$obj_ID}{ignore_self_messages} = $arg_ref-&gt;{'ignore_self_messages'};
-    $ignore_messages{$obj_ID}{ignore_self_messages} = 1 if(!defined $ignore_messages{$obj_ID}{ignore_self_messages});
-
-    $forums_and_responses{$obj_ID} = $arg_ref-&gt;{'forums_and_responses'};
-
-    my $out_messages_per_second = $arg_ref-&gt;{'out_messages_per_second'};
-    $out_messages_per_second = 5
-    if(!defined $out_messages_per_second || $out_messages_per_second &lt;= 0); # Can't be &lt; 0 or undef
-
-    $message_delay{$obj_ID} = 1 / $out_messages_per_second;
-
-    # Set the maximum chunk size to fed value if it's reasonable.
-    if(defined $arg_ref-&gt;{'max_message_size'} &amp;&amp; $arg_ref-&gt;{'max_message_size'} &gt; 100) { # Can't be &lt; 100 (don't be silly)
-    $max_message_size{$obj_ID} = $arg_ref-&gt;{'max_message_size'};
-    } else {
-    $max_message_size{$obj_ID} = 1,000,000; # Set it to one meg if not specified.
-    }
-
-    # Set the maximum messages per day limit to fed value if it's within reason
-    if(defined $arg_ref-&gt;{'max_messages_per_hour'} &amp;&amp; $arg_ref-&gt;{'max_messages_per_hour'} &gt; 0) { # Must be undef and &gt; 0
-    $max_messages_per_hour{$obj_ID} = $arg_ref-&gt;{'max_messages_per_hour'};
-    } else {
-    # Set it to a really big number (Safety will catch if you're not dumb enough to disable it.)
-    $max_messages_per_hour{$obj_ID} = 1,000,000;
-    }
-
-    # Initialize today's message count.
-    my $yday = (localtime)[7];
-    my $hour = (localtime)[2];
-    $messages_sent_today{$obj_ID}{$yday}{$hour} = 0;
 
     # Enforce all our safety restrictions here.
-    if($safety_mode{$obj_ID}) {
-    # more than 5 messages per second risks server flooding.
-    $safety_mode{$obj_ID} = 1/5 if($message_delay{$obj_ID} &lt; 1/5);
+    if($self-&gt;safety_mode) {
+        # more than 5 messages per second risks server flooding.
+        $self-&gt;message_delay(1/5) if($self-&gt;message_delay &lt; 1/5);
 
-    # Messages should be small to not overwhelm rooms/people/server
-    $max_message_size{$obj_ID} = 1000 if($max_message_size{$obj_ID} &gt; 1000);
+        # Messages should be small to not overwhelm rooms/people/server
+        $self-&gt;max_message_size(1000) if($self-&gt;max_message_size &gt; 1000);
 
-    # More than 4,000 messages a day is a little excessive.
-    $max_messages_per_hour{$obj_ID} = 125 if($max_message_size{$obj_ID} &gt; 166);
+        # More than 4,000 messages a day is a little excessive.
+        $self-&gt;max_messages_per_hour(125) if($self-&gt;max_message_size &gt; 166);
 
-    # Should not be responding to self messages to prevent loops.
-    $ignore_messages{$obj_ID}{ignore_self_messages} = 1;
+        # Should not be responding to self messages to prevent loops.
+        $self-&gt;ignore_self_messages(1);
     }
-}
-
-=item B&lt;START&gt;
-
-Sets up the special message handling and then initializes the connection.
-
-=cut
-
-sub START {
-   my ($self, $obj_ID, $arg_ref) = @_;
-   $self-&gt;InitJabber(); # Will not connect now until 
+    
+    #Initialize the connection.
+    $self-&gt;InitJabber;
 }
 
 # Return a code reference that will pass self in addition to arguements passed to callback code ref.
-sub callback_maker : PRIVATE {
+sub callback_maker {
     my $self = shift;
     my $Function = shift;
 
@@ -348,18 +308,15 @@ sub callback_maker : PRIVATE {
 }
 
 # Creates client object and manages connection. Called on new but also called by re-connect
-sub InitJabber : PRIVATE {
+sub InitJabber {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
     # Determine if the object already exists and if not, create it.
-    my $client_exists = 1;
     DEBUG(&quot;new client object.&quot;);
-    if(!defined $jabber_client{$obj_ID}) { # If client was fed in for test?
-        $jabber_client{$obj_ID} = new Net::Jabber::Client();
-        $client_exists = 0;
+    if(!$self-&gt;jabber_client) { # If client was fed in for test?
+        $self-&gt;jabber_client(Net::Jabber::Client-&gt;new);
     }
-    my $connection = $jabber_client{$obj_ID};
+    my $connection = $self-&gt;jabber_client;
 
     DEBUG(&quot;Set the call backs.&quot;);
 
@@ -370,14 +327,13 @@ sub InitJabber : PRIVATE {
                               ,'iq'       =&gt; $self-&gt;callback_maker(\&amp;InIQ)
                               );
 
-    DEBUG(&quot;Connect. hostname =&gt; $connection_hash{$obj_ID}{'server'} , port =&gt; $connection_hash{$obj_ID}{'port'}&quot;);
-    my %client_connect_hash;
-    $client_connect_hash{hostname} = $connection_hash{$obj_ID}{'server'};
-    $client_connect_hash{port}     = $connection_hash{$obj_ID}{'port'};
-    $client_connect_hash{connectiontype} = 'tcpip';
-
-    # Currently have to set this for google.
-    $client_connect_hash{tls} = '1' if($connection_hash{$obj_ID}{'tls'});
+    DEBUG(&quot;Connect. hostname =&gt; $self-&gt;server() , port =&gt; $self-&gt;port()&quot;);
+    my %client_connect_hash = (
+        hostname =&gt; $self-&gt;server,
+        port =&gt; $self-&gt;port,
+        tls =&gt; $self-&gt;tls,
+        connection_type =&gt; 'tcpip',
+    );
 
     my $status = $connection-&gt;Connect(%client_connect_hash);
 
@@ -386,27 +342,28 @@ sub InitJabber : PRIVATE {
        return;
     }
 
-    DEBUG(&quot;Logging in... as user $connection_hash{$obj_ID}{'username'} / $connection_hash{$obj_ID}{'alias'}&quot;);
+    DEBUG(&quot;Logging in... as user $self-&gt;username / $self-&gt;alias&quot;);
 
     my $sid = $connection-&gt;{SESSION}-&gt;{id};
-    $connection-&gt;{STREAM}-&gt;{SIDS}-&gt;{$sid}-&gt;{hostname} = $connection_hash{$obj_ID}{'server_host'};
+    $connection-&gt;{STREAM}-&gt;{SIDS}-&gt;{$sid}-&gt;{hostname} = $self-&gt;server_host;
 
 
-    my @auth_result = $connection-&gt;AuthSend(username=&gt;$connection_hash{$obj_ID}{'username'},
-                                            password=&gt;$connection_hash{$obj_ID}{'password'},
-                                            resource=&gt;$connection_hash{$obj_ID}{'alias'});
+    my @auth_result = $connection-&gt;AuthSend(username =&gt; $self-&gt;username,
+                                            password =&gt; $self-&gt;password,
+                                            resource =&gt; $self-&gt;alias,
+                                            );
 
     if(!defined $auth_result[0] || $auth_result[0] ne &quot;ok&quot;) {
-    ERROR(&quot;ERROR: Authorization failed: for $connection_hash{$obj_ID}{'username'} / $connection_hash{$obj_ID}{'alias'}&quot;);
-    foreach my $result (@auth_result) {
-        ERROR(&quot;$result&quot;);
-    }
-    return;
+        ERROR(&quot;ERROR: Authorization failed: for $self-&gt;username / $self-&gt;alias&quot;);
+        foreach my $result (@auth_result) {
+            ERROR(&quot;$result&quot;);
+        }
+        return;
     }
 
     $connection-&gt;RosterRequest();
 
-    $connection_session_id{$obj_ID} = $connection-&gt;{SESSION}-&gt;{id};
+    $self-&gt;client_session_id($connection-&gt;{SESSION}-&gt;{id}); 
 
     DEBUG(&quot;Sending presence to tell world that we are logged in&quot;);
     $connection-&gt;PresenceSend();
@@ -416,12 +373,12 @@ sub InitJabber : PRIVATE {
     $connection-&gt;RosterGet();
     $self-&gt;Process(5);
 
-    foreach my $forum (keys %{$forums_and_responses{$obj_ID}}) {
+    foreach my $forum (keys %{$self-&gt;forums_and_responses}) {
         $self-&gt;JoinForum($forum);
     }
 
-    INFO(&quot;Connected to server '$connection_hash{$obj_ID}{'server'}' successfully&quot;);
-    $client_start_time{$obj_ID} = time; # Track when we came online.
+    INFO(&quot;Connected to server '$self-&gt;server' successfully&quot;);
+    $self-&gt;connect_time(time); # Track when we came online.
     return 1;
 }
 
@@ -437,19 +394,17 @@ NOTE: No error detection for join failure is present at the moment. (TODO)
 
 sub JoinForum {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
-
     my $forum_name = shift;
 
-    DEBUG(&quot;Joining $forum_name on $connection_hash{$obj_ID}{'conference_server'} as $connection_hash{$obj_ID}{alias}&quot;);
-    $jabber_client{$obj_ID}-&gt;MUCJoin(room    =&gt; $forum_name
-                     , server =&gt; $connection_hash{$obj_ID}{'conference_server'}
-                     , nick   =&gt; $connection_hash{$obj_ID}{'alias'}
-                     );
+    DEBUG(&quot;Joining $forum_name on $self-&gt;conference_server as $self-&gt;alias&quot;);
+    $self-&gt;jabber_client-&gt;MUCJoin(room    =&gt; $forum_name,
+                                  server =&gt; $self-&gt;conference_server,
+                                  nick   =&gt; $self-&gt;alias,
+                                  );
 
-    $forum_join_time{$obj_ID}{$forum_name} = time;
-    DEBUG(&quot;Sleeping $message_delay{$obj_ID} seconds&quot;);
-    Time::HiRes::sleep $message_delay{$obj_ID};
+    $self-&gt;forum_join_time(time);
+    DEBUG(&quot;Sleeping $self-&gt;message_delay seconds&quot;);
+    Time::HiRes::sleep $self-&gt;message_delay;
 }
 
 =item B&lt;Process&gt;
@@ -463,13 +418,12 @@ You should mostly be calling Start() and just let the Bot kernel handle all this
 
 sub Process { # Call connection process.
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
     my $timeout_seconds = shift;
 
     #If not passed explicitly
-    $timeout_seconds = $process_timeout{$obj_ID} if(!defined $timeout_seconds);
+    $timeout_seconds = $self-&gt;process_timeout if(!defined $timeout_seconds);
 
-    my $process_return = $jabber_client{$obj_ID}-&gt;Process($timeout_seconds);
+    my $process_return = $self-&gt;jabber_client-&gt;Process($timeout_seconds);
     return $process_return;
 }
 
@@ -485,12 +439,11 @@ Primary subroutine save new called by the program. Does an endless loop of:
 
 sub Start {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
-    my $time_between_background_routines = $loop_sleep_time{$obj_ID};
-    my $process_timeout = $process_timeout{$obj_ID};
-    my $background_subroutine = $bot_background_activity{$obj_ID};
-    my $message_delay = $message_delay{$obj_ID};
+    my $time_between_background_routines = $self-&gt;loop_sleep_time;
+    my $process_timeout = $self-&gt;process_timeout;
+    my $background_subroutine = $self-&gt;background_function;
+    my $message_delay = $self-&gt;message_delay;
 
     my $last_background = time - $time_between_background_routines - 1; # Call background process every so often...
     my $counter = 0; # Keep track of how many times we've looped. Not sure if we'll use this long term.
@@ -501,8 +454,8 @@ sub Start {
         eval {$self-&gt;Process($process_timeout)};
         
         if($@) { #Assume the connection is down...
-            my $message = &quot;Disconnected from $connection_hash{$obj_ID}{'server'}:$connection_hash{$obj_ID}{'port'}&quot;
-                        . &quot; as $connection_hash{$obj_ID}{'username'}.&quot;;
+            my $message = &quot;Disconnected from $self-&gt;server:$self-&gt;port&quot;
+                        . &quot; as $self-&gt;username.&quot;;
             ERROR(&quot;$message Reconnecting...&quot;);
             $self-&gt;ReconnectToServer();
         }
@@ -529,8 +482,7 @@ Internal process
 sub ReconnectToServer {
     my $self = shift;
 
-    my $obj_ID = $self-&gt;_get_obj_id() or return; # Not an object.
-    my $background_subroutine = $bot_background_activity{$obj_ID};
+    my $background_subroutine = $self-&gt;background_function;
 
     $self-&gt;Disconnect();
 
@@ -554,15 +506,15 @@ Disconnects from server if client object is defined. Assures the client object i
 
 sub Disconnect {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return; # Not an object.
 
-    $client_start_time{$obj_ID} = 0;
+    $self-&gt;connect_time(0);
 
     INFO(&quot;Disconnecting from server&quot;);
-    return -1 if(!defined($jabber_client{$obj_ID})); # do not proceed, no object.
+    return -1 if(!defined($self-&gt;jabber_client)); # do not proceed, no object.
 
-    $jabber_client{$obj_ID}-&gt;Disconnect();
-    delete $jabber_client{$obj_ID};
+    $self-&gt;jabber_client-&gt;Disconnect();
+    my $old_client = $self-&gt;jabber_client;
+    $self-&gt;jabber_client(undef);
 
     DEBUG(&quot;Disconnected.&quot;);
     return 1;
@@ -576,10 +528,9 @@ Reports connect state (true/false) based on the status of client_start_time.
 
 sub IsConnected {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return; # Not an object.
 
-    DEBUG(&quot;REF = &quot; . ref($jabber_client{$obj_ID}));
-    return $client_start_time{$obj_ID};
+    DEBUG(&quot;REF = &quot; . ref($self-&gt;jabber_client));
+    return $self-&gt;connect_time;
 }
 
 =item B&lt;ProcessJabberMessage&gt; - DO NOT CALL
@@ -591,7 +542,6 @@ Handles incoming messages ***NEED VERY GOOD DOCUMENTATION HERE***** (TODO)
 sub ProcessJabberMessage {
     my $self = shift;
     DEBUG(&quot;ProcessJabberMessage called&quot;);
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
     my $session_id = shift;
     my $message = shift;
@@ -615,12 +565,12 @@ sub ProcessJabberMessage {
     #    my $message_date = UnixDate($message_date_text, &quot;%s&quot;) - 1*60*60; # Convert to EST from CST;
 
     # Ignore any messages within 20 seconds of start or join of that forum
-    my $grace_period = $forum_join_grace{$obj_ID};
+    my $grace_period = $self-&gt;forum_join_grace;
     my $time_now = time;
-    if($client_start_time{$obj_ID} &gt; $time_now - $grace_period
-       || (defined $forum_join_time{$obj_ID}{$from} &amp;&amp; $forum_join_time{$obj_ID}{$from} &gt; $time_now - $grace_period)) {
-    my $cond1 = &quot;$client_start_time{$obj_ID} &gt; $time_now - $grace_period&quot;;
-    my $cond2 = &quot;$forum_join_time{$obj_ID}{$from} &gt; $time_now - $grace_period&quot;;
+    if($self-&gt;connect_time &gt; $time_now - $grace_period
+       || (defined $self-&gt;forum_join_time-&gt;{$from} &amp;&amp; $self-&gt;forum_join_time-&gt;{$from} &gt; $time_now - $grace_period)) {
+    my $cond1 = &quot;$self-&gt;connect_time &gt; $time_now - $grace_period&quot;;
+    my $cond2 = &quot;$self-&gt;forum_join_time-&gt;{$from} &gt; $time_now - $grace_period&quot;;
     DEBUG(&quot;Ignoring messages cause I'm in startup for forum $from\n&quot;
           . &quot;$cond1\n&quot;
           . &quot;$cond2&quot;);
@@ -628,7 +578,7 @@ sub ProcessJabberMessage {
     }
 
     # Ignore Group messages with no resource on them. (Server Messages?)
-    if($ignore_messages{$obj_ID}{ignore_server_messages}) {
+    if($self-&gt;ignore_server_messages) {
         if($from_full !~ m/^([^\@]+)\@([^\/]+)\/(.+)$/) {
         DEBUG(&quot;Server message? ($from_full) - $message&quot;);
             return if($from_full !~ m/^([^\@]+)\@([^\/]+)\//);
@@ -638,7 +588,7 @@ sub ProcessJabberMessage {
     }
 
     # Are these my own messages?
-    if($ignore_messages{$obj_ID}{ignore_self_messages}) {
+    if($self-&gt;ignore_self_messages) {
     my $bot_alias = $self-&gt;get_alias();
     if(defined $resource &amp;&amp; $bot_alias eq $resource) { # Ignore my own messages.
         DEBUG(&quot;Ignoring message from self...\n&quot;);
@@ -664,15 +614,15 @@ sub ProcessJabberMessage {
     }
 
     # Call the message callback if it's defined.
-    if( exists $message_function{$obj_ID} ) {
-        $message_function{$obj_ID}-&gt;(bot_object =&gt; $self,
-                                     from_full =&gt; $from_full,
-                                     body =&gt; $body,
-                                     type =&gt; $type,
-                                     reply_to =&gt; $reply_to,
-                                     bot_address_from =&gt; $bot_address_from,
-                                     message =&gt; $message
-                                     );
+    if( defined $self-&gt;message_function) {
+        $self-&gt;message_function-&gt;(bot_object =&gt; $self,
+                                  from_full =&gt; $from_full,
+                                  body =&gt; $body,
+                                  type =&gt; $type,
+                                  reply_to =&gt; $reply_to,
+                                  bot_address_from =&gt; $bot_address_from,
+                                  message =&gt; $message
+                                  );
         return;
     } else {
         WARN(&quot;No handler for messages!&quot;);
@@ -688,9 +638,8 @@ Returns the alias name we are connected as or undef if we are not an object
 
 sub get_alias {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
-    return $connection_hash{$obj_ID}{'alias'};
+    return $self-&gt;alias;
 }
 
 =item B&lt;get_responses&gt;
@@ -703,7 +652,6 @@ Returns the array of messages we are monitoring for in supplied forum or replies
 
 sub get_responses {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
     my $forum = shift;
 
@@ -713,8 +661,8 @@ sub get_responses {
     }
 
     my @aliases_to_respond_to;
-    if(defined $forums_and_responses{$obj_ID}{$forum}) {
-        @aliases_to_respond_to = @{$forums_and_responses{$obj_ID}{$forum}};
+    if(defined $self-&gt;forums_and_responses-&gt;{$forum}) {
+        @aliases_to_respond_to = @{$self-&gt;forums_and_responses-&gt;{$forum}};
     }
 
     return @aliases_to_respond_to;
@@ -722,9 +670,8 @@ sub get_responses {
 
 
 # Supposed to send version requests to other user/resources. *** NOT WORKING YET ****
-sub RequestVersion : PRIVATE {
+sub RequestVersion {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
     my $iq = new Net::XMPP::IQ();
     $iq-&gt;SetIQ(to=&gt; 'todd.e.rinaldo@jabber.com/Shiva'
@@ -734,7 +681,7 @@ sub RequestVersion : PRIVATE {
           );
     my $iqType = $iq-&gt;NewChild( 'jabber:iq:version' );
     DEBUG(&quot;Sending IQ Message:&quot; . $iq-&gt;GetXML());
-    $jabber_client{$obj_ID}-&gt;Send($iq)
+    $self-&gt;jabber_client-&gt;Send($iq)
 }
 
 =item B&lt;InIQ&gt; - DO NOT CALL
@@ -745,7 +692,6 @@ Called when the client receives new messages during Process of this type.
 
 sub InIQ {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
     my $session_id = shift;
     my $iq = shift;
@@ -761,7 +707,7 @@ sub InIQ {
     if($xmlns eq &quot;jabber:iq:version&quot;) {
         $iqReply = $iq-&gt;Reply();
         my $response = $iqReply-&gt;GetQuery();
-        $response-&gt;SetName($connection_hash{$obj_ID}{'alias'});
+        $response-&gt;SetName($self-&gt;alias);
         $response-&gt;SetVer(&quot;2.0.7&quot;);
         $response-&gt;SetOS($^O);
     } else { # Unknown request. Just ignore it.
@@ -769,7 +715,7 @@ sub InIQ {
     }
 
     DEBUG(&quot;Reply: &quot;, $iqReply-&gt;GetXML());
-    $jabber_client{$obj_ID}-&gt;Send($iqReply);
+    $self-&gt;jabber_client-&gt;Send($iqReply);
 
 #    $from = &quot;&quot; if(!defined $from);
 #    $type = &quot;&quot; if(!defined $type);
@@ -788,7 +734,6 @@ Mostly we are just pushing the data down into the client DB for later processing
 
 sub JabberPresenceMessage {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
     my $session_id = shift;
     my $presence = shift;
@@ -796,20 +741,20 @@ sub JabberPresenceMessage {
     my $type = $presence-&gt;GetType();
     if($type eq 'subscribe') { # Always allow people to subscribe to us. Why wouldn't we?
         my $from = $presence-&gt;GetFrom();
-        $jabber_client{$obj_ID}-&gt;Subscription(type=&gt;&quot;subscribe&quot;,
+        $self-&gt;jabber_client-&gt;Subscription(type=&gt;&quot;subscribe&quot;,
                                               to=&gt;$from);
-        $jabber_client{$obj_ID}-&gt;Subscription(type=&gt;&quot;subscribed&quot;,to=&gt;$from);
+        $self-&gt;jabber_client-&gt;Subscription(type=&gt;&quot;subscribed&quot;,to=&gt;$from);
         INFO(&quot;Processed subscription request from $from&quot;);
         return;
     } elsif($type eq 'unsubscribe') { # Always allow people to subscribe to us. Why wouldn't we?
         my $from = $presence-&gt;GetFrom();
-        $jabber_client{$obj_ID}-&gt;Subscription(type=&gt;&quot;unsubscribed&quot;,
+        $self-&gt;jabber_client-&gt;Subscription(type=&gt;&quot;unsubscribed&quot;,
                                               to=&gt;$from);
         INFO(&quot;Processed unsubscribe request from $from&quot;);
         return;
     }
 
-    $jabber_client{$obj_ID}-&gt;PresenceDBParse($presence); # Since we are always an object just throw it into the db.
+    $self-&gt;jabber_client-&gt;PresenceDBParse($presence); # Since we are always an object just throw it into the db.
 
     my $from = $presence-&gt;GetFrom();
     $from = &quot;.&quot; if(!defined $from);
@@ -833,12 +778,11 @@ Tells the bot to start reacting to it\'s own messages if non-zero is passed. Def
 
 sub respond_to_self_messages {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return &quot;Not an object\n&quot;; #Failure
 
     my $setting = shift;
     $setting = 1 if(!defined $setting);
 
-    $ignore_messages{$obj_ID}{ignore_self_messages} = !$setting;
+    $self-&gt;ignore_self_messages(!$setting);
     return $setting;
 }
 
@@ -853,11 +797,10 @@ replys with number of messages sent so far this hour.
 
 sub get_messages_this_hour {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return; #Failure
 
     my $yday = (localtime)[7];
     my $hour = (localtime)[2];
-    my $messages_this_hour = $messages_sent_today{$obj_ID}{$yday}{$hour};
+    my $messages_this_hour = $self-&gt;messages_sent_today-&gt;{$yday}-&gt;{$hour};
     return $messages_this_hour;
 }
 
@@ -869,14 +812,13 @@ Validates that we are in safety mode. Returns a bool as long as we are an object
 
 sub get_safety_mode {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
     # Must be in safety mode and all thresholds met.
-    my $mode = !!($safety_mode{$obj_ID}
-          &amp;&amp; $message_delay{$obj_ID} &gt;= 1/5
-          &amp;&amp; $max_message_size{$obj_ID} &lt;= 1000
-          &amp;&amp; $max_message_size{$obj_ID} &lt;= 166
-          &amp;&amp; $ignore_messages{$obj_ID}{ignore_self_messages}
+    my $mode = !!($self-&gt;safety_mode
+          &amp;&amp; $self-&gt;message_delay &gt;= 1/5
+          &amp;&amp; $self-&gt;max_message_size &lt;= 1000
+          &amp;&amp; $self-&gt;max_message_size &lt;= 166
+          &amp;&amp; $self-&gt;ignore_self_messages
          );
     return $mode;
 }
@@ -894,8 +836,7 @@ sub SendGroupMessage {
     my $recipient = shift;
     my $message = shift;
 
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
-    $recipient .= '@' . $connection_hash{$obj_ID}{'conference_server'} if($recipient !~ m{\@});
+    $recipient .= '@' . $self-&gt;conference_server if($recipient !~ m{\@});
 
     return $self-&gt;SendJabberMessage($recipient, $message, 'groupchat');
 }
@@ -910,7 +851,7 @@ $recipient must read as user@server/Resource or it will not send.
 
 =cut
 
-    sub SendPersonalMessage {
+sub SendPersonalMessage {
     my $self = shift;
     my $recipient = shift;
     my $message = shift;
@@ -930,14 +871,13 @@ Assures message size does not exceed a limit and chops it into pieces if need be
 
 sub SendJabberMessage {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return;
 
     my $recipient = shift;
     my $message = shift;
     my $message_type = shift;
     my $subject = shift;
 
-    my $max_size = $max_message_size{$obj_ID};
+    my $max_size = $self-&gt;max_message_size;
 
     # Split the message into no more than max_message_size so that we do not piss off jabber.
     # Split on new line. Space if you have to or just chop at max size.
@@ -962,9 +902,8 @@ sub SendJabberMessage {
 # 2. Make sure we have not sent too many messages this hour and block sends if they are attempted over a certain limit (max limit is 125)
 # 3. Strip out special characters that will get us booted from the server.
 
-sub _SendIndividualMessage : PRIVATE {
+sub _SendIndividualMessage {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return &quot;Not an object\n&quot;; #Failure
 
     my $recipient = shift;
     my $message_chunk = shift;
@@ -983,13 +922,13 @@ sub _SendIndividualMessage : PRIVATE {
 
     my $yday = (localtime)[7];
     my $hour = (localtime)[2];
-    my $messages_this_hour = ++$messages_sent_today{$obj_ID}{$yday}{$hour};
+    my $messages_this_hour = ++$self-&gt;messages_sent_today-&gt;{$yday}-&gt;{$hour};
 
-    if($messages_this_hour &gt; $max_messages_per_hour{$obj_ID}) {
+    if($messages_this_hour &gt; $self-&gt;max_messages_per_hour) {
         $subject = &quot;&quot; if(!defined $subject); # Keep warning messages quiet.
         $message_chunk = &quot;&quot; if(!defined $message_chunk); # Keep warning messages quiet.
 
-        ERROR(&quot;Can't Send message because we've already tried to send $messages_this_hour of $max_messages_per_hour{$obj_ID} messages this hour.\n&quot;
+        ERROR(&quot;Can't Send message because we've already tried to send $messages_this_hour of $self-&gt;max_messages_per_hour messages this hour.\n&quot;
               . &quot;To: $recipient\n&quot;
               . &quot;Subject: $subject\n&quot;
               . &quot;Type: $message_type\n&quot;
@@ -1021,20 +960,20 @@ sub _SendIndividualMessage : PRIVATE {
 
     my $message_length = length($message_chunk);
     DEBUG(&quot;Sending message $yday-$hour-$messages_this_hour $message_length bytes to $recipient&quot;);
-    $jabber_client{$obj_ID}-&gt;MessageSend(to =&gt; $recipient
+    $self-&gt;jabber_client-&gt;MessageSend(to =&gt; $recipient
                      , body =&gt; $message_chunk
                      , type =&gt; $message_type
 #                                        , from =&gt; $connection_hash{$obj_ID}{'from_full'}
                      , subject =&gt; $subject
                      );
 
-    DEBUG(&quot;Sleeping $message_delay{$obj_ID} after sending message.&quot;);
-    Time::HiRes::sleep $message_delay{$obj_ID}; #Throttle messages.
+    DEBUG(&quot;Sleeping $self-&gt;message_delay after sending message.&quot;);
+    Time::HiRes::sleep $self-&gt;message_delay; #Throttle messages.
 
-    if($messages_this_hour == $max_messages_per_hour{$obj_ID}) {
-        $jabber_client{$obj_ID}-&gt;MessageSend(to =&gt; $recipient
+    if($messages_this_hour == $self-&gt;max_messages_per_hour) {
+        $self-&gt;jabber_client-&gt;MessageSend(to =&gt; $recipient
                          , body =&gt; &quot;Cannot send more messages this hour. &quot;
-                         . &quot;$messages_this_hour of $max_messages_per_hour{$obj_ID} already sent.&quot;
+                         . &quot;$messages_this_hour of $self-&gt;max_messages_per_hour already sent.&quot;
                          , type =&gt; $message_type
                          );
     }
@@ -1051,15 +990,14 @@ Sets the subject of a forum
 
 sub SetForumSubject {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return &quot;Not an object\n&quot;; #Failure
 
     my $recipient = shift;
     my $subject = shift;
 
-    if(length $subject &gt; $max_message_size{$obj_ID}) {
+    if(length $subject &gt; $self-&gt;max_message_size) {
     my $subject_len = length($subject);
     ERROR(&quot;Someone tried to send a subject message $subject_len bytes long!&quot;);
-    my $subject = substr($subject, 0, $max_message_size{$obj_ID});
+    my $subject = substr($subject, 0, self-&gt;max_message_size);
     DEBUG(&quot;Truncated subject: $subject&quot;);
     return &quot;Subject is too long!&quot;;
     }
@@ -1068,26 +1006,6 @@ sub SetForumSubject {
     return;
 }
 
-# $bot-&gt;_get_obj_id();
-# Retrieves the ident of the local object and does a default bail if the caller had not initialized the object. does not die by design.
-
-sub _get_obj_id : PRIVATE {
-    my $self = shift;
-    my $obj_ID = ident($self);
-
-    return $obj_ID if(defined $obj_ID);
-
-    my ($package, $filename, $line) = caller(1);
-    my ($package_caller, $filename_caller, $line_caller) = caller(2);
-
-    $line_caller = 'unknown' if(!defined $line_caller);
-    $filename_caller = 'unknown' if(!defined $filename_caller);
-    $package = 'unknown' if(!defined $package);
-
-    ERROR(&quot;$package called at line $line_caller in $filename_caller without a valid object!!&quot;);
-    return;
-}
-
 =item B&lt;ChangeStatus&gt;
 
     $bot-&gt;ChangeStatus($presence_mode, $status_string);
@@ -1100,11 +1018,10 @@ $status_string is an optional comment to go with your presence mode. It is not r
 
 sub ChangeStatus {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return &quot;Not an object\n&quot;; #Failure
     my $presence_mode = shift;
     my $status_string = shift; # (optional)
 
-    $jabber_client{$obj_ID}-&gt;PresenceSend(show=&gt;$presence_mode, status=&gt;$status_string);
+    $self-&gt;jabber_client-&gt;PresenceSend(show=&gt;$presence_mode, status=&gt;$status_string);
 
     return 1;
 }
@@ -1120,10 +1037,9 @@ In which case we need another sub for this.
 
 sub GetRoster {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return &quot;Not an object\n&quot;; #Failure
 
     my @rosterlist;
-    foreach my $jid ($jabber_client{$obj_ID}-&gt;RosterDBJIDs()) {
+    foreach my $jid ($self-&gt;jabber_client-&gt;RosterDBJIDs()) {
         my $username =$jid-&gt;GetJID();
         push(@rosterlist, $username) ;
     }
@@ -1139,10 +1055,9 @@ Need documentation from Yago on this sub.
 sub GetStatus {
 
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return &quot;Not an object\n&quot;; #Failure
     my ($jid) = shift;
 
-    my $Pres = $jabber_client{$obj_ID}-&gt;PresenceDBQuery($jid);
+    my $Pres = $self-&gt;jabber_client-&gt;PresenceDBQuery($jid);
 
     if (!(defined($Pres))) {
 
@@ -1167,11 +1082,10 @@ Need documentation from Yago on this sub.
 
 sub AddUser {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return &quot;Not an object\n&quot;; #Failure
     my $user = shift;
 
-    $jabber_client{$obj_ID}-&gt;Subscription(type=&gt;&quot;subscribe&quot;, to=&gt;$user);
-    $jabber_client{$obj_ID}-&gt;Subscription(type=&gt;&quot;subscribed&quot;,to=&gt;$user);
+    $self-&gt;jabber_client-&gt;Subscription(type=&gt;&quot;subscribe&quot;, to=&gt;$user);
+    $self-&gt;jabber_client-&gt;Subscription(type=&gt;&quot;subscribed&quot;,to=&gt;$user);
 }
 
 =item B&lt;RmUser&gt;
@@ -1182,11 +1096,10 @@ Need documentation from Yago on this sub.
 
 sub RmUser {
     my $self = shift;
-    my $obj_ID = $self-&gt;_get_obj_id() or return &quot;Not an object\n&quot;; #Failure
     my $user = shift;
 
-    $jabber_client{$obj_ID}-&gt;Subscription(type=&gt;&quot;unsubscribe&quot;, to=&gt;$user);
-    $jabber_client{$obj_ID}-&gt;Subscription(type=&gt;&quot;unsubscribed&quot;,to=&gt;$user);
+    $self-&gt;jabber_client-&gt;Subscription(type=&gt;&quot;unsubscribe&quot;, to=&gt;$user);
+    $self-&gt;jabber_client-&gt;Subscription(type=&gt;&quot;unsubscribed&quot;,to=&gt;$user);
 }
 =back
 </diff>
      <filename>lib/Net/Jabber/Bot.pm</filename>
    </modified>
  </modified>
  <removed type="array"/>
  <parents type="array">
    <parent>
      <id>2ebfaeea92bc31d8582a9950ae4a58876a989e54</id>
    </parent>
  </parents>
  <author>
    <name>todd.e.rinaldo@jpmorgan.com</name>
    <email>todd.e.rinaldo@jpmorgan.com@0a4183e2-4043-0410-8c03-cd5d52198443</email>
  </author>
  <url>http://github.com/toddr/perl-net-jabber-bot/commit/e522d06b6ee9fbd7f3bb5cb29bd54aee9185fb2d</url>
  <id>e522d06b6ee9fbd7f3bb5cb29bd54aee9185fb2d</id>
  <committed-date>2008-09-22T22:14:00-07:00</committed-date>
  <authored-date>2008-09-22T22:14:00-07:00</authored-date>
  <message>Initial conversion to Moose - about to test</message>
  <tree>2fc45c3f673b1ccddf47762bfc9c2e5988cb9f5d</tree>
  <committer>
    <name>todd.e.rinaldo@jpmorgan.com</name>
    <email>todd.e.rinaldo@jpmorgan.com@0a4183e2-4043-0410-8c03-cd5d52198443</email>
  </committer>
</commit>
