svn commit: r420702 [1/2] - /webservices/sandesha/trunk/c/src/storage/inmemory/

[da...@apache.org]

Author: damitha
Date: Mon Jul 10 21:08:10 2006
New Revision: 420702

URL: http://svn.apache.org/viewvc?rev=420702&view=rev
Log: (empty)

Added:
    webservices/sandesha/trunk/c/src/storage/inmemory/
    webservices/sandesha/trunk/c/src/storage/inmemory/Makefile.am
    webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_create_seq_mgr.c
    webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_invoker_mgr.c
    webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_next_msg_mgr.c
    webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_sender_mgr.c
    webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_seq_property_mgr.c
    webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_storage_manager.c
    webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_transaction.c

Added: webservices/sandesha/trunk/c/src/storage/inmemory/Makefile.am
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/storage/inmemory/Makefile.am?rev=420702&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/storage/inmemory/Makefile.am (added)
+++ webservices/sandesha/trunk/c/src/storage/inmemory/Makefile.am Mon Jul 10 21:08:10 2006
@@ -0,0 +1,13 @@
+noinst_LTLIBRARIES = libsandesha2_inmemory.la
+
+libsandesha2_inmemory_la_SOURCES = \
+								in_memory_create_seq_mgr.c \
+								in_memory_invoker_mgr.c \
+								in_memory_sender_mgr.c \
+								in_memory_next_msg_mgr.c \
+								in_memory_seq_property_mgr.c \
+								in_memory_transaction.c
+
+INCLUDES = -I$(top_builddir)/include \
+			-I$(top_builddir)/include/sandesha2 \
+			@UTILINC@

