Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Functions | Variables
storage.c File Reference
#include "ical.h"
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "icalmemory.h"
#include "icaldirset.h"
#include "icalfileset.h"
#include "icalerror.h"
#include "icalrestriction.h"
#include "icalcalendar.h"

Go to the source code of this file.

Classes

struct  calendar

Defines

#define OUTPUT_FILE   "filesetout.ics"
#define DATABASE   "calendar.db"
#define NUMCOMP   4

Functions

int vcalendar_init (struct calendar **cal, char *vcalendar, char *title)
char * pack_calendar (struct calendar *cal, int size)
struct calendarunpack_calendar (char *str, int size)
void test_fileset ()
int test_dirset ()
int main (int argc, char *argv[])

Variables

char str []
char str2 []

Class Documentation

struct calendar

Definition at line 43 of file regression-storage.c.

Collaboration diagram for calendar:
Class Members
int ID
char * title
int title_offset
int title_size
int title_size_offset
int total_size
int total_size_offset
char * vcalendar
int vcalendar_offset
int vcalendar_size
int vcalendar_size_offset

Define Documentation

#define DATABASE   "calendar.db"

Definition at line 47 of file storage.c.

#define NUMCOMP   4
#define OUTPUT_FILE   "filesetout.ics"

Definition at line 46 of file storage.c.


Function Documentation

int main ( int  argc,
char *  argv[] 
)

Definition at line 850 of file storage.c.

{

    printf("\n------------Test File Set---------------\n");
    test_fileset(); 

    printf("\n------------Test Dir Set---------------\n");
    test_dirset();

#ifdef WITH_BDB4
    printf("\n------------Test BerkeleyDB Set---------------\n");
    test_bdbset();
#endif

#if 0
    printf("\n------------Test Calendar---------------\n");
    test_calendar();
#endif

    return 0;
}

Here is the call graph for this function:

char * pack_calendar ( struct calendar cal,
int  size 
)

Definition at line 555 of file storage.c.

{
  char *str;

  if((str = (char *)malloc(sizeof(char) * size))==NULL)
    return 0;

  /* ID */
  memcpy(str, &cal->ID, sizeof(cal->ID));

  /* total_size */
  memcpy(str + cal->total_size_offset,
        &cal->total_size,
        sizeof(cal->total_size));

  /* vcalendar_size */
  memcpy(str + cal->vcalendar_size_offset, 
         &cal->vcalendar_size, 
         sizeof(cal->vcalendar_size));

  /* vcalendar */
  memcpy(str + cal->vcalendar_offset, 
         cal->vcalendar, 
         cal->vcalendar_size);

  /* title_size */
  memcpy(str + cal->title_size_offset,
        &cal->title_size,
        sizeof(cal->title_size));

  /* title */
  memcpy(str + cal->title_offset,
        cal->title,
        cal->title_size);

  return str;
}

Here is the call graph for this function:

Definition at line 647 of file storage.c.

