2 commits - c++/CMakeLists.txt c++/lib c++/tests schemas/kolabformat-xcard.xsd schemas/xCard.xsd

Christian Mollekopf mollekopf at kolabsys.com
Mon Mar 19 18:23:09 CET 2012


 c++/CMakeLists.txt            |   16 +-
 c++/lib/CMakeLists.txt        |   19 +-
 c++/lib/kolabcontact.cpp      |   12 +
 c++/lib/kolabcontact.h        |  163 +++++++++++------------
 c++/lib/kolabcontainers.h     |    6 
 c++/lib/php/CMakeLists.txt    |    2 
 c++/lib/python/CMakeLists.txt |    2 
 c++/lib/shared_conversions.h  |    4 
 c++/lib/xcardconversions.h    |  297 +++++++++++++++++++++++++-----------------
 c++/tests/bindingstest.cpp    |   25 ++-
 c++/tests/conversiontest.cpp  |    2 
 c++/tests/serializers.h       |   32 ++--
 schemas/kolabformat-xcard.xsd |    1 
 schemas/xCard.xsd             |   14 +
 14 files changed, 346 insertions(+), 249 deletions(-)

New commits:
commit dc57d97e688ec6be842dfc7f01f569c223c8c06d
Author: Christian Mollekopf <mollekopf at kolabsys.com>
Date:   Mon Mar 19 18:15:14 2012 +0100

    Cleaned up dependencies

diff --git a/c++/CMakeLists.txt b/c++/CMakeLists.txt
index 2e70a9b..f7f3026 100644
--- a/c++/CMakeLists.txt
+++ b/c++/CMakeLists.txt
@@ -69,9 +69,15 @@ set( SCHEMA_DIR ${CMAKE_SOURCE_DIR}/../schemas )
 
 # Generate bindings
 
