package.h

/*
 * package.h
 *
 * Copyright (C) 2003 Bastian Blank <waldi@debian.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef DEBIAN_INSTALLER__PACKAGE_H
#define DEBIAN_INSTALLER__PACKAGE_H

#include <debian-installer/mem.h>
#include <debian-installer/parser.h>
#include <debian-installer/slist.h>
#include <debian-installer/string.h>

typedef struct di_package di_package;
typedef struct di_package_dependency di_package_dependency;
typedef struct di_package_version di_package_version;

typedef enum di_package_dependency_type di_package_dependency_type;
typedef enum di_package_priority di_package_priority;
typedef enum di_package_status di_package_status;
typedef enum di_package_status_want di_package_status_want;
typedef enum di_package_type di_package_type;

#include <debian-installer/packages.h>

enum di_package_priority
{
  di_package_priority_extra = 1,
  di_package_priority_optional,
  di_package_priority_standard,
  di_package_priority_important,
  di_package_priority_required,
};

enum di_package_status
{
  di_package_status_undefined = 0,
  di_package_status_not_installed,
  di_package_status_unpacked,
  di_package_status_installed,
  di_package_status_half_configured,
  di_package_status_config_files,
};

enum di_package_status_want
{
  di_package_status_want_unknown = 0,
  di_package_status_want_install,
  di_package_status_want_hold,
  di_package_status_want_deinstall,
  di_package_status_want_purge,
};

enum di_package_type
{
  di_package_type_non_existent = 0,                     
  di_package_type_virtual_package,                      
  di_package_type_real_package,                         
};

struct di_package
{
  union
  {
    char *package;                                      
    di_rstring key;                                     
  };
  di_package_type type;                                 
  di_package_status_want status_want;                   
  di_package_status status;                             
  int essential;                                        
  di_package_priority priority;                         
  char *section;                                        
  int installed_size;                                   
  char *maintainer;                                     
  char *architecture;                                   
  char *version;                                        
  di_slist depends;                                     
  char *filename;                                       
  size_t size;                                          
  char *md5sum;                                         
  char *short_description;                              
  char *description;                                    
  unsigned int resolver;                                
};

enum di_package_dependency_type
{
  di_package_dependency_type_replaces = 1,              
  di_package_dependency_type_provides,                  
  di_package_dependency_type_depends,                   
  di_package_dependency_type_pre_depends,               
  di_package_dependency_type_recommends,                
  di_package_dependency_type_suggests,                  
  di_package_dependency_type_conflicts,                 
  di_package_dependency_type_enhances,                  
  di_package_dependency_type_reverse_provides = 0x100,  
  di_package_dependency_type_reverse_enhances,          
};

struct di_package_dependency
{
  di_package_dependency_type type;                      
  di_package *ptr;                                      
};

struct di_package_version
{
  unsigned long epoch;                                  
  char *upstream;                                       
  char *debian_revision;                                
};

void di_package_destroy (di_package *package);

static inline di_package *di_package_alloc (di_packages_allocator *allocator)
{
  return di_mem_chunk_alloc0 (allocator->package_mem_chunk);
}

static inline di_package_dependency *di_package_dependency_alloc (di_packages_allocator *allocator)
{
  return di_mem_chunk_alloc0 (allocator->package_dependency_mem_chunk);
}

void di_package_version_free (di_package_version *version);

int di_package_version_compare (const di_package_version *a, const di_package_version *b);
di_package_version *di_package_version_parse (di_package *package);

extern const char *const di_package_priority_text[];
extern const char *const di_package_status_want_text[];
extern const char *const di_package_status_text[];

int di_package_array_text_from (const char *const *array, const char *text);

static inline di_package_priority di_package_priority_text_from (const char *text)
{
  return di_package_array_text_from (di_package_priority_text, text);
}

static inline di_package_status_want di_package_status_want_text_from (const char *text)
{
  return di_package_array_text_from (di_package_status_want_text, text);
}

static inline di_package_status di_package_status_text_from (const char *text)
{
  return di_package_array_text_from (di_package_status_text, text);
}

static inline const char *di_package_priority_text_to (const di_package_priority priority)
{
  return di_package_priority_text[priority];
}

static inline const char *di_package_status_want_text_to (const di_package_status_want status)
{
  return di_package_status_want_text[status];
}

static inline const char *di_package_status_text_to (const di_package_status status)
{
  return di_package_status_text[status];
}

di_parser_fields_function_read
  di_package_parser_read_dependency,
  di_package_parser_read_description,
  di_package_parser_read_priority,
  di_package_parser_read_status;

di_parser_fields_function_write
  di_package_parser_write_dependency,
  di_package_parser_write_description,
  di_package_parser_write_priority,
  di_package_parser_write_status;

extern const di_parser_fieldinfo *di_package_parser_fieldinfo[];

di_parser_info *di_package_parser_info (void);

di_package *di_package_special_read_file (const char *file, di_packages *packages, di_packages_allocator *allocator, di_parser_info *(info) (void));

static inline di_package *di_package_read_file (const char *file, di_packages *packages, di_packages_allocator *allocator)
{
  return di_package_special_read_file (file, packages, allocator, di_package_parser_info);
}

#endif