Added: webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_create_seq_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_create_seq_mgr.c?rev=420702&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_create_seq_mgr.c (added)
+++ webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_create_seq_mgr.c Mon Jul 10 21:08:10 2006
@@ -0,0 +1,379 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#include <sandesha2_in_memory_create_seq_mgr.h>
+#include <sandesha2_constants.h>
+#include <sandesha2_error.h>
+#include <axis2_log.h>
+#include <axis2_hash.h>
+#include <axis2_thread.h>
+#include <axis2_property.h>
+
+typedef struct sandesha2_in_memory_create_seq_mgr_impl sandesha2_in_memory_create_seq_mgr_impl_t;
+
+/** 
+ * @brief Sandesha Sequence Report Struct Impl
+ *   Sandesha Sequence Report 
+ */ 
+struct sandesha2_in_memory_create_seq_mgr_impl
+{
+    sandesha2_in_memory_create_seq_mgr_t seq_mgr;
+	
+    axis2_hash_t *table;
+    axis2_thread_mutex_t *mutex;
+
+};
+
+#define SANDESHA2_INTF_TO_IMPL(seq_mgr) ((sandesha2_in_memory_create_seq_mgr_impl_t *) seq_mgr)
+
+axis2_status_t AXIS2_CALL 
+sandesha2_in_memory_create_seq_mgr_free(
+        void *seq_mgr,
+        const axis2_env_t *envv);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_insert(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        sandesha2_create_seq_bean_t *bean);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_remove(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        axis2_char_t *msg_id);
+
+sandesha2_create_seq_bean_t *AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_retrieve(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        axis2_char_t *msg_id);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_update(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        sandesha2_create_seq_bean_t *bean);
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_find(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        sandesha2_create_seq_bean_t *bean);
+
+sandesha2_create_seq_bean_t *AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_find_unique(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        sandesha2_create_seq_bean_t *bean);
+
+AXIS2_EXTERN sandesha2_in_memory_create_seq_mgr_t * AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_create(
+        const axis2_env_t *env,
+        axis2_ctx_t *ctx)
+{
+    sandesha2_in_memory_create_seq_mgr_impl_t *seq_mgr_impl = NULL;
+    axis2_property_t *property = NULL;
+    
+    AXIS2_ENV_CHECK(env, NULL);
+    seq_mgr_impl = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_create_seq_mgr_impl_t));
+
+    seq_mgr_impl->table = NULL;
+    seq_mgr_impl->mutex = NULL;
+
+    seq_mgr_impl->seq_mgr.ops = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_create_seq_mgr_ops_t)); 
+    
+    seq_mgr_impl->mutex = axis2_thread_mutex_create(env->allocator, 
+            AXIS2_THREAD_MUTEX_DEFAULT);
+    if(!seq_mgr_impl->mutex) 
+    {
+        sandesha2_in_memory_create_seq_mgr_free(&(seq_mgr_impl->seq_mgr), env);
+        return NULL;
+    }
+
+    property = AXIS2_CTX_GET_PROPERTY(ctx, env, 
+            SANDESHA2_BEAN_MAP_CREATE_SEQUECE, AXIS2_FALSE);
+    seq_mgr_impl->table = (axis2_hash_t *) AXIS2_PROPERTY_GET_VALUE(property, env);
+    if(!seq_mgr_impl->table)
+    {
+        axis2_property_t *property = NULL;
+
+        property = axis2_property_create(env);
+        seq_mgr_impl->table = axis2_hash_make(env);
+        if(!property || !seq_mgr_impl->table)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            return NULL;
+        }
+        AXIS2_PROPERTY_SET_VALUE(property, env, seq_mgr_impl->table);
+        AXIS2_PROPERTY_SET_FREE_FUNC(property, env, seq_mgr_impl->seq_mgr.ops->free);
+        AXIS2_CTX_SET_PROPERTY(ctx, env, SANDESHA2_BEAN_MAP_CREATE_SEQUECE, 
+                property, AXIS2_FALSE);
+    }
+    seq_mgr_impl->seq_mgr.ops->free = sandesha2_in_memory_create_seq_mgr_free;
+    seq_mgr_impl->seq_mgr.ops->insert = 
+        sandesha2_in_memory_create_seq_mgr_insert;
+    seq_mgr_impl->seq_mgr.ops->remove = 
+        sandesha2_in_memory_create_seq_mgr_remove;
+    seq_mgr_impl->seq_mgr.ops->retrieve = 
+        sandesha2_in_memory_create_seq_mgr_retrieve;
+    seq_mgr_impl->seq_mgr.ops->update = 
+        sandesha2_in_memory_create_seq_mgr_update;
+    seq_mgr_impl->seq_mgr.ops->find = 
+        sandesha2_in_memory_create_seq_mgr_find;
+    seq_mgr_impl->seq_mgr.ops->find_unique = 
+        sandesha2_in_memory_create_seq_mgr_find_unique;
+
+    return &(seq_mgr_impl->seq_mgr);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_free(
+        void *seq_mgr,
+        const axis2_env_t *env)
+{
+    sandesha2_in_memory_create_seq_mgr_impl_t *seq_mgr_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
+
+    if(seq_mgr_impl->mutex)
+    {
+        axis2_thread_mutex_destry(seq_mgr_impl->mutex);
+        seq_mgr_impl->mutex = NULL;
+    }
+    if(seq_mgr_impl->table)
+    {
+        axis2_hash_free(seq_mgr_impl->table, env);
+        seq_mgr_impl->table = NULL;
+    }
+
+    if((&(seq_mgr_impl->seq_mgr))->ops)
+    {
+        AXIS2_FREE(env->allocator, (&(seq_mgr_impl->seq_mgr))->ops);
+        (&(seq_mgr_impl->seq_mgr))->ops = NULL;
+    }
+
+    if(seq_mgr_impl)
+    {
+        AXIS2_FREE(env->allocator, seq_mgr_impl);
+        seq_mgr_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_insert(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        sandesha2_create_seq_bean_t *bean)
+{
+    sandesha2_in_memory_create_seq_mgr_impl_t *seq_mgr_impl = NULL;
+    axis2_char_t *msg_id = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
+
+    axis2_thread_mutex_lock(seq_mgr_impl->mutex);
+    msg_id = SANDESHA2_CREATE_SEQ_BEAN_GET_CREATE_SEQ_MSG_ID(bean, env);
+    axis2_hash_set(seq_mgr_impl->table, msg_id, AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_remove(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        axis2_char_t *msg_id)
+{
+    sandesha2_in_memory_create_seq_mgr_impl_t *seq_mgr_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, msg_id, AXIS2_FALSE);
+    seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
+
+    axis2_thread_mutex_lock(seq_mgr_impl->mutex);
+    axis2_hash_set(seq_mgr_impl->table, msg_id, AXIS2_HASH_KEY_STRING, NULL);
+    axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+sandesha2_create_seq_bean_t *AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_retrieve(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        axis2_char_t *msg_id)
+{
+    sandesha2_in_memory_create_seq_mgr_impl_t *seq_mgr_impl = NULL;
+    sandesha2_create_seq_bean_t *bean = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, msg_id, AXIS2_FALSE);
+    seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
+
+    axis2_thread_mutex_lock(seq_mgr_impl->mutex);
+    bean = (sandesha2_create_seq_bean_t *) axis2_hash_get(seq_mgr_impl->table, 
+            msg_id, AXIS2_HASH_KEY_STRING);
+    axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+
+    return bean;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_update(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        sandesha2_create_seq_bean_t *bean)
+{
+    sandesha2_in_memory_create_seq_mgr_impl_t *seq_mgr_impl = NULL;
+    axis2_char_t *msg_id = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
+
+    axis2_thread_mutex_lock(seq_mgr_impl->mutex);
+    msg_id = SANDESHA2_CREATE_SEQ_BEAN_GET_CREATE_SEQ_MSG_ID(bean, env);
+    if(!msg_id)
+    {
+        axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    axis2_hash_set(seq_mgr_impl->table, msg_id, AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+
+    return AXIS2_TRUE;
+}
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_find(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        sandesha2_create_seq_bean_t *bean)
+{
+    sandesha2_in_memory_create_seq_mgr_impl_t *seq_mgr_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    axis2_hash_index_t *i = NULL;
+    sandesha2_create_seq_bean_t *temp = NULL;
+    void *v = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
+
+    axis2_thread_mutex_lock(seq_mgr_impl->mutex);
+    beans = axis2_array_list_create(env, 0);
+    if(!beans)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+        return NULL;
+    }
+    if(!bean)
+    {
+        axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+        return beans;
+    }
+    for (i = axis2_hash_first (seq_mgr_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        axis2_bool_t equal = AXIS2_TRUE;
+        axis2_char_t *msg_id = NULL;
+        axis2_char_t *temp_msg_id = NULL;
+        axis2_char_t *seq_id = NULL;
+        axis2_char_t *temp_seq_id = NULL;
+        axis2_char_t *internal_seq_id = NULL;
+        axis2_char_t *temp_internal_seq_id = NULL;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        temp = (sandesha2_create_seq_bean_t *) v;
+        msg_id = SANDESHA2_CREATE_SEQ_BEAN_GET_CREATE_SEQ_MSG_ID(bean, env);
+        temp_msg_id = SANDESHA2_CREATE_SEQ_BEAN_GET_CREATE_SEQ_MSG_ID(temp, env);
+        if(msg_id && temp_msg_id && 0 != AXIS2_STRCMP(msg_id, temp_msg_id))
+        {
+            equal = AXIS2_FALSE;
+        }
+        seq_id = SANDESHA2_CREATE_SEQ_BEAN_GET_SEQ_ID(bean, env);
+        temp_seq_id = SANDESHA2_CREATE_SEQ_BEAN_GET_SEQ_ID(temp, env);
+        if(seq_id && temp_seq_id && 0 != AXIS2_STRCMP(seq_id, temp_seq_id))
+        {
+            equal = AXIS2_FALSE;
+        }
+        internal_seq_id = SANDESHA2_CREATE_SEQ_BEAN_GET_INTERNAL_SEQ_ID(bean, 
+                env);
+        temp_internal_seq_id = SANDESHA2_CREATE_SEQ_BEAN_GET_INTERNAL_SEQ_ID(
+                temp, env);
+        if(internal_seq_id && temp_internal_seq_id && 0 != AXIS2_STRCMP(
+                    internal_seq_id, temp_internal_seq_id))
+        {
+            equal = AXIS2_FALSE;
+        }
+        if(AXIS2_TRUE == equal)
+        {
+            AXIS2_ARRAY_LIST_ADD(beans, env, temp);
+        }
+        
+    }
+    axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+
+    return beans;
+}
+
+sandesha2_create_seq_bean_t *AXIS2_CALL
+sandesha2_in_memory_create_seq_mgr_find_unique(
+        sandesha2_in_memory_create_seq_mgr_t *seq_mgr,
+        const axis2_env_t *env,
+        sandesha2_create_seq_bean_t *bean)
+{
+    sandesha2_in_memory_create_seq_mgr_impl_t *seq_mgr_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    int i = 0, size = 0;
+    sandesha2_create_seq_bean_t *ret = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    seq_mgr_impl = SANDESHA2_INTF_TO_IMPL(seq_mgr);
+
+    axis2_thread_mutex_lock(seq_mgr_impl->mutex);
+    
+    beans = sandesha2_in_memory_create_seq_mgr_find(seq_mgr, env, bean);
+    if(beans)
+        size = AXIS2_ARRAY_LIST_SIZE(beans, env);
+    if( size > 1)
+    {
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Non-Unique result");
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NON_UNIQUE_RESULT, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+        return NULL;
+    }
+    for(i = 0; i < size; i++)
+    {
+       ret = AXIS2_ARRAY_LIST_GET(beans, env, i);
+       break;
+    }
+    
+    axis2_thread_mutex_unlock(seq_mgr_impl->mutex);
+
+    return ret;
+}
+

Added: webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_invoker_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_invoker_mgr.c?rev=420702&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_invoker_mgr.c (added)
+++ webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_invoker_mgr.c Mon Jul 10 21:08:10 2006
@@ -0,0 +1,384 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#include <sandesha2_in_memory_invoker_mgr.h>
+#include <sandesha2_constants.h>
+#include <sandesha2_error.h>
+#include <axis2_log.h>
+#include <axis2_hash.h>
+#include <axis2_thread.h>
+#include <axis2_property.h>
+
+typedef struct sandesha2_in_memory_invoker_mgr_impl sandesha2_in_memory_invoker_mgr_impl_t;
+
+/** 
+ * @brief Sandesha Sequence Report Struct Impl
+ *   Sandesha Sequence Report 
+ */ 
+struct sandesha2_in_memory_invoker_mgr_impl
+{
+    sandesha2_in_memory_invoker_mgr_t invoker;
+	
+    axis2_hash_t *table;
+    axis2_thread_mutex_t *mutex;
+
+};
+
+#define SANDESHA2_INTF_TO_IMPL(invoker) ((sandesha2_in_memory_invoker_mgr_impl_t *) invoker)
+
+axis2_status_t AXIS2_CALL 
+sandesha2_in_memory_invoker_mgr_free(
+        void *invoker,
+        const axis2_env_t *envv);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_insert(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        sandesha2_invoker_bean_t *bean);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_remove(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        axis2_char_t *ref_key);
+
+sandesha2_invoker_bean_t *AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_retrieve(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        axis2_char_t *ref_key);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_update(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        sandesha2_invoker_bean_t *bean);
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_find(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        sandesha2_invoker_bean_t *bean);
+
+sandesha2_invoker_bean_t *AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_find_unique(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        sandesha2_invoker_bean_t *bean);
+
+AXIS2_EXTERN sandesha2_in_memory_invoker_mgr_t * AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_create(
+        const axis2_env_t *env,
+        axis2_ctx_t *ctx)
+{
+    sandesha2_in_memory_invoker_mgr_impl_t *invoker_impl = NULL;
+    axis2_property_t *property = NULL;
+    
+    AXIS2_ENV_CHECK(env, NULL);
+    invoker_impl = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_invoker_mgr_impl_t));
+
+    invoker_impl->table = NULL;
+    invoker_impl->mutex = NULL;
+
+    invoker_impl->invoker.ops = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_invoker_mgr_ops_t)); 
+    
+    invoker_impl->mutex = axis2_thread_mutex_create(env->allocator, 
+            AXIS2_THREAD_MUTEX_DEFAULT);
+    if(!invoker_impl->mutex) 
+    {
+        sandesha2_in_memory_invoker_mgr_free(&(invoker_impl->invoker), env);
+        return NULL;
+    }
+
+    property = AXIS2_CTX_GET_PROPERTY(ctx, env, 
+            SANDESHA2_BEAN_MAP_STORAGE_MAP, AXIS2_FALSE);
+    invoker_impl->table = (axis2_hash_t *) AXIS2_PROPERTY_GET_VALUE(property, env);
+    if(!invoker_impl->table)
+    {
+        axis2_property_t *property = NULL;
+
+        property = axis2_property_create(env);
+        invoker_impl->table = axis2_hash_make(env);
+        if(!property || !invoker_impl->table)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            return NULL;
+        }
+        AXIS2_PROPERTY_SET_VALUE(property, env, invoker_impl->table);
+        AXIS2_PROPERTY_SET_FREE_FUNC(property, env, invoker_impl->invoker.ops->free);
+        AXIS2_CTX_SET_PROPERTY(ctx, env, SANDESHA2_BEAN_MAP_STORAGE_MAP, 
+                property, AXIS2_FALSE);
+    }
+    invoker_impl->invoker.ops->free = sandesha2_in_memory_invoker_mgr_free;
+    invoker_impl->invoker.ops->insert = 
+        sandesha2_in_memory_invoker_mgr_insert;
+    invoker_impl->invoker.ops->remove = 
+        sandesha2_in_memory_invoker_mgr_remove;
+    invoker_impl->invoker.ops->retrieve = 
+        sandesha2_in_memory_invoker_mgr_retrieve;
+    invoker_impl->invoker.ops->update = 
+        sandesha2_in_memory_invoker_mgr_update;
+    invoker_impl->invoker.ops->find = 
+        sandesha2_in_memory_invoker_mgr_find;
+    invoker_impl->invoker.ops->find_unique = 
+        sandesha2_in_memory_invoker_mgr_find_unique;
+
+    return &(invoker_impl->invoker);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_free(
+        void *invoker,
+        const axis2_env_t *env)
+{
+    sandesha2_in_memory_invoker_mgr_impl_t *invoker_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+
+    if(invoker_impl->mutex)
+    {
+        axis2_thread_mutex_destry(invoker_impl->mutex);
+        invoker_impl->mutex = NULL;
+    }
+    if(invoker_impl->table)
+    {
+        axis2_hash_free(invoker_impl->table, env);
+        invoker_impl->table = NULL;
+    }
+
+    if((&(invoker_impl->invoker))->ops)
+    {
+        AXIS2_FREE(env->allocator, (&(invoker_impl->invoker))->ops);
+        (&(invoker_impl->invoker))->ops = NULL;
+    }
+
+    if(invoker_impl)
+    {
+        AXIS2_FREE(env->allocator, invoker_impl);
+        invoker_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_insert(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        sandesha2_invoker_bean_t *bean)
+{
+    sandesha2_in_memory_invoker_mgr_impl_t *invoker_impl = NULL;
+    axis2_char_t *ref_key = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+
+    axis2_thread_mutex_lock(invoker_impl->mutex);
+    ref_key = SANDESHA2_INVOKER_BEAN_GET_MSG_CONTEXT_REF_KEY(bean, env);
+    axis2_hash_set(invoker_impl->table, ref_key, AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(invoker_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_remove(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        axis2_char_t *key)
+{
+    sandesha2_in_memory_invoker_mgr_impl_t *invoker_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, key, AXIS2_FALSE);
+    invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+
+    axis2_thread_mutex_lock(invoker_impl->mutex);
+    axis2_hash_set(invoker_impl->table, key, AXIS2_HASH_KEY_STRING, NULL);
+    axis2_thread_mutex_unlock(invoker_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+sandesha2_invoker_bean_t *AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_retrieve(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        axis2_char_t *key)
+{
+    sandesha2_in_memory_invoker_mgr_impl_t *invoker_impl = NULL;
+    sandesha2_invoker_bean_t *bean = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, key, AXIS2_FALSE);
+    invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+
+    axis2_thread_mutex_lock(invoker_impl->mutex);
+    bean = (sandesha2_invoker_bean_t *) axis2_hash_get(invoker_impl->table, 
+            key, AXIS2_HASH_KEY_STRING);
+    axis2_thread_mutex_unlock(invoker_impl->mutex);
+
+    return bean;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_update(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        sandesha2_invoker_bean_t *bean)
+{
+    sandesha2_in_memory_invoker_mgr_impl_t *invoker_impl = NULL;
+    axis2_char_t *ref_key = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+
+    axis2_thread_mutex_lock(invoker_impl->mutex);
+    ref_key = SANDESHA2_INVOKER_BEAN_GET_MSG_CONTEXT_REF_KEY(bean, env);
+    if(!ref_key)
+    {
+        axis2_thread_mutex_unlock(invoker_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    axis2_hash_set(invoker_impl->table, ref_key, AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(invoker_impl->mutex);
+
+    return AXIS2_TRUE;
+}
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_find(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        sandesha2_invoker_bean_t *bean)
+{
+    sandesha2_in_memory_invoker_mgr_impl_t *invoker_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    axis2_hash_index_t *i = NULL;
+    sandesha2_invoker_bean_t *temp = NULL;
+    void *v = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+
+    axis2_thread_mutex_lock(invoker_impl->mutex);
+    beans = axis2_array_list_create(env, 0);
+    if(!beans)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(invoker_impl->mutex);
+        return NULL;
+    }
+    if(!bean)
+    {
+        axis2_thread_mutex_unlock(invoker_impl->mutex);
+        return beans;
+    }
+    for (i = axis2_hash_first (invoker_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        axis2_bool_t select = AXIS2_TRUE;
+        axis2_char_t *ref_key = NULL;
+        axis2_char_t *temp_ref_key = NULL;
+        axis2_char_t *seq_id = NULL;
+        axis2_char_t *temp_seq_id = NULL;
+        long msg_no = 0;
+        long temp_msg_no = 0;
+        axis2_bool_t is_invoked = AXIS2_FALSE;
+        axis2_bool_t temp_is_invoked = AXIS2_FALSE;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        temp = (sandesha2_invoker_bean_t *) v;
+        ref_key = SANDESHA2_INVOKER_BEAN_GET_MSG_CONTEXT_REF_KEY(bean, env);
+        temp_ref_key = SANDESHA2_INVOKER_BEAN_GET_MSG_CONTEXT_REF_KEY(temp, env);
+        if(ref_key && temp_ref_key && 0 != AXIS2_STRCMP(ref_key, temp_ref_key))
+        {
+            select = AXIS2_FALSE;
+        }
+        seq_id = SANDESHA2_INVOKER_BEAN_GET_SEQ_ID(bean, env);
+        temp_seq_id = SANDESHA2_INVOKER_BEAN_GET_SEQ_ID(temp, env);
+        if(seq_id && temp_seq_id && 0 != AXIS2_STRCMP(seq_id, temp_seq_id))
+        {
+            select = AXIS2_FALSE;
+        }
+        msg_no = SANDESHA2_INVOKER_BEAN_GET_MSG_NO(bean, env);
+        temp_msg_no = SANDESHA2_INVOKER_BEAN_GET_MSG_NO(temp, env);
+        if(msg_no != 0 && (msg_no != temp_msg_no))
+        {
+            select = AXIS2_FALSE;
+        }
+        is_invoked = SANDESHA2_INVOKER_BEAN_IS_INVOKED(bean, env);
+        temp_is_invoked = SANDESHA2_INVOKER_BEAN_IS_INVOKED(temp, env);
+        if(is_invoked != temp_is_invoked)
+        {
+            select = AXIS2_FALSE;
+        }
+        if(AXIS2_TRUE == select)
+        {
+            AXIS2_ARRAY_LIST_ADD(beans, env, temp);
+        }
+        
+    }
+    axis2_thread_mutex_unlock(invoker_impl->mutex);
+
+    return beans;
+}
+
+sandesha2_invoker_bean_t *AXIS2_CALL
+sandesha2_in_memory_invoker_mgr_find_unique(
+        sandesha2_in_memory_invoker_mgr_t *invoker,
+        const axis2_env_t *env,
+        sandesha2_invoker_bean_t *bean)
+{
+    sandesha2_in_memory_invoker_mgr_impl_t *invoker_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    int i = 0, size = 0;
+    sandesha2_invoker_bean_t *ret = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    invoker_impl = SANDESHA2_INTF_TO_IMPL(invoker);
+
+    axis2_thread_mutex_lock(invoker_impl->mutex);
+    
+    beans = sandesha2_in_memory_invoker_mgr_find(invoker, env, bean);
+    if(beans)
+        size = AXIS2_ARRAY_LIST_SIZE(beans, env);
+    if( size > 1)
+    {
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Non-Unique result");
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NON_UNIQUE_RESULT, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(invoker_impl->mutex);
+        return NULL;
+    }
+    for(i = 0; i < size; i++)
+    {
+       ret = AXIS2_ARRAY_LIST_GET(beans, env, i);
+       break;
+    }
+    
+    axis2_thread_mutex_unlock(invoker_impl->mutex);
+
+    return ret;
+}
+

Added: webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_next_msg_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_next_msg_mgr.c?rev=420702&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_next_msg_mgr.c (added)
+++ webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_next_msg_mgr.c Mon Jul 10 21:08:10 2006
@@ -0,0 +1,417 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#include <sandesha2_in_memory_next_msg_mgr.h>
+#include <sandesha2_constants.h>
+#include <sandesha2_error.h>
+#include <sandesha2_utils.h>
+#include <axis2_log.h>
+#include <axis2_hash.h>
+#include <axis2_thread.h>
+#include <axis2_property.h>
+
+typedef struct sandesha2_in_memory_next_msg_mgr_impl sandesha2_in_memory_next_msg_mgr_impl_t;
+
+/** 
+ * @brief Sandesha Sequence Report Struct Impl
+ *   Sandesha Sequence Report 
+ */ 
+struct sandesha2_in_memory_next_msg_mgr_impl
+{
+    sandesha2_in_memory_next_msg_mgr_t next_msg;
+	
+    axis2_hash_t *table;
+    axis2_array_list_t *values;
+    axis2_thread_mutex_t *mutex;
+
+};
+
+#define SANDESHA2_INTF_TO_IMPL(next_msg) ((sandesha2_in_memory_next_msg_mgr_impl_t *) next_msg)
+
+axis2_status_t AXIS2_CALL 
+sandesha2_in_memory_next_msg_mgr_free(
+        void *next_msg,
+        const axis2_env_t *envv);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_insert(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        sandesha2_next_msg_bean_t *bean);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_remove(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        axis2_char_t *seq_id);
+
+sandesha2_next_msg_bean_t *AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_retrieve(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        axis2_char_t *seq_id);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_update(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        sandesha2_next_msg_bean_t *bean);
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_find(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        sandesha2_next_msg_bean_t *bean);
+
+sandesha2_next_msg_bean_t *AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_find_unique(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        sandesha2_next_msg_bean_t *bean);
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_retrieve_all(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env);
+
+AXIS2_EXTERN sandesha2_in_memory_next_msg_mgr_t * AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_create(
+        const axis2_env_t *env,
+        axis2_ctx_t *ctx)
+{
+    sandesha2_in_memory_next_msg_mgr_impl_t *next_msg_impl = NULL;
+    axis2_property_t *property = NULL;
+    
+    AXIS2_ENV_CHECK(env, NULL);
+    next_msg_impl = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_next_msg_mgr_impl_t));
+
+    next_msg_impl->table = NULL;
+    next_msg_impl->values = NULL;
+    next_msg_impl->mutex = NULL;
+
+    next_msg_impl->next_msg.ops = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_next_msg_mgr_ops_t)); 
+    
+    next_msg_impl->mutex = axis2_thread_mutex_create(env->allocator, 
+            AXIS2_THREAD_MUTEX_DEFAULT);
+    if(!next_msg_impl->mutex) 
+    {
+        sandesha2_in_memory_next_msg_mgr_free(&(next_msg_impl->next_msg), env);
+        return NULL;
+    }
+
+    property = AXIS2_CTX_GET_PROPERTY(ctx, env, 
+            SANDESHA2_BEAN_MAP_NEXT_MESSAGE, AXIS2_FALSE);
+    next_msg_impl->table = (axis2_hash_t *) AXIS2_PROPERTY_GET_VALUE(property, env);
+    if(!next_msg_impl->table)
+    {
+        axis2_property_t *property = NULL;
+
+        property = axis2_property_create(env);
+        next_msg_impl->table = axis2_hash_make(env);
+        if(!property || !next_msg_impl->table)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            return NULL;
+        }
+        AXIS2_PROPERTY_SET_VALUE(property, env, next_msg_impl->table);
+        AXIS2_PROPERTY_SET_FREE_FUNC(property, env, next_msg_impl->next_msg.ops->free);
+        AXIS2_CTX_SET_PROPERTY(ctx, env, SANDESHA2_BEAN_MAP_NEXT_MESSAGE, 
+                property, AXIS2_FALSE);
+    }
+    next_msg_impl->next_msg.ops->free = sandesha2_in_memory_next_msg_mgr_free;
+    next_msg_impl->next_msg.ops->insert = 
+        sandesha2_in_memory_next_msg_mgr_insert;
+    next_msg_impl->next_msg.ops->remove = 
+        sandesha2_in_memory_next_msg_mgr_remove;
+    next_msg_impl->next_msg.ops->retrieve = 
+        sandesha2_in_memory_next_msg_mgr_retrieve;
+    next_msg_impl->next_msg.ops->update = 
+        sandesha2_in_memory_next_msg_mgr_update;
+    next_msg_impl->next_msg.ops->find = 
+        sandesha2_in_memory_next_msg_mgr_find;
+    next_msg_impl->next_msg.ops->find_unique = 
+        sandesha2_in_memory_next_msg_mgr_find_unique;
+    next_msg_impl->next_msg.ops->retrieve_all = 
+        sandesha2_in_memory_next_msg_mgr_retrieve_all;
+
+    return &(next_msg_impl->next_msg);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_free(
+        void *next_msg,
+        const axis2_env_t *env)
+{
+    sandesha2_in_memory_next_msg_mgr_impl_t *next_msg_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    next_msg_impl = SANDESHA2_INTF_TO_IMPL(next_msg);
+
+    if(next_msg_impl->mutex)
+    {
+        axis2_thread_mutex_destry(next_msg_impl->mutex);
+        next_msg_impl->mutex = NULL;
+    }
+    if(next_msg_impl->table)
+    {
+        axis2_hash_free(next_msg_impl->table, env);
+        next_msg_impl->table = NULL;
+    }
+    if(next_msg_impl->values)
+    {
+        AXIS2_ARRAY_LIST_FREE(next_msg_impl->values, env);
+        next_msg_impl->values = NULL;
+    }
+
+
+    if((&(next_msg_impl->next_msg))->ops)
+    {
+        AXIS2_FREE(env->allocator, (&(next_msg_impl->next_msg))->ops);
+        (&(next_msg_impl->next_msg))->ops = NULL;
+    }
+
+    if(next_msg_impl)
+    {
+        AXIS2_FREE(env->allocator, next_msg_impl);
+        next_msg_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_insert(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        sandesha2_next_msg_bean_t *bean)
+{
+    sandesha2_in_memory_next_msg_mgr_impl_t *next_msg_impl = NULL;
+    axis2_char_t *seq_id = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    next_msg_impl = SANDESHA2_INTF_TO_IMPL(next_msg);
+
+    axis2_thread_mutex_lock(next_msg_impl->mutex);
+
+    seq_id = SANDESHA2_NEXT_MSG_BEAN_GET_SEQUENCE_ID(bean, env);
+    if(!seq_id)
+    {
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_KEY_IS_NULL, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(next_msg_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    axis2_hash_set(next_msg_impl->table, seq_id, AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(next_msg_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_remove(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        axis2_char_t *seq_id)
+{
+    sandesha2_in_memory_next_msg_mgr_impl_t *next_msg_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FALSE);
+    next_msg_impl = SANDESHA2_INTF_TO_IMPL(next_msg);
+
+    axis2_thread_mutex_lock(next_msg_impl->mutex);
+    axis2_hash_set(next_msg_impl->table, seq_id, AXIS2_HASH_KEY_STRING, NULL);
+    axis2_thread_mutex_unlock(next_msg_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+sandesha2_next_msg_bean_t *AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_retrieve(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        axis2_char_t *seq_id)
+{
+    sandesha2_in_memory_next_msg_mgr_impl_t *next_msg_impl = NULL;
+    sandesha2_next_msg_bean_t *bean = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FALSE);
+    next_msg_impl = SANDESHA2_INTF_TO_IMPL(next_msg);
+
+    axis2_thread_mutex_lock(next_msg_impl->mutex);
+    bean = (sandesha2_next_msg_bean_t *) axis2_hash_get(next_msg_impl->table, 
+            seq_id, AXIS2_HASH_KEY_STRING);
+    axis2_thread_mutex_unlock(next_msg_impl->mutex);
+
+    return bean;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_update(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        sandesha2_next_msg_bean_t *bean)
+{
+    sandesha2_in_memory_next_msg_mgr_impl_t *next_msg_impl = NULL;
+    axis2_char_t *seq_id = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    next_msg_impl = SANDESHA2_INTF_TO_IMPL(next_msg);
+
+    axis2_thread_mutex_lock(next_msg_impl->mutex);
+    seq_id = SANDESHA2_NEXT_MSG_BEAN_GET_SEQUENCE_ID(bean, env);
+    if(!seq_id)
+    {
+        axis2_thread_mutex_unlock(next_msg_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    axis2_hash_set(next_msg_impl->table, seq_id, AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(next_msg_impl->mutex);
+    return AXIS2_TRUE;
+}
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_find(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        sandesha2_next_msg_bean_t *bean)
+{
+    sandesha2_in_memory_next_msg_mgr_impl_t *next_msg_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    axis2_hash_index_t *i = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    next_msg_impl = SANDESHA2_INTF_TO_IMPL(next_msg);
+
+    axis2_thread_mutex_lock(next_msg_impl->mutex);
+    beans = axis2_array_list_create(env, 0);
+    if(!beans)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(next_msg_impl->mutex);
+        return NULL;
+    }
+    if(!bean)
+        return beans;
+    for (i = axis2_hash_first (next_msg_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        sandesha2_next_msg_bean_t *temp = NULL;
+        void *v = NULL;
+        axis2_bool_t equal = AXIS2_TRUE;
+        long next_msg_no = 0;
+        long temp_next_msg_no = 0;
+        axis2_char_t *seq_id = NULL;
+        axis2_char_t *temp_seq_id = NULL;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        temp = (sandesha2_next_msg_bean_t *) v;
+        next_msg_no = SANDESHA2_NEXT_MSG_BEAN_GET_NEXT_MSG_NO_TO_PROCESS(bean, env);
+        temp_next_msg_no = SANDESHA2_NEXT_MSG_BEAN_GET_NEXT_MSG_NO_TO_PROCESS(temp, env);
+        if(next_msg_no > 0 && (next_msg_no != temp_next_msg_no))
+        {
+            equal = AXIS2_FALSE;
+        }
+        seq_id = SANDESHA2_NEXT_MSG_BEAN_GET_SEQUENCE_ID(bean, env);
+        temp_seq_id = SANDESHA2_NEXT_MSG_BEAN_GET_SEQUENCE_ID(temp, env);
+        if(seq_id && temp_seq_id && 0 != AXIS2_STRCMP(seq_id, temp_seq_id))
+        {
+            equal = AXIS2_FALSE;
+        }
+        if(AXIS2_TRUE == equal)
+        {
+            AXIS2_ARRAY_LIST_ADD(beans, env, temp);
+        }
+        
+    }
+    axis2_thread_mutex_unlock(next_msg_impl->mutex);
+
+    return beans;
+}
+
+sandesha2_next_msg_bean_t *AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_find_unique(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env,
+        sandesha2_next_msg_bean_t *bean)
+{
+    sandesha2_in_memory_next_msg_mgr_impl_t *next_msg_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    int i = 0, size = 0;
+    sandesha2_next_msg_bean_t *ret = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    next_msg_impl = SANDESHA2_INTF_TO_IMPL(next_msg);
+
+    axis2_thread_mutex_lock(next_msg_impl->mutex);
+    
+    beans = sandesha2_in_memory_next_msg_mgr_find(next_msg, env, 
+            bean);
+    if(beans)
+        size = AXIS2_ARRAY_LIST_SIZE(beans, env);
+    if( size > 1)
+    {
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Non-Unique result");
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NON_UNIQUE_RESULT, 
+                AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(next_msg_impl->mutex);
+        return NULL;
+    }
+    for(i = 0; i < size; i++)
+    {
+       ret = AXIS2_ARRAY_LIST_GET(beans, env, i);
+       break;
+    }
+    
+    axis2_thread_mutex_unlock(next_msg_impl->mutex);
+
+    return ret;
+}
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_next_msg_mgr_retrieve_all(
+        sandesha2_in_memory_next_msg_mgr_t *next_msg,
+        const axis2_env_t *env)
+{
+    sandesha2_in_memory_next_msg_mgr_impl_t *next_msg_impl = NULL;
+    axis2_hash_index_t *i = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    next_msg_impl = SANDESHA2_INTF_TO_IMPL(next_msg);
+
+    axis2_thread_mutex_lock(next_msg_impl->mutex);
+    for (i = axis2_hash_first (next_msg_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        sandesha2_next_msg_bean_t *bean = NULL;
+        void *v = NULL;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        bean = (sandesha2_next_msg_bean_t *) v;
+        AXIS2_ARRAY_LIST_ADD(next_msg_impl->values, env, bean);
+    }
+
+    axis2_thread_mutex_unlock(next_msg_impl->mutex);
+
+    return next_msg_impl->values;
+}
+

Added: webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_sender_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_sender_mgr.c?rev=420702&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_sender_mgr.c (added)
+++ webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_sender_mgr.c Mon Jul 10 21:08:10 2006
@@ -0,0 +1,698 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#include <sandesha2_in_memory_sender_mgr.h>
+#include <sandesha2_constants.h>
+#include <sandesha2_error.h>
+#include <sandesha2_utils.h>
+#include <axis2_log.h>
+#include <axis2_hash.h>
+#include <axis2_thread.h>
+#include <axis2_property.h>
+
+typedef struct sandesha2_in_memory_sender_mgr_impl sandesha2_in_memory_sender_mgr_impl_t;
+
+/** 
+ * @brief Sandesha Sequence Report Struct Impl
+ *   Sandesha Sequence Report 
+ */ 
+struct sandesha2_in_memory_sender_mgr_impl
+{
+    sandesha2_in_memory_sender_mgr_t sender;
+	
+    axis2_hash_t *table;
+    axis2_thread_mutex_t *mutex;
+
+};
+
+#define SANDESHA2_INTF_TO_IMPL(sender) ((sandesha2_in_memory_sender_mgr_impl_t *) sender)
+
+axis2_status_t AXIS2_CALL 
+sandesha2_in_memory_sender_mgr_free(
+        void *sender,
+        const axis2_env_t *envv);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_sender_mgr_insert(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_sender_mgr_remove(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_char_t *msg_id);
+
+sandesha2_sender_bean_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_retrieve(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_char_t *msg_id);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_sender_mgr_update(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean);
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_find_by_internal_seq_id(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_char_t *internal_seq_id);
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_find_by_sender_bean(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean);
+
+sandesha2_sender_bean_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_find_unique(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean);
+
+sandesha2_sender_bean_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_get_next_msg_to_send(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env);
+
+sandesha2_sender_bean_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_retrieve_from_msg_ref_key(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_char_t *msg_ctx_ref_key);
+
+static axis2_status_t
+sandesha2_in_memory_sender_mgr_update_next_sending_time(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean);
+
+/*
+static axis2_array_list_t *
+sandesha2_in_memory_sender_mgr_find_beans_with_msg_no(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_array_list_t *list,
+        long msg_no);
+*/
+
+AXIS2_EXTERN sandesha2_in_memory_sender_mgr_t * AXIS2_CALL
+sandesha2_in_memory_sender_mgr_create(
+        const axis2_env_t *env,
+        axis2_ctx_t *ctx)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    axis2_property_t *property = NULL;
+    
+    AXIS2_ENV_CHECK(env, NULL);
+    sender_impl = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_sender_mgr_impl_t));
+
+    sender_impl->table = NULL;
+    sender_impl->mutex = NULL;
+
+    sender_impl->sender.ops = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_sender_mgr_ops_t)); 
+    
+    sender_impl->mutex = axis2_thread_mutex_create(env->allocator, 
+            AXIS2_THREAD_MUTEX_DEFAULT);
+    if(!sender_impl->mutex) 
+    {
+        sandesha2_in_memory_sender_mgr_free(&(sender_impl->sender), env);
+        return NULL;
+    }
+
+    property = AXIS2_CTX_GET_PROPERTY(ctx, env, 
+            SANDESHA2_BEAN_MAP_RETRANSMITTER, AXIS2_FALSE);
+    sender_impl->table = (axis2_hash_t *) AXIS2_PROPERTY_GET_VALUE(property, env);
+    if(!sender_impl->table)
+    {
+        axis2_property_t *property = NULL;
+
+        property = axis2_property_create(env);
+        sender_impl->table = axis2_hash_make(env);
+        if(!property || !sender_impl->table)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            return NULL;
+        }
+        AXIS2_PROPERTY_SET_VALUE(property, env, sender_impl->table);
+        AXIS2_PROPERTY_SET_FREE_FUNC(property, env, sender_impl->sender.ops->free);
+        AXIS2_CTX_SET_PROPERTY(ctx, env, SANDESHA2_BEAN_MAP_RETRANSMITTER, 
+                property, AXIS2_FALSE);
+    }
+    sender_impl->sender.ops->free = sandesha2_in_memory_sender_mgr_free;
+    sender_impl->sender.ops->insert = 
+        sandesha2_in_memory_sender_mgr_insert;
+    sender_impl->sender.ops->remove = 
+        sandesha2_in_memory_sender_mgr_remove;
+    sender_impl->sender.ops->retrieve = 
+        sandesha2_in_memory_sender_mgr_retrieve;
+    sender_impl->sender.ops->update = 
+        sandesha2_in_memory_sender_mgr_update;
+    sender_impl->sender.ops->find_by_internal_seq_id = 
+        sandesha2_in_memory_sender_mgr_find_by_internal_seq_id;
+    sender_impl->sender.ops->find_by_sender_bean = 
+        sandesha2_in_memory_sender_mgr_find_by_sender_bean;
+    sender_impl->sender.ops->find_unique = 
+        sandesha2_in_memory_sender_mgr_find_unique;
+    sender_impl->sender.ops->get_next_msg_to_send = 
+        sandesha2_in_memory_sender_mgr_get_next_msg_to_send;
+    sender_impl->sender.ops->retrieve_from_msg_ref_key = 
+        sandesha2_in_memory_sender_mgr_retrieve_from_msg_ref_key;
+
+    return &(sender_impl->sender);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_memory_sender_mgr_free(
+        void *sender,
+        const axis2_env_t *env)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    if(sender_impl->mutex)
+    {
+        axis2_thread_mutex_destry(sender_impl->mutex);
+        sender_impl->mutex = NULL;
+    }
+    if(sender_impl->table)
+    {
+        axis2_hash_free(sender_impl->table, env);
+        sender_impl->table = NULL;
+    }
+
+    if((&(sender_impl->sender))->ops)
+    {
+        AXIS2_FREE(env->allocator, (&(sender_impl->sender))->ops);
+        (&(sender_impl->sender))->ops = NULL;
+    }
+
+    if(sender_impl)
+    {
+        AXIS2_FREE(env->allocator, sender_impl);
+        sender_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_sender_mgr_insert(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    axis2_char_t *msg_id = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+
+    msg_id = SANDESHA2_SENDER_BEAN_GET_MSG_CONTEXT_REF_KEY(bean, env);
+    if(!msg_id)
+    {
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_KEY_IS_NULL, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(sender_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    axis2_hash_set(sender_impl->table, msg_id, AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_sender_mgr_remove(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_char_t *msg_id)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, msg_id, AXIS2_FALSE);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+    axis2_hash_set(sender_impl->table, msg_id, AXIS2_HASH_KEY_STRING, NULL);
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+sandesha2_sender_bean_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_retrieve(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_char_t *msg_id)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    sandesha2_sender_bean_t *bean = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, msg_id, AXIS2_FALSE);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+    bean = (sandesha2_sender_bean_t *) axis2_hash_get(sender_impl->table, 
+            msg_id, AXIS2_HASH_KEY_STRING);
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return bean;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_sender_mgr_update(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    axis2_char_t *msg_id = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+    msg_id = SANDESHA2_SENDER_BEAN_GET_MSG_CONTEXT_REF_KEY(bean, env);
+    if(!msg_id)
+    {
+        axis2_thread_mutex_unlock(sender_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return AXIS2_TRUE; /* No need to update. Being a reference does the job */
+}
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_find_by_internal_seq_id(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_char_t *internal_seq_id)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    axis2_array_list_t *list = NULL;
+    axis2_hash_index_t *i = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+    
+    list = axis2_array_list_create(env, 0);
+    if(!list)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(sender_impl->mutex);
+        return NULL;
+    }
+    if(!internal_seq_id || 0 == AXIS2_STRCMP(internal_seq_id, ""))
+        return list;
+    for (i = axis2_hash_first (sender_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        sandesha2_sender_bean_t *sender_bean = NULL;
+        void *v = NULL;
+        axis2_char_t *temp_internal_seq_id = NULL;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        sender_bean = (sandesha2_sender_bean_t *) v;
+        temp_internal_seq_id = SANDESHA2_SENDER_BEAN_GET_INTERNAL_SEQ_ID(
+                sender_bean, env);
+        if(internal_seq_id && temp_internal_seq_id && 0 == AXIS2_STRCMP(
+                    internal_seq_id, temp_internal_seq_id))
+        {
+            AXIS2_ARRAY_LIST_ADD(list, env, sender_bean);
+        }
+        
+    }
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return list;
+}
+
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_find_by_sender_bean(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    axis2_hash_index_t *i = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+    beans = axis2_array_list_create(env, 0);
+    if(!beans)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(sender_impl->mutex);
+        return NULL;
+    }
+    if(!bean)
+    {
+        axis2_thread_mutex_unlock(sender_impl->mutex);
+        return beans;
+    }
+    for (i = axis2_hash_first (sender_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        sandesha2_sender_bean_t *temp = NULL;
+        void *v = NULL;
+        axis2_bool_t add = AXIS2_TRUE;
+        axis2_char_t *ref_key = NULL;
+        axis2_char_t *temp_ref_key = NULL;
+        long time_to_send = 0;
+        long temp_time_to_send = 0;
+        axis2_char_t *msg_id = NULL;
+        axis2_char_t *temp_msg_id = NULL;
+        axis2_char_t *internal_seq_id = NULL;
+        axis2_char_t *temp_internal_seq_id = NULL;
+        long msg_no = 0;
+        long temp_msg_no = 0;
+        int msg_type = 0;
+        int temp_msg_type = 0;
+        axis2_bool_t is_send = AXIS2_FALSE;
+        axis2_bool_t temp_is_send = AXIS2_FALSE;
+        axis2_bool_t is_resend = AXIS2_FALSE;
+        axis2_bool_t temp_is_resend = AXIS2_FALSE;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        temp = (sandesha2_sender_bean_t *) v;
+        ref_key = SANDESHA2_SENDER_BEAN_GET_MSG_CONTEXT_REF_KEY(bean, env);
+        temp_ref_key = SANDESHA2_SENDER_BEAN_GET_MSG_CONTEXT_REF_KEY(temp, env);
+        if(time_to_send > 0 && (time_to_send != temp_time_to_send))
+        {
+            add = AXIS2_FALSE;
+        }
+        ref_key = SANDESHA2_SENDER_BEAN_GET_MSG_CONTEXT_REF_KEY(bean, env);
+        temp_ref_key = SANDESHA2_SENDER_BEAN_GET_MSG_CONTEXT_REF_KEY(temp, env);
+        if(ref_key && temp_ref_key && 0 != AXIS2_STRCMP(ref_key, temp_ref_key))
+        {
+            add = AXIS2_FALSE;
+        }
+        msg_id = SANDESHA2_SENDER_BEAN_GET_MSG_ID(bean, env);
+        temp_msg_id = SANDESHA2_SENDER_BEAN_GET_MSG_ID(temp, env);
+        if(msg_id && temp_msg_id && 0 != AXIS2_STRCMP(msg_id, temp_msg_id))
+        {
+            add = AXIS2_FALSE;
+        }
+        internal_seq_id = SANDESHA2_SENDER_BEAN_GET_INTERNAL_SEQ_ID(bean, env);
+        temp_internal_seq_id = SANDESHA2_SENDER_BEAN_GET_INTERNAL_SEQ_ID(temp, 
+                env);
+        if(internal_seq_id && temp_internal_seq_id && 0 != AXIS2_STRCMP(
+                    internal_seq_id, temp_internal_seq_id))
+        {
+            add = AXIS2_FALSE;
+        }
+        msg_no = SANDESHA2_SENDER_BEAN_GET_MSG_NO(bean, env);
+        temp_msg_no = SANDESHA2_SENDER_BEAN_GET_MSG_NO(temp, env);
+        if(msg_no > 0 && (msg_no != temp_msg_no))
+        {
+            add = AXIS2_FALSE;
+        }
+        msg_type = SANDESHA2_SENDER_BEAN_GET_MSG_TYPE(bean, env);
+        temp_msg_type = SANDESHA2_SENDER_BEAN_GET_MSG_TYPE(temp, env);
+        if(msg_type != SANDESHA2_MSG_TYPE_UNKNOWN  && (msg_type != temp_msg_type))
+        {
+            add = AXIS2_FALSE;
+        }
+        is_send = SANDESHA2_SENDER_BEAN_IS_SEND(bean, env);
+        temp_is_send = SANDESHA2_SENDER_BEAN_IS_SEND(temp, env);
+        if(is_send != temp_is_send)
+        {
+            add = AXIS2_FALSE;
+        }
+        is_resend = SANDESHA2_SENDER_BEAN_IS_RESEND(bean, env);
+        temp_is_resend = SANDESHA2_SENDER_BEAN_IS_RESEND(temp, env);
+        if(is_resend != temp_is_resend)
+        {
+            add = AXIS2_FALSE;
+        }
+        if(AXIS2_TRUE == add)
+        {
+            AXIS2_ARRAY_LIST_ADD(beans, env, temp);
+        }
+        
+    }
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return beans;
+}
+
+sandesha2_sender_bean_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_find_unique(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    int i = 0, size = 0;
+    sandesha2_sender_bean_t *ret = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+    
+    beans = sandesha2_in_memory_sender_mgr_find_by_sender_bean(sender, env, 
+            bean);
+    if(beans)
+        size = AXIS2_ARRAY_LIST_SIZE(beans, env);
+    if( size > 1)
+    {
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Non-Unique result");
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NON_UNIQUE_RESULT, 
+                AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(sender_impl->mutex);
+        return NULL;
+    }
+    for(i = 0; i < size; i++)
+    {
+       ret = AXIS2_ARRAY_LIST_GET(beans, env, i);
+       break;
+    }
+    
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return ret;
+}
+
+sandesha2_sender_bean_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_get_next_msg_to_send(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    long lowest_app_msg_no = 0;
+    axis2_hash_index_t *i = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+    
+    for (i = axis2_hash_first (sender_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        sandesha2_sender_bean_t *temp = NULL;
+        void *v = NULL;
+        axis2_bool_t is_send = AXIS2_FALSE;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        temp = (sandesha2_sender_bean_t *) v;
+        is_send = SANDESHA2_SENDER_BEAN_IS_SEND(temp, env);
+        if(AXIS2_TRUE == is_send)
+        {
+            long time_to_send = 0;
+            long time_now = 0;
+
+            time_to_send = SANDESHA2_SENDER_BEAN_GET_TIME_TO_SEND(temp, env);
+            time_now = SANDESHA2_UTIL_GET_CURRENT_TIME_IN_MILLIS(env);
+            if(time_now >= time_to_send)
+            {
+                int msg_type = SANDESHA2_SENDER_BEAN_GET_MSG_TYPE(temp, env);
+                if(msg_type == SANDESHA2_MSG_TYPE_APPLICATION)
+                {
+                    long msg_no = SANDESHA2_SENDER_BEAN_GET_MSG_NO(temp, env);
+                    if(lowest_app_msg_no == 0 || msg_no < lowest_app_msg_no)
+                        lowest_app_msg_no = msg_no;
+                }
+            }
+        }
+    }
+    
+    for (i = axis2_hash_first (sender_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        sandesha2_sender_bean_t *temp = NULL;
+        void *v = NULL;
+        axis2_bool_t is_send = AXIS2_FALSE;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        temp = (sandesha2_sender_bean_t *) v;
+        is_send = SANDESHA2_SENDER_BEAN_IS_SEND(temp, env);
+        if(AXIS2_TRUE == is_send)
+        {
+            long time_to_send = 0;
+            long time_now = 0;
+
+            time_to_send = SANDESHA2_SENDER_BEAN_GET_TIME_TO_SEND(temp, env);
+            time_now = SANDESHA2_UTIL_GET_CURRENT_TIME_IN_MILLIS(env);
+            if(time_now >= time_to_send)
+            {
+                axis2_bool_t valid = AXIS2_FALSE;
+                int msg_type = SANDESHA2_SENDER_BEAN_GET_MSG_TYPE(temp, env);
+                
+                if(msg_type == SANDESHA2_MSG_TYPE_APPLICATION)
+                {
+                    long msg_no = SANDESHA2_SENDER_BEAN_GET_MSG_NO(temp, env);
+                    
+                    if(msg_no == lowest_app_msg_no)
+                        valid = AXIS2_TRUE;
+                }
+                else
+                    valid = AXIS2_TRUE;
+                if(AXIS2_TRUE == valid)
+                {
+                    sandesha2_in_memory_sender_mgr_update_next_sending_time(
+                            sender, env, temp);
+                    axis2_thread_mutex_unlock(sender_impl->mutex);
+                    return temp;
+                }
+            }
+        }
+    }
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return NULL;
+}
+
+static axis2_status_t
+sandesha2_in_memory_sender_mgr_update_next_sending_time(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        sandesha2_sender_bean_t *bean)
+{
+    return AXIS2_SUCCESS;
+}
+
+/*
+static axis2_array_list_t *
+sandesha2_in_memory_sender_mgr_find_beans_with_msg_no(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_array_list_t *list,
+        long msg_no)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    int i = 0, size =0;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    AXIS2_PARAM_CHECK(env->error, list, NULL);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+    
+    beans = axis2_array_list_create(env, 0);
+    if(!beans)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(sender_impl->mutex);
+        return NULL;
+    }
+    size = AXIS2_ARRAY_LIST_SIZE(list, env); 
+    for(i = 0; i < size; i++)
+    {
+        long msg_no_l = 0;
+        sandesha2_sender_bean_t *bean = NULL;
+        
+        bean = (sandesha2_sender_bean_t *) AXIS2_ARRAY_LIST_GET(list, 
+                env, i);
+        msg_no_l = SANDESHA2_SENDER_BEAN_GET_MSG_NO(bean, env);
+        if(msg_no_l == msg_no)
+        {
+            AXIS2_ARRAY_LIST_ADD(beans, env, bean);
+        }
+        
+    }
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return beans;
+}
+*/
+
+sandesha2_sender_bean_t *AXIS2_CALL
+sandesha2_in_memory_sender_mgr_retrieve_from_msg_ref_key(
+        sandesha2_in_memory_sender_mgr_t *sender,
+        const axis2_env_t *env,
+        axis2_char_t *msg_ctx_ref_key)
+{
+    sandesha2_in_memory_sender_mgr_impl_t *sender_impl = NULL;
+    axis2_hash_index_t *i = NULL;
+
+    AXIS2_ENV_CHECK(env, NULL);
+    AXIS2_PARAM_CHECK(env->error, msg_ctx_ref_key, NULL);
+    sender_impl = SANDESHA2_INTF_TO_IMPL(sender);
+
+    axis2_thread_mutex_lock(sender_impl->mutex);
+    
+    for (i = axis2_hash_first (sender_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        sandesha2_sender_bean_t *bean = NULL;
+        axis2_char_t *msg_ctx_ref_key_l = NULL;
+        void *v = NULL;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        bean = (sandesha2_sender_bean_t *) v;
+        msg_ctx_ref_key_l = SANDESHA2_SENDER_BEAN_GET_MSG_CONTEXT_REF_KEY(bean, env);
+        if(msg_ctx_ref_key_l && 0 == AXIS2_STRCMP(msg_ctx_ref_key_l, 
+                    msg_ctx_ref_key))
+        {
+            axis2_thread_mutex_unlock(sender_impl->mutex);
+            return bean;
+        }
+    }    
+    axis2_thread_mutex_unlock(sender_impl->mutex);
+
+    return NULL;
+}
+
+
+
+

Added: webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_seq_property_mgr.c
URL: http://svn.apache.org/viewvc/webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_seq_property_mgr.c?rev=420702&view=auto
==============================================================================
--- webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_seq_property_mgr.c (added)
+++ webservices/sandesha/trunk/c/src/storage/inmemory/in_memory_seq_property_mgr.c Mon Jul 10 21:08:10 2006
@@ -0,0 +1,534 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+#include <sandesha2_in_memory_seq_property_mgr.h>
+#include <sandesha2_constants.h>
+#include <sandesha2_error.h>
+#include <sandesha2_utils.h>
+#include <axis2_log.h>
+#include <axis2_hash.h>
+#include <axis2_thread.h>
+#include <axis2_property.h>
+
+typedef struct sandesha2_in_memory_seq_property_mgr_impl sandesha2_in_memory_seq_property_mgr_impl_t;
+
+/** 
+ * @brief Sandesha Sequence Report Struct Impl
+ *   Sandesha Sequence Report 
+ */ 
+struct sandesha2_in_memory_seq_property_mgr_impl
+{
+    sandesha2_in_memory_seq_property_mgr_t seq_property;
+	
+    axis2_hash_t *table;
+    axis2_array_list_t *values;
+    axis2_thread_mutex_t *mutex;
+
+};
+
+#define SANDESHA2_INTF_TO_IMPL(seq_property) ((sandesha2_in_memory_seq_property_mgr_impl_t *) seq_property)
+
+axis2_status_t AXIS2_CALL 
+sandesha2_in_memory_seq_property_mgr_free(
+        void *seq_property,
+        const axis2_env_t *envv);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_insert(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_remove(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        axis2_char_t *seq_id,
+        axis2_char_t *name);
+
+sandesha2_sequence_property_bean_t *AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_retrieve(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        axis2_char_t *seq_id,
+        axis2_char_t *name);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_update(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean);
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_find(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean);
+
+sandesha2_sequence_property_bean_t *AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_find_unique(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean);
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_retrieve_all(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env);
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_update_or_insert(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean);
+
+static axis2_char_t *
+sandesha2_in_memory_seq_property_mgr_get_id(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean);
+
+AXIS2_EXTERN sandesha2_in_memory_seq_property_mgr_t * AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_create(
+        const axis2_env_t *env,
+        axis2_ctx_t *ctx)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    axis2_property_t *property = NULL;
+    
+    AXIS2_ENV_CHECK(env, NULL);
+    seq_property_impl = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_seq_property_mgr_impl_t));
+
+    seq_property_impl->table = NULL;
+    seq_property_impl->values = NULL;
+    seq_property_impl->mutex = NULL;
+
+    seq_property_impl->seq_property.ops = AXIS2_MALLOC(env->allocator, 
+                    sizeof(sandesha2_in_memory_seq_property_mgr_ops_t)); 
+    
+    seq_property_impl->mutex = axis2_thread_mutex_create(env->allocator, 
+            AXIS2_THREAD_MUTEX_DEFAULT);
+    if(!seq_property_impl->mutex) 
+    {
+        sandesha2_in_memory_seq_property_mgr_free(&(seq_property_impl->seq_property), env);
+        return NULL;
+    }
+
+    property = AXIS2_CTX_GET_PROPERTY(ctx, env, 
+            SANDESHA2_BEAN_MAP_SEQUENCE_PROPERTY, AXIS2_FALSE);
+    seq_property_impl->table = (axis2_hash_t *) AXIS2_PROPERTY_GET_VALUE(property, env);
+    if(!seq_property_impl->table)
+    {
+        axis2_property_t *property = NULL;
+
+        property = axis2_property_create(env);
+        seq_property_impl->table = axis2_hash_make(env);
+        if(!property || !seq_property_impl->table)
+        {
+            AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+            return NULL;
+        }
+        AXIS2_PROPERTY_SET_VALUE(property, env, seq_property_impl->table);
+        AXIS2_PROPERTY_SET_FREE_FUNC(property, env, seq_property_impl->seq_property.ops->free);
+        AXIS2_CTX_SET_PROPERTY(ctx, env, SANDESHA2_BEAN_MAP_SEQUENCE_PROPERTY, 
+                property, AXIS2_FALSE);
+    }
+    seq_property_impl->seq_property.ops->free = sandesha2_in_memory_seq_property_mgr_free;
+    seq_property_impl->seq_property.ops->insert = 
+        sandesha2_in_memory_seq_property_mgr_insert;
+    seq_property_impl->seq_property.ops->remove = 
+        sandesha2_in_memory_seq_property_mgr_remove;
+    seq_property_impl->seq_property.ops->retrieve = 
+        sandesha2_in_memory_seq_property_mgr_retrieve;
+    seq_property_impl->seq_property.ops->update = 
+        sandesha2_in_memory_seq_property_mgr_update;
+    seq_property_impl->seq_property.ops->find = 
+        sandesha2_in_memory_seq_property_mgr_find;
+    seq_property_impl->seq_property.ops->find_unique = 
+        sandesha2_in_memory_seq_property_mgr_find_unique;
+    seq_property_impl->seq_property.ops->retrieve_all = 
+        sandesha2_in_memory_seq_property_mgr_retrieve_all;
+    seq_property_impl->seq_property.ops->update_or_insert = 
+        sandesha2_in_memory_seq_property_mgr_update_or_insert;
+
+    return &(seq_property_impl->seq_property);
+}
+
+axis2_status_t AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_free(
+        void *seq_property,
+        const axis2_env_t *env)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FAILURE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    if(seq_property_impl->mutex)
+    {
+        axis2_thread_mutex_destry(seq_property_impl->mutex);
+        seq_property_impl->mutex = NULL;
+    }
+    if(seq_property_impl->values)
+    {
+        AXIS2_ARRAY_LIST_FREE(seq_property_impl->values, env);
+        seq_property_impl->values = NULL;
+    }
+
+    if(seq_property_impl->table)
+    {
+        axis2_hash_free(seq_property_impl->table, env);
+        seq_property_impl->table = NULL;
+    }
+
+    if((&(seq_property_impl->seq_property))->ops)
+    {
+        AXIS2_FREE(env->allocator, (&(seq_property_impl->seq_property))->ops);
+        (&(seq_property_impl->seq_property))->ops = NULL;
+    }
+
+    if(seq_property_impl)
+    {
+        AXIS2_FREE(env->allocator, seq_property_impl);
+        seq_property_impl = NULL;
+    }
+    return AXIS2_SUCCESS;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_insert(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    axis2_char_t *seq_id = NULL;
+    axis2_char_t *id = NULL;
+    axis2_char_t *name = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    axis2_thread_mutex_lock(seq_property_impl->mutex);
+
+    seq_id = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_SEQUENCE_ID(bean, env);
+    if(!seq_id)
+    {
+        axis2_thread_mutex_unlock(seq_property_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    name = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_NAME(bean, env);
+    if(!name)
+    {
+        axis2_thread_mutex_unlock(seq_property_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    id = axis2_strcat(env, seq_id, ":", name, NULL);
+    axis2_hash_set(seq_property_impl->table, id, AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(seq_property_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_remove(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        axis2_char_t *seq_id,
+        axis2_char_t *name)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    sandesha2_sequence_property_bean_t *bean = NULL;
+    axis2_char_t *key = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, name, AXIS2_FALSE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    axis2_thread_mutex_lock(seq_property_impl->mutex);
+    
+    bean = sandesha2_in_memory_seq_property_mgr_retrieve(seq_property, env, 
+            seq_id, name);
+    key = axis2_strcat(env, seq_id, ":", name, NULL); 
+    axis2_hash_set(seq_property_impl->table, key, AXIS2_HASH_KEY_STRING, NULL);
+    AXIS2_FREE(env->allocator, key);
+    axis2_thread_mutex_unlock(seq_property_impl->mutex);
+
+    return AXIS2_TRUE;
+
+}
+
+sandesha2_sequence_property_bean_t *AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_retrieve(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        axis2_char_t *seq_id,
+        axis2_char_t *name)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    sandesha2_sequence_property_bean_t *bean = NULL;
+    axis2_char_t *key = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, seq_id, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, name, AXIS2_FALSE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    axis2_thread_mutex_lock(seq_property_impl->mutex);
+    
+    key = axis2_strcat(env, seq_id, ":", name, NULL); 
+    bean = (sandesha2_sequence_property_bean_t *) axis2_hash_get(seq_property_impl->table, 
+            key, AXIS2_HASH_KEY_STRING);
+    axis2_thread_mutex_unlock(seq_property_impl->mutex);
+
+    return bean;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_update(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    axis2_char_t *id = NULL;
+    sandesha2_sequence_property_bean_t *bean_l = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    axis2_thread_mutex_lock(seq_property_impl->mutex);
+    id = sandesha2_in_memory_seq_property_mgr_get_id(seq_property, env, bean);
+    if(!id)
+    {
+        axis2_thread_mutex_unlock(seq_property_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    bean_l = axis2_hash_get(seq_property_impl->table, id, 
+            AXIS2_HASH_KEY_STRING);
+    if(!bean_l)
+    {
+        axis2_thread_mutex_unlock(seq_property_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    axis2_hash_set(seq_property_impl->table, id, 
+            AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(seq_property_impl->mutex);
+
+    return AXIS2_TRUE;
+}
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_find(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    axis2_hash_index_t *i = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    axis2_thread_mutex_lock(seq_property_impl->mutex);
+    beans = axis2_array_list_create(env, 0);
+    if(!beans)
+    {
+        AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(seq_property_impl->mutex);
+        return NULL;
+    }
+    if(!bean)
+    {
+        axis2_thread_mutex_unlock(seq_property_impl->mutex);
+        return beans;
+    }
+    for (i = axis2_hash_first (seq_property_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        sandesha2_sequence_property_bean_t *temp = NULL;
+        void *v = NULL;
+        axis2_bool_t equal = AXIS2_TRUE;
+        axis2_char_t *seq_id = NULL;
+        axis2_char_t *temp_seq_id = NULL;
+        axis2_char_t *name = NULL;
+        axis2_char_t *temp_name = NULL;
+        axis2_char_t *value = NULL;
+        axis2_char_t *temp_value = NULL;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        temp = (sandesha2_sequence_property_bean_t *) v;
+        seq_id = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_SEQUENCE_ID(bean, env);
+        temp_seq_id = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_SEQUENCE_ID(temp, env);
+        if(seq_id && temp_seq_id && 0 != AXIS2_STRCMP(seq_id, temp_seq_id))
+        {
+            equal = AXIS2_FALSE;
+        }
+        name = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_NAME(bean, env);
+        temp_name = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_NAME(temp, env);
+        if(name && temp_name && 0 != AXIS2_STRCMP(name, temp_name))
+        {
+            equal = AXIS2_FALSE;
+        }
+        value = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_VALUE(bean, env);
+        temp_value = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_VALUE(temp, 
+                env);
+        if(value && temp_value && 0 != AXIS2_STRCMP(value, temp_value))
+        {
+            equal = AXIS2_FALSE;
+        }
+        if(AXIS2_TRUE == equal)
+        {
+            AXIS2_ARRAY_LIST_ADD(beans, env, temp);
+        }
+        
+    }
+    axis2_thread_mutex_unlock(seq_property_impl->mutex);
+
+    return beans;
+}
+
+sandesha2_sequence_property_bean_t *AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_find_unique(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    axis2_array_list_t *beans = NULL;
+    int i = 0, size = 0;
+    sandesha2_sequence_property_bean_t *ret = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    AXIS2_PARAM_CHECK(env->error, bean, AXIS2_FALSE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    axis2_thread_mutex_lock(seq_property_impl->mutex);
+    
+    beans = sandesha2_in_memory_seq_property_mgr_find(seq_property, env, 
+            bean);
+    if(beans)
+        size = AXIS2_ARRAY_LIST_SIZE(beans, env);
+    if( size > 1)
+    {
+        AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "Non-Unique result");
+        AXIS2_ERROR_SET(env->error, SANDESHA2_ERROR_NON_UNIQUE_RESULT, 
+                AXIS2_FAILURE);
+        axis2_thread_mutex_unlock(seq_property_impl->mutex);
+        return NULL;
+    }
+    for(i = 0; i < size; i++)
+    {
+       ret = AXIS2_ARRAY_LIST_GET(beans, env, i);
+       break;
+    }
+    
+    axis2_thread_mutex_unlock(seq_property_impl->mutex);
+
+    return ret;
+}
+
+axis2_array_list_t *AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_retrieve_all(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    axis2_hash_index_t *i = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    axis2_thread_mutex_lock(seq_property_impl->mutex);
+    for (i = axis2_hash_first (seq_property_impl->table, env); i; 
+            i = axis2_hash_next (env, i))
+    {
+        sandesha2_sequence_property_bean_t *bean = NULL;
+        void *v = NULL;
+        
+        axis2_hash_this (i, NULL, NULL, &v);
+        bean = (sandesha2_sequence_property_bean_t *) v;
+        AXIS2_ARRAY_LIST_ADD(seq_property_impl->values, env, bean);
+    }
+
+    axis2_thread_mutex_unlock(seq_property_impl->mutex);
+
+    return seq_property_impl->values;
+}
+
+axis2_bool_t AXIS2_CALL
+sandesha2_in_memory_seq_property_mgr_update_or_insert(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    axis2_char_t *id = NULL;
+    sandesha2_sequence_property_bean_t *bean_l = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    axis2_thread_mutex_lock(seq_property_impl->mutex);
+    id = sandesha2_in_memory_seq_property_mgr_get_id(seq_property, env, bean);
+    if(!id)
+    {
+        axis2_thread_mutex_unlock(seq_property_impl->mutex);
+        return AXIS2_FALSE;
+    }
+    bean_l = axis2_hash_get(seq_property_impl->table, id, 
+            AXIS2_HASH_KEY_STRING);
+    if(!bean_l)
+    {
+        axis2_hash_set(seq_property_impl->table, id, 
+            AXIS2_HASH_KEY_STRING, bean);
+    }
+    axis2_hash_set(seq_property_impl->table, id, 
+            AXIS2_HASH_KEY_STRING, bean);
+    axis2_thread_mutex_unlock(seq_property_impl->mutex);
+
+    return AXIS2_TRUE;
+}
+
+static axis2_char_t *
+sandesha2_in_memory_seq_property_mgr_get_id(
+        sandesha2_in_memory_seq_property_mgr_t *seq_property,
+        const axis2_env_t *env,
+        sandesha2_sequence_property_bean_t *bean)
+{
+    sandesha2_in_memory_seq_property_mgr_impl_t *seq_property_impl = NULL;
+    axis2_char_t *seq_id = NULL;
+    axis2_char_t *name = NULL;
+    axis2_char_t *id = NULL;
+
+    AXIS2_ENV_CHECK(env, AXIS2_FALSE);
+    seq_property_impl = SANDESHA2_INTF_TO_IMPL(seq_property);
+
+    axis2_thread_mutex_lock(seq_property_impl->mutex);
+    seq_id = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_SEQUENCE_ID(bean, env);
+    name = SANDESHA2_SEQUENCE_PROPERTY_BEAN_GET_NAME(bean, env);
+    id = axis2_strcat(env, seq_id, ":", name, NULL);
+    axis2_thread_mutex_unlock(seq_property_impl->mutex);
+
+    return id;
+}
+



---------------------------------------------------------------------
To unsubscribe, e-mail: sandesha-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: sandesha-dev-help@ws.apache.org