-file(GLOB XCAL_SCHEMAS ${SCHEMA_DIR}/ical/*.xsd)
-file(GLOB SCHEMAS ${SCHEMA_DIR}/*.xsd)
-set( SCHEMAS ${SCHEMAS} ${XCAL_SCHEMAS})
+set( SCHEMAS
+    ${SCHEMA_DIR}/ical/kolabformat-xcal.xsd
+    ${SCHEMA_DIR}/ical/iCalendar-params.xsd
+    ${SCHEMA_DIR}/ical/iCalendar-props.xsd
+    ${SCHEMA_DIR}/ical/iCalendar-valtypes.xsd
+    ${SCHEMA_DIR}/xCard.xsd
+    ${SCHEMA_DIR}/kolabformat-xcard.xsd
+    ${SCHEMA_DIR}/kolabformat.xsd
+)
 
 set( SCHEMA_SOURCEFILES  
     ${CMAKE_BUILD_DIR}/bindings/kolabformat.cxx
@@ -101,8 +107,10 @@ add_custom_command(OUTPUT ${SCHEMA_SOURCEFILES}
 add_executable(xsdbin compiled/xsdbin.cxx)
 target_link_libraries(xsdbin ${XERCES_C})
 
+
+
 add_custom_command(OUTPUT kolabformat-xcal-schema.cxx
-    COMMAND ${CMAKE_BUILD_DIR}/xsdbin --verbose --array-name iCalendar_schema --output-dir ${CMAKE_BUILD_DIR}   ${SCHEMA_DIR}/ical/kolabformat-xcal.xsd ${SCHEMA_DIR}/ical/iCalendar-params.xsd ${SCHEMA_DIR}/ical/iCalendar-props.xsd ${SCHEMA_DIR}/ical/iCalendar-valtypes.xsd ${SCHEMA_DIR}/xCard.xsd ${SCHEMA_DIR}/kolabformat-xcard.xsd ${SCHEMA_DIR}/kolabformat.xsd
+    COMMAND ${CMAKE_BUILD_DIR}/xsdbin --verbose --array-name iCalendar_schema --output-dir ${CMAKE_BUILD_DIR} ${SCHEMAS}
     COMMENT "Compiling Kolab XSD schema"
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
     DEPENDS ${SCHEMAS} xsdbin
diff --git a/c++/lib/CMakeLists.txt b/c++/lib/CMakeLists.txt
index 0e34045..ac961a8 100644
--- a/c++/lib/CMakeLists.txt
+++ b/c++/lib/CMakeLists.txt
@@ -14,15 +14,15 @@ set_target_properties(kolabxml PROPERTIES VERSION 3.0.0 SOVERSION 0)
 install(TARGETS kolabxml LIBRARY DESTINATION lib)
 
 install( FILES
-  kolabformat.h
-  kolabevent.h
-  kolabtodo.h
-  kolabjournal.h
-  kolabcontact.h
-  kolabnote.h
-  kolabcontainers.h
-  global_definitions.h
-  DESTINATION include/kolab COMPONENT Devel)
+    kolabformat.h
+    kolabevent.h
+    kolabtodo.h
+    kolabjournal.h
+    kolabcontact.h
+    kolabnote.h
+    kolabcontainers.h
+    global_definitions.h
+    DESTINATION include/kolab COMPONENT Devel)
 
 #----- The following makes sure libkolabxml is found in the install directory for installed files and not in the build directory (for libraries which link to libkolabxml)
 
@@ -64,7 +64,6 @@ endif()
 #-----------------------SWIG--------------------
 
 if (SWIG_FOUND)
-    set(KOLAB_CONTAINER_HEADERS ../kolabcontainers.h ../kolabevent.h ../kolabtodo.h)
     add_subdirectory(python)
     add_subdirectory(php)
 else()
diff --git a/c++/lib/php/CMakeLists.txt b/c++/lib/php/CMakeLists.txt
index 702fd32..2d95c36 100644
--- a/c++/lib/php/CMakeLists.txt
+++ b/c++/lib/php/CMakeLists.txt
@@ -6,7 +6,7 @@ add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${KOLAB_SWIG_PHP_SOURCE_FI
     COMMAND ${SWIG} -v -c++ -php -o ${CMAKE_CURRENT_BINARY_DIR}/${KOLAB_SWIG_PHP_SOURCE_FILE}  ../kolabformat.i
     COMMENT "Generating php bindings"
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    DEPENDS ../kolabformat.i ${KOLAB_CONTAINER_HEADERS}
+    DEPENDS ../kolabformat.i kolabxml
     VERBATIM
     )
 SET_SOURCE_FILES_PROPERTIES(${KOLAB_SWIG_PHP_SOURCE_FILE} PROPERTIES GENERATED 1)
diff --git a/c++/lib/python/CMakeLists.txt b/c++/lib/python/CMakeLists.txt
index 217be18..397405c 100644
--- a/c++/lib/python/CMakeLists.txt
+++ b/c++/lib/python/CMakeLists.txt
@@ -6,7 +6,7 @@ add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${KOLAB_SWIG_PYTHON_SOURCE
     COMMAND ${SWIG} -v -c++ -python -o ${CMAKE_CURRENT_BINARY_DIR}/${KOLAB_SWIG_PYTHON_SOURCE_FILE} ../kolabformat.i
     COMMENT "Generating python bindings"
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    DEPENDS ../kolabformat.i ${KOLAB_CONTAINER_HEADERS}
+    DEPENDS ../kolabformat.i kolabxml
     VERBATIM
     )
 


commit 382aff3fff8b77d4c9deff9e41c4fa357acfb35c
Author: Christian Mollekopf <mollekopf at kolabsys.com>
Date:   Mon Mar 19 18:05:22 2012 +0100

    Restructured the Affiliation property according to the KEP changes.

diff --git a/c++/lib/kolabcontact.cpp b/c++/lib/kolabcontact.cpp
index 9bd26aa..eaa2ab8 100644
--- a/c++/lib/kolabcontact.cpp
+++ b/c++/lib/kolabcontact.cpp
@@ -133,6 +133,7 @@ struct Contact::Private
     NameComponents nameComponents;
     std::string note;
     std::string freeBusyUrl;
+    std::vector< std::string > titles;
     std::vector<Affiliation> affiliations;
     std::vector<std::string> urls;
     std::vector<Address> addresses;
@@ -258,6 +259,17 @@ std::string Contact::freeBusyUrl() const
     return d->freeBusyUrl;
 }
 
+void Contact::setTitles(const std::vector< std::string >& titles)
+{
+    d->titles = titles;
+}
+
+std::vector< std::string > Contact::titles() const
+{
+    return d->titles;
+}
+
+
 void Contact::setAffiliations(const std::vector< Affiliation > &a)
 {
     d->affiliations = a;
diff --git a/c++/lib/kolabcontact.h b/c++/lib/kolabcontact.h
index 2b2b63f..bf365fb 100644
--- a/c++/lib/kolabcontact.h
+++ b/c++/lib/kolabcontact.h
@@ -51,68 +51,68 @@ private:
     std::vector<std::string> mSuffixes;
 };
 
-struct Affiliation {
-    bool operator==(const Affiliation &other) const { return mOrg == other.mOrg &&
-                                                    mOrgUnits == other.mOrgUnits &&
-                                                    mLogo == other.mLogo &&
-                                                    mLogoMimetype == other.mLogoMimetype &&
-                                                    mTitles == other.mTitles &&
-                                                    mRoles == other.mRoles &&
-                                                    mManagers == other.mManagers &&
-                                                    mAssistants == other.mAssistants &&
-                                                    mOffices == other.mOffices;
-                                                    };
-    void setOrganisation(const std::string &org) { mOrg = org; };
-    std::string organisation() const { return mOrg; };
-    void setOrganisationalUnits(const std::vector<std::string> &units) { mOrgUnits = units; };
-    std::vector<std::string> organisationalUnits() const { return mOrgUnits; };
-    void setLogo(const std::string &l, const std::string mimetype) { mLogo = l; mLogoMimetype = mimetype; };
-    std::string logo() const { return mLogo; };
-    std::string logoMimetype() const { return mLogoMimetype; };
-
-    void setTitles(const std::vector<std::string> &titles) { mTitles = titles; };
-    std::vector<std::string> titles() const { return mTitles; };
-    void setRoles(const std::vector<std::string> &roles) { mRoles = roles; };
-    std::vector<std::string> roles() const { return mRoles; };
-    void setManagers(const std::vector<std::string> &managers) { mManagers = managers; };
-    std::vector<std::string> managers() const { return mManagers; };
-    void setAssistants(const std::vector<std::string> &assistants) { mAssistants = assistants; };
-    std::vector<std::string> assistants() const { return mAssistants; };
-    void setOffices(const std::vector<std::string> &offices) { mOffices = offices; };
-    std::vector<std::string> offices() const { return mOffices; };
+struct Related {
+    
+    enum DescriptionType {
+        Invalid,
+        Text,
+        Uid
+    };
+    Related(): mType(Invalid), mRelationType(NoRelation) {};
+    Related(DescriptionType t, const std::string &textOrUri, int relationType = NoRelation)
+    :   mType(t), mRelationType(relationType)
+    {
+        if (t == Text) {
+            mText = textOrUri;
+        } else {
+            mUri = textOrUri;
+        }
+    };
+    bool operator==(const Related &other) const { return mType == other.mType &&
+    mUri == other.mUri &&
+    mText == other.mText &&
+    mRelationType == other.mRelationType;
+    };
+    DescriptionType type() const { return mType; };
+    std::string uri() const { return mUri; };
+    std::string text() const { return mText; };
+    enum RelationType {
+        NoRelation = 0,
+        Child = 0x01,
+        Spouse = 0x02,
+        Manager = 0x04,
+        Assistant = 0x08,
+    };
+    void setRelationTypes(int t) { mRelationType = t; };
+    int relationTypes() const { return mRelationType; };
 private:
-    std::string mOrg;
-    std::vector<std::string> mOrgUnits;
-    std::string mLogo;
-    std::string mLogoMimetype;
-    std::vector<std::string> mTitles;
-    std::vector<std::string> mRoles;
-    std::vector<std::string> mManagers;
-    std::vector<std::string> mAssistants;
-    std::vector<std::string> mOffices;
+    DescriptionType mType;
+    std::string mUri;
+    std::string mText;
+    int mRelationType;
 };
 
 struct Address {
-
+    
     Address(): mTypes(0) {};
     enum Type {
         Work = 0x01,
         Home = 0x02
     };
     bool operator==(const Address &other) const { return mTypes == other.mTypes &&
-                                                    mLabel == other.mLabel &&
-                                                    mStreet == other.mStreet &&
-                                                    mLocality == other.mLocality &&
-                                                    mRegion == other.mRegion &&
-                                                    mCode == other.mCode &&
-                                                    mCountry == other.mCountry;
-                                                    };
+    mLabel == other.mLabel &&
+    mStreet == other.mStreet &&
+    mLocality == other.mLocality &&
+    mRegion == other.mRegion &&
+    mCode == other.mCode &&
+    mCountry == other.mCountry;
+    };
     void setTypes(int t) { mTypes = t; };
     int types() const { return mTypes; };
-
+    
     void setLabel(const std::string &s) { mLabel = s; };
     std::string label() const { return mLabel; }
-
+    
     void setStreet(const std::string &s) { mStreet = s; };
     std::string street() const { return mStreet; };
     
@@ -137,43 +137,37 @@ private:
     std::string mCountry;
 };
 
-struct Related {
+struct Affiliation {
+    bool operator==(const Affiliation &other) const { return mOrg == other.mOrg &&
+                                                    mOrgUnits == other.mOrgUnits &&
+                                                    mLogo == other.mLogo &&
+                                                    mLogoMimetype == other.mLogoMimetype &&
+                                                    mRoles == other.mRoles &&
+                                                    mRelateds == other.mRelateds &&
+                                                    mOffices == other.mOffices;
+                                                    };
+    void setOrganisation(const std::string &org) { mOrg = org; };
+    std::string organisation() const { return mOrg; };
+    void setOrganisationalUnits(const std::vector<std::string> &units) { mOrgUnits = units; };
+    std::vector<std::string> organisationalUnits() const { return mOrgUnits; };
+    void setLogo(const std::string &l, const std::string mimetype) { mLogo = l; mLogoMimetype = mimetype; };
+    std::string logo() const { return mLogo; };
+    std::string logoMimetype() const { return mLogoMimetype; };
 
-    enum DescriptionType {
-        Invalid,
-        Text,
-        Urn
-    };
-    Related(): mType(Invalid), mRelationType(NoRelation) {};
-    Related(DescriptionType t, const std::string &textOrUri)
-    :   mType(t), mRelationType(NoRelation)
-    {
-        if (t == Text) {
-            mText = textOrUri;
-        } else {
-            mUri = textOrUri;
-        }
-    };
-    bool operator==(const Related &other) const { return mType == other.mType &&
-                                                    mUri == other.mUri &&
-                                                    mText == other.mText &&
-                                                    mRelationType == other.mRelationType;
-    };
-    DescriptionType type() const { return mType; };
-    std::string uri() const { return mUri; };
-    std::string text() const { return mText; };
-    enum RelationType {
-        NoRelation = 0,
-        Child = 0x01,
-        Spouse = 0x02
-    };
-    void setRelationTypes(int t) { mRelationType = t; };
-    int relationTypes() const { return mRelationType; };
+    void setRoles(const std::vector<std::string> &roles) { mRoles = roles; };
+    std::vector<std::string> roles() const { return mRoles; };
+    void setRelateds(const std::vector<Related> &relateds) { mRelateds = relateds; };
+    std::vector<Related> relateds() const { return mRelateds; };
+    void setAddresses(const std::vector<Address> &offices) { mOffices = offices; };
+    std::vector<Address> addresses() const { return mOffices; };
 private:
-    DescriptionType mType;
-    std::string mUri;
-    std::string mText;
-    int mRelationType;
+    std::string mOrg;
+    std::vector<std::string> mOrgUnits;
+    std::string mLogo;
+    std::string mLogoMimetype;
+    std::vector<std::string> mRoles;
+    std::vector<Related> mRelateds;
+    std::vector<Address> mOffices;
 };
 
 struct Telephone {
@@ -303,6 +297,9 @@ public:
     void setFreeBusyUrl(const std::string &);
     std::string freeBusyUrl() const;
     
+    void setTitles(const std::vector<std::string> &titles);
+    std::vector<std::string> titles() const;
+    
     void setAffiliations(const std::vector<Affiliation> &);
     std::vector<Affiliation> affiliations() const;
     
diff --git a/c++/lib/kolabcontainers.h b/c++/lib/kolabcontainers.h
index 50a74d2..cd577b7 100644
--- a/c++/lib/kolabcontainers.h
+++ b/c++/lib/kolabcontainers.h
@@ -171,9 +171,13 @@ struct ContactReference {
     enum ReferenceType {
         Invalid,
         EmailReference,
-        UrnReference
+        UidReference,
+        EmailAndUidReference
     };
     ContactReference(): mType(Invalid) {};
+    ///For xCal
+    ContactReference(const std::string &email, const std::string &name = std::string(), const std::string &uid = std::string()): mType(EmailAndUidReference), mEmail(email), mUid(uid), mName(name) {};
+    ///For xCard
     ContactReference(ReferenceType type, const std::string &emailOrUID, const std::string &name = std::string()): mType(type), mName(name) { 
         if (type == EmailReference) {
             mEmail = emailOrUID;
diff --git a/c++/lib/shared_conversions.h b/c++/lib/shared_conversions.h
index 6602e22..948e836 100644
--- a/c++/lib/shared_conversions.h
+++ b/c++/lib/shared_conversions.h
@@ -89,7 +89,7 @@ std::string fromURN(const std::string &uri)
 Kolab::ContactReference toContactReference(const std::string &uri) {
     std::string name;
     if (uri.substr(0, 9) == std::string("urn:uuid:")) {
-        return Kolab::ContactReference(Kolab::ContactReference::UrnReference, fromURN(uri));
+        return Kolab::ContactReference(Kolab::ContactReference::UidReference, fromURN(uri));
     }
     const std::string &email = fromMailto(uri, name);
     return Kolab::ContactReference(Kolab::ContactReference::EmailReference, email, name);
@@ -97,7 +97,7 @@ Kolab::ContactReference toContactReference(const std::string &uri) {
 
 std::string fromContactReference(const Kolab::ContactReference &c, bool embeddName = true) {
     switch (c.type()) {
-        case ContactReference::UrnReference:
+        case ContactReference::UidReference:
             return toURN(c.uid());
         case ContactReference::EmailReference:
             if (embeddName) {
diff --git a/c++/lib/xcardconversions.h b/c++/lib/xcardconversions.h
index 1f9d094..52b1b5e 100644
--- a/c++/lib/xcardconversions.h
+++ b/c++/lib/xcardconversions.h
@@ -260,6 +260,150 @@ Kolab::Crypto::CryptoPref toCryptoPref(vcard_4_0::PrefTypeValueType pref)
     return Kolab::Crypto::Ask;
 }
 
+vcard_4_0::relatedPropType fromRelated(const Kolab::Related &r)
+{
+    using namespace vcard_4_0;
+    vcard_4_0::relatedPropType related;
+    if (r.type() == Kolab::Related::Uid) {
+        related.uri(r.uri());
+    } else {
+        related.text(r.text());
+    }
+    if (r.relationTypes() != Kolab::Related::NoRelation) {
+        
+        vcard::adr_type::parameters_type::baseParameter_sequence base;
+        vcard::adr_type::parameters_type b;
+        
+        vcard_4_0::typeParamType::text_sequence seq;
+        if (r.relationTypes() & Kolab::Related::Child) {
+            seq.push_back(TypeValueType::child);
+        }
+        if (r.relationTypes() & Kolab::Related::Spouse) {
+            seq.push_back(TypeValueType::spouse);
+        }
+        if (r.relationTypes() & Kolab::Related::Assistant) {
+            seq.push_back(TypeValueType::x_assistant);
+        }
+        if (r.relationTypes() & Kolab::Related::Manager) {
+            seq.push_back(TypeValueType::x_manager);
+        }
+        if (!seq.empty()) {
+            vcard_4_0::typeParamType type;
+            type.text(seq);
+            b.baseParameter().push_back(type);
+        }
+        
+        related.parameters(b);
+    }
+    
+    return related;
+}
+
+Kolab::Related toRelated(const vcard_4_0::relatedPropType &r)
+{
+    Kolab::Related::DescriptionType type;
+    std::string textOrUri;
+    if (r.uri()) {
+        type = Kolab::Related::Uid;
+        textOrUri = *r.uri();
+    } else if (r.text()) {
+        type = Kolab::Related::Text;
+        textOrUri = *r.text();
+    } else {
+        ERROR("no text and no uri");
+    }
+    Kolab::Related related(type, textOrUri);
+    if (r.parameters()) {
+        BOOST_FOREACH(const vcard_4_0::ArrayOfParameters::baseParameter_type &param, (*r.parameters()).baseParameter()) {
+            if (const vcard_4_0::typeParamType *rel = dynamic_cast<const vcard_4_0::typeParamType*> (&param)) {
+                int types = 0;
+                BOOST_FOREACH(const std::string &s, rel->text()) {
+                    if (s == vcard_4_0::TypeValueType(vcard_4_0::TypeValueType::child)) {
+                        types |= Kolab::Related::Child;
+                    }
+                    if (s == vcard_4_0::TypeValueType(vcard_4_0::TypeValueType::spouse)) {
+                        types |= Kolab::Related::Spouse;
+                    }
+                    if (s == vcard_4_0::TypeValueType(vcard_4_0::TypeValueType::x_assistant)) {
+                        types |= Kolab::Related::Assistant;
+                    }
+                    if (s == vcard_4_0::TypeValueType(vcard_4_0::TypeValueType::x_manager)) {
+                        types |= Kolab::Related::Manager;
+                    }
+                }
+                related.setRelationTypes(types);
+            } 
+        }
+    }
+    return related;
+}
+
+vcard_4_0::vcard::adr_type fromAddress(const Kolab::Address &address)
+{
+    using namespace vcard_4_0;
+    vcard::adr_type a(vcard::adr_type::pobox_type(std::string()/*address.pobox()*/), 
+                      vcard::adr_type::ext_type(std::string()/*address.ext()*/),
+                                                vcard::adr_type::street_type(address.street()),
+                                                vcard::adr_type::locality_type(address.locality()),
+                                                vcard::adr_type::region_type(address.region()),
+                                                address.code(),
+                                                vcard::adr_type::country_type(address.country())
+                      );
+    vcard::adr_type::parameters_type b;
+    if (address.types()) {
+        vcard_4_0::typeParamType::text_sequence seq;
+        if (address.types() & Kolab::Address::Home) {
+            seq.push_back(TypeValueType::home);
+        }
+        if (address.types() & Kolab::Address::Work) {
+            seq.push_back(TypeValueType::work);
+        }
+        if (!seq.empty()) {
+            vcard_4_0::typeParamType type;
+            type.text(seq);
+            b.baseParameter().push_back(type);
+        }
+    }
+    if (!address.label().empty()) {
+        b.baseParameter().push_back(vcard_4_0::labelParamType(address.label()));
+    }
+    a.parameters(b);
+    return a;
+}
+
+Kolab::Address toAddress(const vcard_4_0::vcard::adr_type &adr, bool *isPreferred = 0)
+{
+    using namespace vcard_4_0;
+    Address address;
+    if (adr.parameters()) {
+        BOOST_FOREACH(const vcard_4_0::ArrayOfParameters::baseParameter_type &param, (*adr.parameters()).baseParameter()) {
+            if (const vcard_4_0::labelParamType *rel = dynamic_cast<const vcard_4_0::labelParamType*> (&param)) {
+                address.setLabel(rel->text());
+            } else if (isPreferred && dynamic_cast<const vcard_4_0::prefParamType*> (&param)) {
+                *isPreferred = true;
+            } else if (const vcard_4_0::typeParamType *rel = dynamic_cast<const vcard_4_0::typeParamType*> (&param)) {
+                int types = 0;
+                BOOST_FOREACH(const std::string &s, rel->text()) {
+                    if (s == TypeValueType(TypeValueType::work)) {
+                        types |= Kolab::Telephone::Work;
+                    }
+                    if (s == TypeValueType(TypeValueType::home)) {
+                        types |= Kolab::Telephone::Home;
+                    }
+                }
+                address.setTypes(types);
+            } 
+        }
+    }
+    
+    address.setCode(adr.code());
+    address.setCountry(adr.country());
+    address.setLocality(adr.locality());
+    address.setRegion(adr.region());
+    address.setStreet(adr.street());
+    return address;
+}
+
 template <typename T> 
 void writeCard(vcard_4_0::vcard &vcard, const T &);
 
