PIMCalendarItem.hpp

Go to the documentation of this file.

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef PIMCALENDARITEM_HPP_
#define PIMCALENDARITEM_HPP_

#include <string>
#include <map>
#include <vector>
#include <set>
#include <PIMItem/PIMItem.hpp>
#include <PIMItem/PIMItemIndex.hpp>
namespace OpenAB {

class ItemField
{
  public:
    ItemField();

    ItemField(const std::string& value);
    ~ItemField();

    bool parse(std::string rawFieldString, bool forceParams = false);

    void setValue(const std::string& value);

    bool operator<(const ItemField& other) const;

    std::string toString() const;

    std::string getValue() const;

    std::map<std::string, std::set<std::string> > getParams() const;

  private:
    void processParam (std::string paramLine);

    void addParam(std::string paramName, std::set<std::string> values);

    std::string value;
    std::map<std::string, std::set<std::string> > params;
};

class KeyValueItem
{
  public:
    KeyValueItem();
    virtual ~KeyValueItem();

    bool parse(const std::string& rawData);

    std::map<std::string, std::vector<ItemField> >& getFields() {return fields;}

  protected:
    virtual bool processField();

    std::string currentLine;
    std::string currentFieldName;
    std::string currentFieldValue;
    std::string currentFieldValueOriginal;
    std::map<std::string, std::vector<ItemField> > fields;
    std::map<std::string, std::vector< SmartPtr<KeyValueItem> > > subcomponents;

  private:
    bool processSubcomponent();

    bool inSubcomponent;
    std::string currentSubcomponentName;
    std::string currentSubcomponentData;
};

class VDayLightTimeZoneKeyValueItem : public KeyValueItem
{
  public:
    VDayLightTimeZoneKeyValueItem(){};
    ~VDayLightTimeZoneKeyValueItem(){};

    bool processField() {return true;}
};

class VStandardTimeZoneKeyValueItem : public KeyValueItem
{
  public:
    VStandardTimeZoneKeyValueItem(){};
    ~VStandardTimeZoneKeyValueItem(){};

    bool processField() {return true;}
};

class KeyValueItemFactory
{
  public:
    KeyValueItemFactory() {}
    virtual ~KeyValueItemFactory() {}

    static KeyValueItem* createItem(const std::string& componentType);

    static void registerFactory(KeyValueItemFactory* factory, const std::string& componentType);

  protected:
    virtual KeyValueItem* createItem() = 0;

  private:
    static std::map<std::string, KeyValueItemFactory*> factories;
};

#define CREATE_KEY_VALUE_ITEM_FACTORY(KeyValueItemClass, ComponentType) \
 class KeyValueItemClass##Factory : public KeyValueItemFactory          \
 {                                                                      \
   public:                                                              \
    KeyValueItemClass##Factory() : KeyValueItemFactory()                \
    {                                                                   \
      KeyValueItemFactory::registerFactory(this, ComponentType);        \
    }                                                                   \
    ~KeyValueItemClass##Factory(){}                                     \
   protected:                                                           \
    KeyValueItem* createItem()                                          \
    {                                                                   \
      return new KeyValueItemClass();                                   \
    }                                                                   \
 } KeyValueItemClass##FactoryInstance;

class PIMCalendarItem : public PIMItem, public KeyValueItem
{
  public:
    PIMCalendarItem(PIMItemType t);

    virtual ~PIMCalendarItem()=0;

    bool parse(const std::string& iCalendar);

    SmartPtr<PIMItemIndex> getIndex();

    std::string getRawData() const;

  private:
    std::string iCalendar;
};

class PIMCalendarEventItem : public PIMCalendarItem
{
  public:
    PIMCalendarEventItem();

     virtual ~PIMCalendarEventItem();
};

class PIMCalendarTaskItem : public PIMCalendarItem
{
  public:
    PIMCalendarTaskItem();

    virtual ~PIMCalendarTaskItem();
};

} // namespace OpenAB

#endif // PIMCALENDARITEM_HPP_