Adding upstream version 0.6.2.upstream/0.6.2upstream

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

1 files changed, 369 insertions, 0 deletions

diff --git a/src/libcmis-c/folder.cxx b/src/libcmis-c/folder.cxx
new file mode 100644
index 0000000..8d7555a
--- /dev/null
+++ b/src/libcmis-c/folder.cxx
@@ -0,0 +1,369 @@
+/* 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/folder.h>
+
+#include "internals.hxx"
+
+using namespace std;
+using libcmis::PropertyPtrMap;
+using libcmis::FolderPtr;
+using boost::dynamic_pointer_cast;
+
+void libcmis_vector_folder_free( libcmis_vector_folder_Ptr vector )
+{
+    delete vector;
+}
+
+
+size_t libcmis_vector_folder_size( libcmis_vector_folder_Ptr vector )
+{
+    size_t size = 0;
+    if ( vector != NULL )
+        size = vector->handle.size( );
+    return size;
+}
+
+
+libcmis_FolderPtr libcmis_vector_folder_get( libcmis_vector_folder_Ptr vector, size_t i )
+{
+    libcmis_FolderPtr item = NULL;
+    if ( vector != NULL && i < vector->handle.size( ) )
+    {
+        libcmis::FolderPtr handle = vector->handle[i];
+        item = new ( nothrow ) libcmis_folder( );
+        if ( item )
+            item->handle = handle;
+    }
+    return item;
+}
+
+
+bool libcmis_is_folder( libcmis_ObjectPtr object )
+{
+    bool isFolder = false;
+    if ( object != NULL && object->handle.get( ) != NULL )
+    {
+        libcmis::FolderPtr folder = boost::dynamic_pointer_cast< libcmis::Folder >( object->handle );
+        isFolder = folder.get( ) != NULL;
+    }
+    return isFolder;
+}
+
+
+libcmis_FolderPtr libcmis_folder_cast( libcmis_ObjectPtr object )
+{
+    libcmis_FolderPtr folder = NULL;
+
+    if ( object != NULL && object->handle.get( ) != NULL )
+    {
+        libcmis::FolderPtr handle = boost::dynamic_pointer_cast< libcmis::Folder >( object->handle );
+        if ( handle.get( ) != NULL )
+        {
+            folder = new ( nothrow ) libcmis_folder( );
+            if ( folder )
+                folder->handle = handle;
+        }
+    }
+
+    return folder;
+}
+
+
+void libcmis_folder_free( libcmis_FolderPtr folder )
+{
+    delete folder;
+}
+
+
+libcmis_FolderPtr libcmis_folder_getParent( libcmis_FolderPtr folder, libcmis_ErrorPtr error )
+{
+    libcmis_FolderPtr parent = NULL;
+    if ( folder != NULL && folder->handle.get( ) != NULL )
+    {
+        try
+        {
+            FolderPtr folderHandle = dynamic_pointer_cast< libcmis::Folder >( folder->handle );
+            if ( folder )
+            {
+                libcmis::FolderPtr handle = folderHandle->getFolderParent( );
+                if ( handle.get( ) != NULL )
+                {
+                    parent = new libcmis_folder( );
+                    parent->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 parent;
+}
+
+
+libcmis_vector_object_Ptr libcmis_folder_getChildren( libcmis_FolderPtr folder, libcmis_ErrorPtr error )
+{
+    libcmis_vector_object_Ptr result = NULL;
+    if ( folder != NULL && folder->handle.get( ) != NULL )
+    {
+        try
+        {
+            libcmis::FolderPtr folderHandle = dynamic_pointer_cast< libcmis::Folder >( folder->handle );
+            if ( folder )
+            {
+                std::vector< libcmis::ObjectPtr > handles = folderHandle->getChildren( );
+                result = new libcmis_vector_object( );
+                result->handle = handles;
+            }
+        }
+        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;
+}
+
+
+char* libcmis_folder_getPath( libcmis_FolderPtr folder )
+{
+    char* path = NULL;
+    if ( folder != NULL && folder->handle.get( ) != NULL )
+    {
+        libcmis::FolderPtr folderHandle = dynamic_pointer_cast< libcmis::Folder >( folder->handle );
+        if ( folder )
+            path = strdup( folderHandle->getPath( ).c_str( ) );
+    }
+    return path;
+}
+
+
+bool libcmis_folder_isRootFolder( libcmis_FolderPtr folder )
+{
+    bool isRoot = false;
+    if ( folder != NULL && folder->handle.get( ) != NULL )
+    {
+        libcmis::FolderPtr folderHandle = dynamic_pointer_cast< libcmis::Folder >( folder->handle );
+        if ( folder )
+            isRoot = folderHandle->isRootFolder( );
+    }
+    return isRoot;
+}
+
+libcmis_FolderPtr libcmis_folder_createFolder(
+        libcmis_FolderPtr folder,
+        libcmis_vector_property_Ptr properties,
+        libcmis_ErrorPtr error )
+{
+    libcmis_FolderPtr result = NULL;
+    if ( folder != NULL && folder->handle.get( ) != NULL )
+    {
+        libcmis::FolderPtr folderHandle = dynamic_pointer_cast< libcmis::Folder >( folder->handle );
+        if ( folder )
+        {
+            try
+            {
+                PropertyPtrMap mappedProperties;
+                if ( properties != NULL )
+                {
+                    size_t size = properties->handle.size( );
+                    for ( size_t i = 0; i < size; ++i )
+                    {
+                        libcmis::PropertyPtr property = properties->handle[i];
+                        if ( property.get( ) != NULL )
+                        {
+                            string id = property->getPropertyType( )->getId( );
+                            mappedProperties.insert( pair< string, libcmis::PropertyPtr >( id, property ) );
+                        }
+                    }
+                }
+
+                libcmis::FolderPtr handle = folderHandle->createFolder( mappedProperties );
+                result = new libcmis_folder( );
+                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_DocumentPtr libcmis_folder_createDocument(
+        libcmis_FolderPtr folder,
+        libcmis_vector_property_Ptr properties,
+        libcmis_readFn readFn,
+        void* userData,
+        const char* contentType,
+        const char* filename,
+        libcmis_ErrorPtr error )
+{
+    libcmis_DocumentPtr created = NULL;
+    if ( folder != NULL && folder->handle.get( ) != NULL )
+    {
+        libcmis::FolderPtr folderHandle = dynamic_pointer_cast< libcmis::Folder >( folder->handle );
+        if ( folder )
+        {
+            try
+            {
+                // Create the ostream
+                boost::shared_ptr< std::ostream > stream( new stringstream( ) );
+
+                size_t bufSize = 2048;
+                char* buf = new char[ bufSize ];
+                size_t read = 0;
+                do
+                {
+                    read = readFn( ( void * )buf, size_t( 1 ), bufSize, userData );
+                    stream->write( buf, read );
+                } while ( read == bufSize );
+                delete[] buf;
+
+                // Create the property map
+                PropertyPtrMap propertiesMap;
+                if ( properties != NULL )
+                {
+                    for ( vector< libcmis::PropertyPtr >::iterator it = properties->handle.begin( );
+                            it != properties->handle.end( ); ++it )
+                    {
+                        string id = ( *it )->getPropertyType( )->getId( );
+                        propertiesMap.insert( pair< string, libcmis::PropertyPtr >( id, *it ) );
+                    }
+                }
+
+                libcmis::DocumentPtr handle = folderHandle->createDocument( propertiesMap, stream, contentType, filename );
+                created = new libcmis_document( );
+                created->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;
+                }
+            }
+            catch ( const exception& e )
+            {
+                if ( error != NULL )
+                    error->message = strdup( e.what() );
+            }
+        }
+    }
+    return created;
+}
+
+
+libcmis_vector_string_Ptr libcmis_folder_removeTree( libcmis_FolderPtr folder,
+        bool allVersion,
+        libcmis_folder_UnfileObjects unfile,
+        bool continueOnError,
+        libcmis_ErrorPtr error )
+{
+    libcmis_vector_string_Ptr failed = NULL;
+    try
+    {
+        failed = new libcmis_vector_string( );
+        if ( folder != NULL && folder->handle.get( ) != NULL )
+        {
+            libcmis::FolderPtr folderHandle = dynamic_pointer_cast< libcmis::Folder >( folder->handle );
+            if ( folder )
+            {
+                vector< string > handle = folderHandle->removeTree( allVersion,
+                        libcmis::UnfileObjects::Type( unfile ), continueOnError );
+                failed->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 failed;
+}