@@ -309,11 +453,15 @@ void writeCard<Kolab::Contact>(vcard_4_0::vcard &vcard, const Kolab::Contact &co
             if (!a.logo().empty()) {
                 group.logo(affiliationPropType::logo_type(uriInlineEncoding(a.logo(), a.logoMimetype())));
             }
-            group.title(fromList<affiliationPropType::title_type >(a.titles()));
+//             group.title(fromList<affiliationPropType::title_type >(a.titles()));
             group.role(fromList<affiliationPropType::role_type>(a.roles()));
-            group.x_manager(fromList<affiliationPropType::x_manager_type>(a.managers()));
-            group.x_assistant(fromList<affiliationPropType::x_assistant_type >(a.assistants()));
-            group.x_office(fromList<affiliationPropType::x_office_type>(a.offices()));
+            BOOST_FOREACH(const Related &rel, a.relateds()) {
+                group.related().push_back(fromRelated(rel));
+            }
+            BOOST_FOREACH(const Address &adr, a.addresses()) {
+                group.adr().push_back(fromAddress(adr));
+            }
+
             affiliations.push_back(group);
         }
         vcard.group(affiliations);
@@ -327,39 +475,17 @@ void writeCard<Kolab::Contact>(vcard_4_0::vcard &vcard, const Kolab::Contact &co
         vcard::adr_sequence adrs;
         int index = 0;
         BOOST_FOREACH(const Kolab::Address &address, contact.addresses()) {
-            index++;
-            vcard::adr_type a(vcard::adr_type::pobox_type(std::string()/*address.pobox()*/), 
-                            vcard::adr_type::ext_type(std::string()/*address.ext()*/),
-                            vcard::adr_type::street_type(address.street()),
-                            vcard::adr_type::locality_type(address.locality()),
-                            vcard::adr_type::region_type(address.region()),
-                            address.code(),
-                            vcard::adr_type::country_type(address.country())
-            );
-            vcard::adr_type::parameters_type::baseParameter_sequence base;
-            vcard::adr_type::parameters_type b;
-            if (address.types()) {
-                vcard_4_0::typeParamType::text_sequence seq;
-                if (address.types() & Kolab::Address::Home) {
-                    seq.push_back(TypeValueType::home);
-                }
-                if (address.types() & Kolab::Address::Work) {
-                    seq.push_back(TypeValueType::work);
-                }
-                if (!seq.empty()) {
-                    vcard_4_0::typeParamType type;
-                    type.text(seq);
-                    b.baseParameter().push_back(type);
-                }
-            }
-            if (!address.label().empty()) {
-                b.baseParameter().push_back(vcard_4_0::labelParamType(address.label()));
-            }
+            vcard::adr_type a = fromAddress(address);
             if(contact.addressPreferredIndex() == index) {
-                b.baseParameter().push_back(vcard_4_0::prefParamType(vcard_4_0::prefParamType::integer_default_value()));
+                if (a.parameters()) {
+                    (*a.parameters()).baseParameter().push_back(vcard_4_0::prefParamType(vcard_4_0::prefParamType::integer_default_value()));
+                } else {
+                    vcard::adr_type::parameters_type b;
+                    b.baseParameter().push_back(vcard_4_0::prefParamType(vcard_4_0::prefParamType::integer_default_value()));
+                    a.parameters(b);
+                }
             }
             index++;
-            a.parameters(b);
             adrs.push_back(a);
         }
         vcard.adr(adrs);
@@ -378,33 +504,7 @@ void writeCard<Kolab::Contact>(vcard_4_0::vcard &vcard, const Kolab::Contact &co
     if (!contact.relateds().empty()) {
         vcard::related_sequence seq;
         BOOST_FOREACH(const Kolab::Related &r, contact.relateds()) {
-            vcard_4_0::vcard::related_type related;
-            if (!r.uri().empty()) {
-                related.uri(r.uri());
-            } else {
-                related.text(r.text());
-            }
-            if (r.relationTypes() != Kolab::Related::NoRelation) {
-                
-                vcard::adr_type::parameters_type::baseParameter_sequence base;
-                vcard::adr_type::parameters_type b;
-
-                vcard_4_0::typeParamType::text_sequence seq;
-                if (r.relationTypes() & Kolab::Related::Child) {
-                    seq.push_back(TypeValueType::child);
-                }
-                if (r.relationTypes() & Kolab::Related::Spouse) {
-                    seq.push_back(TypeValueType::spouse);
-                }
-                if (!seq.empty()) {
-                    vcard_4_0::typeParamType type;
-                    type.text(seq);
-                    b.baseParameter().push_back(type);
-                }
-
-                related.parameters(b);
-            }
-            seq.push_back(related);
+            seq.push_back(fromRelated(r));
         }
         vcard.related(seq);
     }
@@ -655,11 +755,18 @@ boost::shared_ptr<Kolab::Contact> readCard <Kolab::Contact> (const vcard_4_0::Vc
                 const std::string &logo = uriInlineDecoding((*group.logo()).uri(), mimetype);
                 aff.setLogo(logo, mimetype);
             }
-            aff.setTitles(toTextList<vcard::group_type::title_type>(group.title()));
+//             aff.setTitles(toTextList<vcard::group_type::title_type>(group.title()));
             aff.setRoles(toTextList<vcard::group_type::role_type>(group.role()));
-            aff.setManagers(toTextList<vcard::group_type::x_manager_type>(group.x_manager()));
-            aff.setAssistants(toTextList<vcard::group_type::x_assistant_type>(group.x_assistant()));
-            aff.setOffices(toTextList<vcard::group_type::x_office_type>(group.x_office()));
+            std::vector<Related> relateds;
+            BOOST_FOREACH(const vcard::group_type::related_type &rel, group.related()) {
+                relateds.push_back(toRelated(rel));
+            }
+            aff.setRelateds(relateds);
+            std::vector<Address> addresses;
+            BOOST_FOREACH(const vcard::group_type::adr_type &adr, group.adr()) {
+                addresses.push_back(toAddress(adr));
+            }
+            aff.setAddresses(addresses);
             list.push_back(aff);
         }
         contact->setAffiliations(list);
@@ -672,34 +779,12 @@ boost::shared_ptr<Kolab::Contact> readCard <Kolab::Contact> (const vcard_4_0::Vc
         int preferredIndex = -1;
         int index = 0;
         BOOST_FOREACH(const vcard::adr_type &adr, vcard.adr()) {
-            Kolab::Address address;
-            if (adr.parameters()) {
-                BOOST_FOREACH(const vcard_4_0::ArrayOfParameters::baseParameter_type &param, (*adr.parameters()).baseParameter()) {
-                    if (const vcard_4_0::labelParamType *rel = dynamic_cast<const vcard_4_0::labelParamType*> (&param)) {
-                        address.setLabel(rel->text());
-                    } else if (dynamic_cast<const vcard_4_0::prefParamType*> (&param)) {
-                        preferredIndex = index;
-                    } else if (const vcard_4_0::typeParamType *rel = dynamic_cast<const vcard_4_0::typeParamType*> (&param)) {
-                        int types = 0;
-                        BOOST_FOREACH(const std::string &s, rel->text()) {
-                            if (s == TypeValueType(TypeValueType::work)) {
-                                types |= Kolab::Telephone::Work;
-                            }
-                            if (s == TypeValueType(TypeValueType::home)) {
-                                types |= Kolab::Telephone::Home;
-                            }
-                        }
-                        address.setTypes(types);
-                    } 
-                }
+            bool isPreferred = false;
+            const Kolab::Address &address = toAddress(adr, &isPreferred);
+            if (isPreferred) {
+                preferredIndex = index;
             }
             index++;
-
-            address.setCode(adr.code());
-            address.setCountry(adr.country());
-            address.setLocality(adr.locality());
-            address.setRegion(adr.region());
-            address.setStreet(adr.street());
             list.push_back(address);
         }
         contact->setAddresses(list, preferredIndex);
@@ -710,35 +795,7 @@ boost::shared_ptr<Kolab::Contact> readCard <Kolab::Contact> (const vcard_4_0::Vc
     if (!vcard.related().empty()) {
         std::vector<Related> list;
         BOOST_FOREACH(const vcard_4_0::vcard::related_type &r, vcard.related()) {
-            Kolab::Related::DescriptionType type;
-            std::string textOrUri;
-            if (r.uri()) {
-                type = Kolab::Related::Urn;
-                textOrUri = *r.uri();
-            } else if (r.text()) {
-                type = Kolab::Related::Text;
-                textOrUri = *r.text();
-            } else {
-                ERROR("no text and no uri");
-            }
-            Kolab::Related related(type, textOrUri);
-            if (r.parameters()) {
-                BOOST_FOREACH(const vcard_4_0::ArrayOfParameters::baseParameter_type &param, (*r.parameters()).baseParameter()) {
-                    if (const vcard_4_0::typeParamType *rel = dynamic_cast<const vcard_4_0::typeParamType*> (&param)) {
-                        int types = 0;
-                        BOOST_FOREACH(const std::string &s, rel->text()) {
-                            if (s == TypeValueType(TypeValueType::child)) {
-                                types |= Kolab::Related::Child;
-                            }
-                            if (s == TypeValueType(TypeValueType::spouse)) {
-                                types |= Kolab::Related::Spouse;
-                            }
-                        }
-                        related.setRelationTypes(types);
-                    } 
-                }
-            }
-            list.push_back(related);
+            list.push_back(toRelated(r));
         }
         contact->setRelateds(list);
     }
diff --git a/c++/tests/bindingstest.cpp b/c++/tests/bindingstest.cpp
index 5aece5c..a33f359 100644
--- a/c++/tests/bindingstest.cpp
+++ b/c++/tests/bindingstest.cpp
@@ -355,7 +355,7 @@ void BindingsTest::contactCompletness()
     Kolab::Related r1(Kolab::Related::Text, "text");
     r1.setRelationTypes(Kolab::Related::Child);
     relateds.push_back(r1);
-    Kolab::Related r2(Kolab::Related::Urn, "urn");
+    Kolab::Related r2(Kolab::Related::Uid, "urn");
     r2.setRelationTypes(Kolab::Related::Child|Kolab::Related::Spouse);
     relateds.push_back(r2);
     c.setRelateds(relateds);
@@ -367,16 +367,27 @@ void BindingsTest::contactCompletness()
     c.setLanguages(stringlist);
     c.setIMaddresses(stringlist,1);
     c.setEmailAddresses(stringlist,1);
+    c.setTitles(stringlist);
+    
     std::vector<Kolab::Affiliation> list;
     Kolab::Affiliation aff;
     aff.setOrganisation("org");
     aff.setOrganisationalUnits(stringlist);
     aff.setLogo("logo", "mime/miem");
-    aff.setTitles(stringlist);
     aff.setRoles(stringlist);
-    aff.setManagers(stringlist);
-    aff.setAssistants(stringlist);
-    aff.setOffices(stringlist);
+    std::vector<Kolab::Related> relateds2;
+    relateds2.push_back(Kolab::Related(Kolab::Related::Text, "textRelation", Kolab::Related::Assistant));
+    relateds2.push_back(Kolab::Related(Kolab::Related::Uid, "textRelation", Kolab::Related::Manager));
+    aff.setRelateds(relateds2);
+    std::vector<Kolab::Address> adrs;
+    Kolab::Address adr1;
+    adr1.setLabel("label");
+    adrs.push_back(adr1);
+    Kolab::Address adr2;
+    adr2.setStreet("street");
+    adr2.setTypes(Kolab::Address::Work);
+    adrs.push_back(adr2);
+    aff.setAddresses(adrs);
     list.push_back(aff);
     Kolab::Affiliation aff2;
     list.push_back(aff2);
@@ -427,7 +438,7 @@ void BindingsTest::contactCompletness()
     
     const std::string result = Kolab::writeContact(c);
     QVERIFY(Kolab::error() == Kolab::NoError);
-//     std::cout << result << endl;
+    std::cout << result << endl;
     Kolab::Contact e = Kolab::readContact(result, false);
     QVERIFY(Kolab::error() == Kolab::NoError);
     QCOMPARE(e.uid(), c.uid());
@@ -470,7 +481,7 @@ void BindingsTest::distlistCompletness()
     c.setUid("uid");
     std::vector<Kolab::ContactReference> members;
     members.push_back(Kolab::ContactReference(Kolab::ContactReference::EmailReference, "mail", "name"));
-    members.push_back(Kolab::ContactReference(Kolab::ContactReference::UrnReference, "urn"));
+    members.push_back(Kolab::ContactReference(Kolab::ContactReference::UidReference, "urn"));
     c.setMembers(members);
     std::vector<Kolab::CustomProperty> properties;
     properties.push_back(Kolab::CustomProperty("ident", "value"));
diff --git a/c++/tests/conversiontest.cpp b/c++/tests/conversiontest.cpp
index 64d6db6..700c251 100644
--- a/c++/tests/conversiontest.cpp
+++ b/c++/tests/conversiontest.cpp
@@ -211,7 +211,7 @@ void ConversionTest::contactReferenceTest()
 {
     Kolab::ContactReference email(Kolab::ContactReference::EmailReference, "mail", "name");
     QCOMPARE(Kolab::Shared::fromContactReference(email), std::string("mailto:name%3Cmail%3E"));
-    Kolab::ContactReference urn(Kolab::ContactReference::UrnReference, "urn");
+    Kolab::ContactReference urn(Kolab::ContactReference::UidReference, "urn");
     QCOMPARE(Kolab::Shared::fromContactReference(urn), std::string("urn:uuid:urn"));
     
     QCOMPARE(Kolab::Shared::toContactReference("urn:uuid:urn"), urn);
diff --git a/c++/tests/serializers.h b/c++/tests/serializers.h
index a669347..39d904f 100644
--- a/c++/tests/serializers.h
+++ b/c++/tests/serializers.h
@@ -166,20 +166,21 @@ namespace QTest {
     }
     
     template<>
-    char *toString(const Kolab::Affiliation &a)
+    char *toString(const Kolab::Related &a)
     {
-        QByteArray ba = "Kolab::Affiliation(";
-        ba += QString::fromStdString(a.organisation()).toAscii()+ "\n " + 
-        QString::fromStdString(a.logo()).toAscii()+"\n " +toString(a.titles()) + "\n " + toString(a.roles())+  "\n " + toString(a.managers()) + "\n " +
-        toString(a.assistants())  + "\n " + toString(a.offices()) + "\n ";
+        QByteArray ba = "Kolab::Related(";
+        ba += QString::fromStdString(a.text()).toAscii()+ "\n " + 
+        QString::fromStdString(a.uri()).toAscii()+"\n " +
+        QByteArray::number(a.relationTypes()) + "\n " +
+        QByteArray::number(a.type()) + "\n ";
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
-    char *toString(const std::vector<Kolab::Affiliation> &v)
+    char *toString(const std::vector<Kolab::Related> &v)
     {
-        QByteArray ba = "vector<Kolab::Affiliation>(";
+        QByteArray ba = "vector<Kolab::Related>(";
         for (int i = 0; i < v.size(); i++) {
             ba += QByteArray(toString(v.at(i)))+ "\n";
         }
@@ -188,27 +189,28 @@ namespace QTest {
     }
     
     template<>
-    char *toString(const Kolab::Related &a)
+    char *toString(const Kolab::Affiliation &a)
     {
-        QByteArray ba = "Kolab::Related(";
-        ba += QString::fromStdString(a.text()).toAscii()+ "\n " + 
-        QString::fromStdString(a.uri()).toAscii()+"\n " +
-        QByteArray::number(a.relationTypes()) + "\n " +
-        QByteArray::number(a.type()) + "\n ";
+        QByteArray ba = "Kolab::Affiliation(";
+        ba += QString::fromStdString(a.organisation()).toAscii()+ "\n " + 
+        QString::fromStdString(a.logo()).toAscii()+"\n " + "\n " + toString(a.roles())+  "\n " + toString(a.relateds()) + "\n " +
+        toString(a.addresses())  + "\n ";
         ba += ")";
         return qstrdup(ba.data());
     }
     
     template<>
-    char *toString(const std::vector<Kolab::Related> &v)
+    char *toString(const std::vector<Kolab::Affiliation> &v)
     {
-        QByteArray ba = "vector<Kolab::Related>(";
+        QByteArray ba = "vector<Kolab::Affiliation>(";
         for (int i = 0; i < v.size(); i++) {
             ba += QByteArray(toString(v.at(i)))+ "\n";
         }
         ba += ")";
         return qstrdup(ba.data());
     }
+    
+
 
  }
  
diff --git a/schemas/kolabformat-xcard.xsd b/schemas/kolabformat-xcard.xsd
index 6138231..0983401 100644
--- a/schemas/kolabformat-xcard.xsd
+++ b/schemas/kolabformat-xcard.xsd
@@ -98,6 +98,7 @@
                         <xs:element name="n" type="nPropType" minOccurs="0"/>
                         <xs:element name="note" type="notePropType" minOccurs="0"/>
                         <xs:element name="fburl" type="fburlPropType" minOccurs="0"/>
+                        <xs:element name="title" type="titlePropType" minOccurs="0" maxOccurs="unbounded"/>
                         <xs:element name="group" type="affiliationPropType" minOccurs="0" maxOccurs="unbounded"/>
                         <xs:element name="url" type="urlPropType" minOccurs="0" maxOccurs="unbounded"/>
                         <xs:element name="adr" type="adrPropType" minOccurs="0" maxOccurs="unbounded"/>
diff --git a/schemas/xCard.xsd b/schemas/xCard.xsd
index e456aff..560cc7c 100644
--- a/schemas/xCard.xsd
+++ b/schemas/xCard.xsd
@@ -79,6 +79,8 @@
       <!-- Related -->
       <xs:enumeration value="spouse"/>
       <xs:enumeration value="child"/>
+      <xs:enumeration value="x-assistant"/>
+      <xs:enumeration value="x-manager"/>
     </xs:restriction>
   </xs:simpleType>
   
@@ -278,17 +280,21 @@
     </xs:complexContent>
   </xs:complexType>
   
+  <xs:complexType name="titlePropType">
+    <xs:complexContent mixed="false">
+      <xs:extension base="xcard:TextPropertyType"/>
+    </xs:complexContent>
+  </xs:complexType>
+  
   <xs:complexType name="affiliationPropType">
     <xs:complexContent mixed="false">
       <xs:extension base="xcard:BasePropertyType">
         <xs:sequence> 
           <xs:element name="org" type="xcard:NonEmptyTextListPropertyType" />
           <xs:element name="logo" type="xcard:UriPropertyType" minOccurs="0" />
-          <xs:element name="title" type="xcard:TextPropertyType" minOccurs="0" maxOccurs="unbounded"/>
           <xs:element name="role" type="xcard:TextPropertyType" minOccurs="0" maxOccurs="unbounded"/>
-          <xs:element name="x-manager" type="xcard:TextPropertyType" minOccurs="0" maxOccurs="unbounded"/>
-          <xs:element name="x-assistant" type="xcard:TextPropertyType" minOccurs="0" maxOccurs="unbounded"/>
-          <xs:element name="x-office" type="xcard:TextPropertyType" minOccurs="0" maxOccurs="unbounded"/>
+          <xs:element name="related" type="xcard:relatedPropType" minOccurs="0" maxOccurs="unbounded"/>
+          <xs:element name="adr" type="xcard:adrPropType" minOccurs="0" maxOccurs="unbounded"/>
         </xs:sequence>
         <xs:attribute name="name" type="xs:string" fixed="Affiliation" />
       </xs:extension>   





More information about the commits mailing list