Adding upstream version 0.6.2.upstream/0.6.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 512 insertions, 0 deletions

diff --git a/src/libcmis-c/object.cxx b/src/libcmis-c/object.cxx
new file mode 100644
index 0000000..323cb31
--- /dev/null
+++ b/src/libcmis-c/object.cxx
@@ -0,0 +1,512 @@
+/* libcmis
+ * Version: MPL 1.1 / GPLv2+ / LGPLv2+
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License or as specified alternatively below. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * Major Contributor(s):
+ * Copyright (C) 2011 SUSE <cbosdonnat@suse.com>
+ *
+ *
+ * All Rights Reserved.
+ *
+ * For minor contributions see the git repository.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPLv2+"), or
+ * the GNU Lesser General Public License Version 2 or later (the "LGPLv2+"),
+ * in which case the provisions of the GPLv2+ or the LGPLv2+ are applicable
+ * instead of those above.
+ */
+
+#include <libcmis-c/object.h>
+
+#include <libcmis-c/folder.h>
+
+#include "internals.hxx"
+
+using namespace std;
+using libcmis::PropertyPtrMap;
+using boost::dynamic_pointer_cast;
+
+namespace
+{
+    string lcl_stdString( const char* str )
+    {
+        string result;
+        if ( str )
+            result = string( str );
+        return result;
+    }
+
+    PropertyPtrMap lcl_createPropertiesMap( libcmis_vector_property_Ptr properties )
+    {
+        PropertyPtrMap propertiesMap;
+        if ( properties )
+        {
+            for ( vector< libcmis::PropertyPtr >::iterator it = properties->handle.begin( );
+                    it != properties->handle.end( ); ++it )
+            {
+                libcmis::PropertyPtr propHandle = *it;
+                propertiesMap[ propHandle->getPropertyType()->getId( ) ] = propHandle;
+            }
+        }
+        return propertiesMap;
+    }
+}
+
+void libcmis_vector_object_free( libcmis_vector_object_Ptr vector )
+{
+    delete vector;
+}
+
+
+size_t libcmis_vector_object_size( libcmis_vector_object_Ptr vector )
+{
+    size_t size = 0;
+    if ( vector != NULL )
+        size = vector->handle.size( );
+    return size;
+}
+
+
+libcmis_ObjectPtr libcmis_vector_object_get( libcmis_vector_object_Ptr vector, size_t i )
+{
+    libcmis_ObjectPtr item = NULL;
+    if ( vector != NULL && i < vector->handle.size( ) )
+    {
+        libcmis::ObjectPtr type = vector->handle[i];
+        item = new ( nothrow ) libcmis_object( );
+        if ( item )
+            item->handle = type;
+    }
+    return item;
+}
+
+
+void libcmis_object_free( libcmis_ObjectPtr object )
+{
+    delete object;
+}
+
+
+char* libcmis_object_getId( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return strdup( object->handle->getId( ).c_str( ) );
+    else
+        return NULL;
+}
+
+
+char* libcmis_object_getName( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return strdup( object->handle->getName( ).c_str( ) );
+    else
+        return NULL;
+}
+
+libcmis_vector_string_Ptr libcmis_object_getPaths( libcmis_ObjectPtr object )
+{
+    libcmis_vector_string_Ptr c_paths = NULL;
+    if ( object != NULL && object->handle != NULL )
+    {
+        std::vector< std::string > paths = object->handle->getPaths( );
+        c_paths = new ( nothrow ) libcmis_vector_string( );
+        if ( c_paths )
+            c_paths->handle = paths;
+    }
+    return c_paths;
+}
+
+char* libcmis_object_getBaseType( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return strdup( object->handle->getBaseType( ).c_str( ) );
+    else
+        return NULL;
+}
+
+
+char* libcmis_object_getType( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return strdup( object->handle->getType( ).c_str( ) );
+    else
+        return NULL;
+}
+
+
+char* libcmis_object_getCreatedBy( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return strdup( object->handle->getCreatedBy( ).c_str( ) );
+    else
+        return NULL;
+}
+
+
+time_t libcmis_object_getCreationDate( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+    {
+        tm time = boost::posix_time::to_tm( object->handle->getCreationDate( ) );
+        return mktime( &time );
+    }
+    else
+        return 0;
+}
+
+
+char* libcmis_object_getLastModifiedBy( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return strdup( object->handle->getLastModifiedBy( ).c_str( ) );
+    else
+        return NULL;
+}
+
+
+time_t libcmis_object_getLastModificationDate( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+    {
+        tm time = boost::posix_time::to_tm( object->handle->getLastModificationDate( ) );
+        return mktime( &time );
+    }
+    else
+        return 0;
+}
+
+
+char* libcmis_object_getChangeToken( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return strdup( object->handle->getChangeToken( ).c_str( ) );
+    else
+        return NULL;
+}
+
+char* libcmis_object_getThumbnailUrl( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return strdup( object->handle->getThumbnailUrl( ).c_str( ) );
+    else
+        return NULL;
+}
+
+libcmis_vector_rendition_Ptr libcmis_object_getRenditions( libcmis_ObjectPtr object,
+                                                           libcmis_ErrorPtr error )
+{
+    libcmis_vector_rendition_Ptr result = NULL;
+    if ( object != NULL && object->handle.get( ) != NULL )
+    {
+        try
+        {
+            std::vector< libcmis::RenditionPtr > handles = object->handle->getRenditions( );
+            result = new libcmis_vector_rendition( );
+            result->handle = handles;
+        }
+
+        catch ( const bad_alloc& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->badAlloc = true;
+            }
+        }
+    }
+    return result;
+}
+
+bool libcmis_object_isImmutable( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return object->handle->isImmutable( );
+    else
+        return true;
+}
+
+libcmis_vector_string_Ptr libcmis_object_getSecondaryTypes( libcmis_ObjectPtr object )
+{
+    libcmis_vector_string_Ptr c_types = NULL;
+    if ( object != NULL && object->handle != NULL )
+    {
+        vector< string > types = object->handle->getSecondaryTypes( );
+        c_types = new ( nothrow ) libcmis_vector_string( );
+        if ( c_types )
+            c_types->handle = types;
+    }
+    return c_types;
+}
+
+libcmis_ObjectPtr
+libcmis_object_addSecondaryType( libcmis_ObjectPtr object,
+                                 const char* id,
+                                 libcmis_vector_property_Ptr properties,
+                                 libcmis_ErrorPtr error )
+{
+    libcmis_ObjectPtr updated = NULL;
+    if ( object != NULL && object->handle != NULL && properties != NULL )
+    {
+        try
+        {
+            PropertyPtrMap propertiesMap = lcl_createPropertiesMap( properties );
+            libcmis::ObjectPtr result = object->handle->addSecondaryType(
+                                                    lcl_stdString( id ),
+                                                    propertiesMap );
+            updated = new libcmis_object( );
+            updated->handle = result;
+        }
+        catch ( const libcmis::Exception& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->type = strdup( e.getType().c_str() );
+            }
+        }
+        catch ( const bad_alloc& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->badAlloc = true;
+            }
+        }
+    }
+    return updated;
+}
+
+libcmis_ObjectPtr
+libcmis_object_removeSecondaryType( libcmis_ObjectPtr object,
+                                    const char* id,
+                                    libcmis_ErrorPtr error )
+{
+    libcmis_ObjectPtr updated = NULL;
+    if ( object != NULL && object->handle != NULL )
+    {
+        try
+        {
+            libcmis::ObjectPtr result = object->handle->removeSecondaryType(
+                                                lcl_stdString( id ) );
+            updated = new libcmis_object( );
+            updated->handle = result;
+        }
+        catch ( const libcmis::Exception& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->type = strdup( e.getType().c_str() );
+            }
+        }
+        catch ( const bad_alloc& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->badAlloc = true;
+            }
+        }
+    }
+    return updated;
+}
+
+libcmis_vector_property_Ptr libcmis_object_getProperties( libcmis_ObjectPtr object )
+{
+    libcmis_vector_property_Ptr properties = NULL;
+    if ( object != NULL && object->handle.get( ) != NULL )
+    {
+        PropertyPtrMap& handles = object->handle->getProperties( );
+        properties = new ( nothrow ) libcmis_vector_property( );
+        if ( properties )
+        {
+            int i = 0;
+            for ( PropertyPtrMap::iterator it = handles.begin( );
+                    it != handles.end( ); ++it, ++i )
+            {
+                properties->handle.push_back( it->second );
+            }
+        }
+    }
+    return properties;
+}
+
+
+libcmis_PropertyPtr libcmis_object_getProperty( libcmis_ObjectPtr object, const char* name )
+{
+    libcmis_PropertyPtr property = NULL;
+    if ( object != NULL && object->handle.get( ) != NULL )
+    {
+        PropertyPtrMap& handles = object->handle->getProperties( );
+        PropertyPtrMap::iterator it = handles.find( lcl_stdString( name ) );
+        if ( it != handles.end( ) )
+        {
+            property = new ( nothrow ) libcmis_property( );
+            if ( property )
+                property->handle = it->second;
+        }
+    }
+    return property;
+}
+
+
+libcmis_ObjectPtr libcmis_object_updateProperties(
+        libcmis_ObjectPtr object,
+        libcmis_vector_property_Ptr properties,
+        libcmis_ErrorPtr error )
+{
+    libcmis_ObjectPtr result = NULL;
+    if ( object != NULL && object->handle != NULL && properties != NULL )
+    {
+        try
+        {
+            // Build the map of changed properties
+            PropertyPtrMap propertiesMap = lcl_createPropertiesMap( properties );
+            libcmis::ObjectPtr handle = object->handle->updateProperties( propertiesMap );
+            result = new libcmis_object( );
+            result->handle = handle;
+        }
+        catch ( const libcmis::Exception& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->type = strdup( e.getType().c_str() );
+            }
+        }
+        catch ( const bad_alloc& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->badAlloc = true;
+            }
+        }
+    }
+    return result;
+}
+
+
+libcmis_ObjectTypePtr libcmis_object_getTypeDescription( libcmis_ObjectPtr object )
+{
+    libcmis_ObjectTypePtr result = NULL;
+    if ( object != NULL && object->handle.get( ) != NULL )
+    {
+        result = new ( nothrow ) libcmis_object_type( );
+        if ( result )
+            result->handle = object->handle->getTypeDescription( );
+    }
+    return result;
+}
+
+
+libcmis_AllowableActionsPtr libcmis_object_getAllowableActions( libcmis_ObjectPtr object )
+{
+    libcmis_AllowableActionsPtr result = NULL;
+    if ( object != NULL && object->handle.get( ) != NULL )
+    {
+        result = new ( nothrow ) libcmis_allowable_actions( );
+        if ( result )
+            result->handle = object->handle->getAllowableActions( );
+    }
+    return result;
+}
+
+
+void libcmis_object_refresh( libcmis_ObjectPtr object, libcmis_ErrorPtr error )
+{
+    if ( object != NULL && object->handle != NULL )
+    {
+        try
+        {
+            object->handle->refresh( );
+        }
+        catch ( const libcmis::Exception& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->type = strdup( e.getType().c_str() );
+            }
+        }
+    }
+}
+
+
+time_t libcmis_object_getRefreshTimestamp( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return object->handle->getRefreshTimestamp( );
+    else
+        return 0;
+}
+
+
+void libcmis_object_remove( libcmis_ObjectPtr object, bool allVersions, libcmis_ErrorPtr error )
+{
+    if ( object != NULL && object->handle != NULL )
+    {
+        try
+        {
+            object->handle->remove( allVersions );
+        }
+        catch ( const libcmis::Exception& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->type = strdup( e.getType().c_str() );
+            }
+        }
+    }
+}
+
+
+void libcmis_object_move( libcmis_ObjectPtr object,
+        libcmis_FolderPtr source,
+        libcmis_FolderPtr dest,
+        libcmis_ErrorPtr error )
+{
+    if ( object != NULL && object->handle != NULL )
+    {
+        try
+        {
+            libcmis::FolderPtr sourceHandle;
+            if ( source != NULL )
+                sourceHandle = dynamic_pointer_cast< libcmis::Folder >( source->handle );
+            libcmis::FolderPtr destHandle;
+            if ( dest != NULL )
+                destHandle = dynamic_pointer_cast< libcmis::Folder >( dest->handle );
+
+            object->handle->move( sourceHandle, destHandle );
+        }
+        catch ( const libcmis::Exception& e )
+        {
+            if ( error != NULL )
+            {
+                error->message = strdup( e.what() );
+                error->type = strdup( e.getType().c_str() );
+            }
+        }
+    }
+}
+
+
+char* libcmis_object_toString( libcmis_ObjectPtr object )
+{
+    if ( object != NULL && object->handle != NULL )
+        return strdup( object->handle->toString( ).c_str( ) );
+    else
+        return NULL;
+}