{

    icalcomponent *c, *gauge;
    icalerrorenum error;
    icalcomponent *itr;
    icalfileset* cluster;
    struct icalperiodtype rtime;
    icaldirset *s = icaldirset_new("store");
    int i;

    assert(s != 0);

    rtime.start = icaltime_from_timet( time(0),0);

    cluster = icalfileset_new(OUTPUT_FILE);

    assert(cluster != 0);

#define NUMCOMP 4

    /* Duplicate every component in the cluster NUMCOMP times */

    icalerror_clear_errno();

    for (i = 1; i<NUMCOMP+1; i++){

       /*rtime.start.month = i%12;*/
       rtime.start.month = i;
       rtime.end = rtime.start;
       rtime.end.hour++;
       
       for (itr = icalfileset_get_first_component(cluster);
            itr != 0;
            itr = icalfileset_get_next_component(cluster)){
           icalcomponent *clone, *inner;
           icalproperty *p;

           inner = icalcomponent_get_first_component(itr,ICAL_VEVENT_COMPONENT);
            if (inner == 0){
              continue;
            }

           /* Change the dtstart and dtend times in the component
               pointed to by Itr*/

           clone = icalcomponent_new_clone(itr);
           inner = icalcomponent_get_first_component(itr,ICAL_VEVENT_COMPONENT);

           assert(icalerrno == ICAL_NO_ERROR);
           assert(inner !=0);

           /* DTSTART*/
           p = icalcomponent_get_first_property(inner,ICAL_DTSTART_PROPERTY);
           assert(icalerrno  == ICAL_NO_ERROR);

           if (p == 0){
              p = icalproperty_new_dtstart(rtime.start);
              icalcomponent_add_property(inner,p);
           } else {
              icalproperty_set_dtstart(p,rtime.start);
           }
           assert(icalerrno  == ICAL_NO_ERROR);

           /* DTEND*/
           p = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
           assert(icalerrno  == ICAL_NO_ERROR);

           if (p == 0){
              p = icalproperty_new_dtstart(rtime.end);
              icalcomponent_add_property(inner,p);
           } else {
              icalproperty_set_dtstart(p,rtime.end);
           }
           assert(icalerrno  == ICAL_NO_ERROR);
           
           printf("\n----------\n%s\n---------\n",icalcomponent_as_ical_string(inner));

           error = icaldirset_add_component(s,
                                        icalcomponent_new_clone(itr));
           
           assert(icalerrno  == ICAL_NO_ERROR);

       }

    }
    
    gauge = 
       icalcomponent_vanew(
           ICAL_VCALENDAR_COMPONENT,
           icalcomponent_vanew(
              ICAL_VEVENT_COMPONENT,  
              icalproperty_vanew_summary(
                  "Submit Income Taxes",
                  icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_EQUAL),
                  0),
              0),
           icalcomponent_vanew(
              ICAL_VEVENT_COMPONENT,  
              icalproperty_vanew_summary(
                  "Bastille Day Party",
                  icalparameter_new_xliccomparetype(ICAL_XLICCOMPARETYPE_EQUAL),
                  0),
              0),
           0);

#if 0


    icaldirset_select(s,gauge);

    for(c = icaldirset_first(s); c != 0; c = icaldirset_next(s)){
       
       printf("Got one! (%d)\n", count++);
       
       if (c != 0){
           printf("%s", icalcomponent_as_ical_string(c));;
           if (icaldirset_store(s2,c) == 0){
              printf("Failed to write!\n");
           }
           icalcomponent_free(c);
       } else {
           printf("Failed to get component\n");
       }
    }


    icalset_free(s2);
#endif


    for(c = icaldirset_get_first_component(s); 
       c != 0; 
       c = icaldirset_get_next_component(s)){

       if (c != 0){
           printf("%s", icalcomponent_as_ical_string(c));;
       } else {
           printf("Failed to get component\n");
       }

    }

    /* Remove all of the components */
    i=0;
    while((c=icaldirset_get_current_component(s)) != 0 ){
       i++;

       icaldirset_remove_component(s,c);
    }
       

    icalset_free(s);
    return 0;
}

Here is the call graph for this function:

Definition at line 142 of file storage.c.

{
    icalfileset *cout;
    int month = 0;
    int count=0;
    struct icaltimetype start, end;
    icalcomponent *c,*clone, *itr;

    start = icaltime_from_timet( time(0),0);
    end = start;
    end.hour++;

    cout = icalfileset_new(OUTPUT_FILE);
    assert(cout != 0);

    c = icalparser_parse_string(str2);
    assert(c != 0);

    /* Add data to the file */

    for(month = 1; month < 10; month++){
       icalcomponent *event;
       icalproperty *dtstart, *dtend;

        cout = icalfileset_new(OUTPUT_FILE);
        assert(cout != 0);

       start.month = month; 
       end.month = month;
       
       clone = icalcomponent_new_clone(c);
       assert(clone !=0);
       event = icalcomponent_get_first_component(clone,ICAL_VEVENT_COMPONENT);
       assert(event != 0);

       dtstart = icalcomponent_get_first_property(event,ICAL_DTSTART_PROPERTY);
       assert(dtstart!=0);
       icalproperty_set_dtstart(dtstart,start);
        
       dtend = icalcomponent_get_first_property(event,ICAL_DTEND_PROPERTY);
       assert(dtend!=0);
       icalproperty_set_dtend(dtend,end);
       
       icalfileset_add_component(cout,clone);
       icalfileset_commit(cout);

        icalset_free(cout);

    }

    /* Print them out */

    cout = icalfileset_new(OUTPUT_FILE);
    assert(cout != 0);
    
    for (itr = icalfileset_get_first_component(cout);
         itr != 0;
         itr = icalfileset_get_next_component(cout)){

      icalcomponent *event;
      icalproperty *dtstart, *dtend;

      count++;

      event = icalcomponent_get_first_component(itr,ICAL_VEVENT_COMPONENT);

      dtstart = icalcomponent_get_first_property(event,ICAL_DTSTART_PROPERTY);
      dtend = icalcomponent_get_first_property(event,ICAL_DTEND_PROPERTY);
      
      printf("%d %s %s\n",count, icalproperty_as_ical_string(dtstart),
             icalproperty_as_ical_string(dtend));

    }

    /* Remove all of them */

    icalset_free(cout);

    cout = icalfileset_new(OUTPUT_FILE);
    assert(cout != 0);
    
    for (itr = icalfileset_get_first_component(cout);
         itr != 0;
         itr = icalfileset_get_next_component(cout)){


      icalfileset_remove_component(cout, itr);
    }

    icalset_free(cout);


    /* Print them out again */

    cout = icalfileset_new(OUTPUT_FILE);
    assert(cout != 0);
    count =0;
    
    for (itr = icalfileset_get_first_component(cout);
         itr != 0;
         itr = icalfileset_get_next_component(cout)){

      icalcomponent *event;
      icalproperty *dtstart, *dtend;

      count++;

      event = icalcomponent_get_first_component(itr,ICAL_VEVENT_COMPONENT);

      dtstart = icalcomponent_get_first_property(event,ICAL_DTSTART_PROPERTY);
      dtend = icalcomponent_get_first_property(event,ICAL_DTEND_PROPERTY);
      
      printf("%d %s %s\n",count, icalproperty_as_ical_string(dtstart),
             icalproperty_as_ical_string(dtend));

    }

    icalset_free(cout);


}

Here is the call graph for this function:

struct calendar * unpack_calendar ( char *  str,
int  size 
) [read]

Definition at line 593 of file storage.c.

{
  struct calendar *cal;
  if((cal = (struct calendar *) malloc(size))==NULL)
    return 0;
  memset(cal, 0, size);

  /* offsets */
  cal->total_size_offset     = sizeof(int);
  cal->vcalendar_size_offset = (sizeof(int) * 7);
  cal->vcalendar_offset      = cal->vcalendar_size_offset + sizeof(int);

  /* ID */
  memcpy(&cal->ID, str, sizeof(cal->ID));

  /* total_size */
  memcpy(&cal->total_size,
        str + cal->total_size_offset,
        sizeof(cal->total_size));

  /* vcalendar_size */
  memcpy(&cal->vcalendar_size, 
        str + cal->vcalendar_size_offset, 
        sizeof(cal->vcalendar_size));

  if((cal->vcalendar = (char *)malloc(sizeof(char) * 
                                  cal->vcalendar_size))==NULL)
    return 0;

  /* vcalendar */
  memcpy(cal->vcalendar, 
        (char *)(str + cal->vcalendar_offset), 
        cal->vcalendar_size);

  cal->title_size_offset     = cal->vcalendar_offset + cal->vcalendar_size;
  cal->title_offset          = cal->title_size_offset + sizeof(int);

  /* title_size */
  memcpy(&cal->title_size,
        str + cal->title_size_offset,
        sizeof(cal->title_size));

  if((cal->title = (char *)malloc(sizeof(char) *
                              cal->title_size))==NULL)
    return 0;

  /* title*/
  memcpy(cal->title,
        (char *)(str + cal->title_offset),
        cal->title_size);

  return cal;
}

Here is the call graph for this function:

int vcalendar_init ( struct calendar **  cal,
char *  vcalendar,
char *  title 
)

Variable Documentation

char str[]

Definition at line 80 of file storage.c.

char str2[]
Initial value:
"BEGIN:VCALENDAR\n\
PRODID:\"-//RDU Software//NONSGML HandCal//EN\"\n\
VERSION:2.0\n\
BEGIN:VEVENT\n\
DTSTAMP:19980309T231000Z\n\
UID:guid-1.host1.com\n\
ORGANIZER;ROLE=CHAIR:MAILTO:mrbig@host.com\n\
ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com\n\
DESCRIPTION:Project XYZ Review Meeting\n\
CATEGORIES:MEETING\n\
CLASS:PUBLIC\n\
CREATED:19980309T130000Z\n\
SUMMARY:XYZ Project Review\n\
DTSTART;TZID=US-Eastern:19980312T083000\n\
DTEND;TZID=US-Eastern:19980312T093000\n\
LOCATION:1CP Conference Room 4350\n\
END:VEVENT\n\
END:VCALENDAR\n\
"

Definition at line 122 of file storage.c.