libaegis/project.h

Go to the documentation of this file.

//
//      aegis - project change supervisor
//      Copyright (C) 1992-1999, 2001-2008 Peter Miller
//      Copyright (C) 2007 Walter Franzini
//
//      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 3 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 PROJECT_H
#define PROJECT_H

#include <common/ac/time.h>

#include <libaegis/pattr.h>
#include <libaegis/pstate.h>
#include <libaegis/view_path.h>
#include <libaegis/change.h>

class string_list_ty; // forward
class sub_context_ty; // forward
class fstate_src_ty; // forward
class itab_ty; // forward

class project_ty
{
public:
    ~project_ty();

    project_ty(string_ty *name);

    // NOTE: methods are sorted alphabetically.  To have methods
    // grouped, make sure they change their suffix rather than their
    // prefix.  E.g. thingumy_get and thingumy_set rather than
    // get_thingumy and set_thingumy.

    nstring attribute_get(const nstring &name);

    bool attribute_get_boolean(const nstring &name);

    string_ty *baseline_path_get(bool resolve = false);

    project_ty *bind_branch(change::pointer bp);

    void bind_existing();

    bool bind_existing_errok();

    void bind_keep(const nstring &path);

    void bind_new();

    change::pointer change_get();

    change::pointer change_get_raw() { return pcp; }

    string_ty *change_path_get(long change_number);

    void
    change_reset()
    {
        change::pointer tmp = pcp;
        pcp = 0;
        change_free(tmp);
    }

    string_ty *changes_path_get();

public: // during transition, then private
    void convert_to_new_format();

public:
    void copy_the_owner(project_ty *pp);

    void copyright_years_slurp(int *a, int amax, int *alen_p);

    fstate_src_ty *file_find_by_uuid(string_ty *uuid, view_path_ty vp);

    fstate_src_ty *file_find_fuzzy(string_ty *filename,
        view_path_ty as_view_path);

private:
    struct string_list_ty *file_list_get(view_path_ty as_view_path);

public:
    void file_list_invalidate();

    fstate_src_ty *file_new(string_ty *file_name);

    fstate_src_ty *file_new(fstate_src_ty *meta);

    fstate_src_ty *file_nth(size_t n, view_path_ty as_view_path);

    project_ty *find_branch(const char *number);

private:
    void get_the_owner();

public:
    user_ty::pointer get_user() const;

    int gid_get();

    time_t change_completion_timestamp(long change_number);

    string_ty *history_path_get();

    string_ty *home_path_get();

    void home_path_set(string_ty *dir);
    void home_path_set(const nstring &dir);

    string_ty *info_path_get();

    bool is_a_trunk() const { return (parent == 0); }

    void list_inner(string_list_ty &result);

    void lock_prepare_everything();

private:
    void lock_sync();

public:
    string_ty *name_get() const;

    long parent_branch_number_get() const { return parent_bn; }

    project_ty *parent_get() { return (parent ? parent : this); }

    pstate_ty *pstate_get();

    void pstate_lock_prepare();

    string_ty *pstate_path_get();

    void pstate_write();

    project_ty *trunk_get();

    int uid_get();

    int umask_get();

public: // during transition
    long            reference_count;

private:
    string_ty *name;

    string_ty *home_path;

    string_ty *baseline_path_unresolved;

    string_ty *baseline_path;

    itab_ty *change2time_stp;

    string_ty *history_path;

    string_ty *info_path;

    string_ty *pstate_path;

    string_ty *changes_path;

    pstate_ty *pstate_data;

    bool is_a_new_file;

    long lock_magic;

    change::pointer pcp;

    int uid;

    int gid;

    project_ty *parent;

    long parent_bn;

    struct string_list_ty *file_list[view_path_MAX];

    struct symtab_ty *file_by_uuid[view_path_MAX];

    //
    // If you add an instance variable to this class, make sure you
    // dispose of it in the destructor and initialize in in the
    // constructor.  Both may be found in libaegis/project.cc
    //


private:
    user_ty::pointer up;

    bool off_limits;

    project_ty();

    project_ty(const project_ty &);

    project_ty &operator=(const project_ty &);
};

project_ty *project_alloc(string_ty *name);

inline DEPRECATED void
project_bind_existing(project_ty *pp)
{
    pp->bind_existing();
}

inline DEPRECATED bool
project_bind_existing_errok(project_ty *pp)
{
    return pp->bind_existing_errok();
}

inline DEPRECATED project_ty *
project_bind_branch(project_ty *ppp, change::pointer bp)
{
    return ppp->bind_branch(bp);
}

inline DEPRECATED void
project_bind_new(project_ty *pp)
{
    pp->bind_new();
}

void project_list_get(struct string_list_ty *);

inline DEPRECATED void
project_list_inner(struct string_list_ty *result, project_ty *pp)
{
    pp->list_inner(*result);
}

inline DEPRECATED project_ty *
project_find_branch(project_ty *pp, const char *number)
{
    return pp->find_branch(number);
}

void project_free(project_ty *);

inline string_ty *
project_name_get(project_ty *pp)
{
    return pp->name_get();
}

project_ty *project_copy(project_ty *);

inline DEPRECATED change::pointer
project_change_get(project_ty *pp)
{
    return pp->change_get();
}

inline DEPRECATED string_ty *
project_home_path_get(project_ty *pp)
{
    return pp->home_path_get();
}

string_ty *project_Home_path_get(project_ty *);
string_ty *project_top_path_get(project_ty *, int);

nstring project_rss_path_get(project_ty *pp, bool resolve = false);

inline DEPRECATED void
project_home_path_set(project_ty *pp, string_ty *dir)
{
    pp->home_path_set(dir);
}

inline DEPRECATED string_ty *
project_baseline_path_get(project_ty *pp, bool resolve = false)
{
    return pp->baseline_path_get(resolve);
}

inline DEPRECATED string_ty *
project_history_path_get(project_ty *pp)
{
    return pp->history_path_get();
}

string_ty *project_history_filename_get(project_ty *, struct fstate_src_ty *);

inline DEPRECATED string_ty *
project_info_path_get(project_ty *pp)
{
    return pp->info_path_get();
}

inline DEPRECATED string_ty *
project_changes_path_get(project_ty *pp)
{
    return pp->changes_path_get();
}

DEPRECATED
string_ty *project_change_path_get(project_ty *, long);

inline DEPRECATED string_ty *
project_pstate_path_get(project_ty *pp)
{
    return pp->pstate_path_get();
}

inline DEPRECATED pstate_ty *
project_pstate_get(project_ty *pp)
{
    return pp->pstate_get();
}

inline DEPRECATED void
project_pstate_write(project_ty *pp)
{
    pp->pstate_write();
}

void project_pstate_write_top(project_ty *);

inline DEPRECATED void
project_pstate_lock_prepare(project_ty *pp)
{
    pp->pstate_lock_prepare();
}

void project_pstate_lock_prepare_top(project_ty *);
void project_baseline_read_lock_prepare(project_ty *);
void project_baseline_write_lock_prepare(project_ty *);
void project_history_lock_prepare(project_ty *);
void project_error(project_ty *, struct sub_context_ty *, const char *);
void project_fatal(project_ty *, struct sub_context_ty *, const char *)
    NORETURN;
void project_verbose(project_ty *, struct sub_context_ty *, const char *);
void project_change_append(project_ty *, long, int);
void project_change_delete(project_ty *, long);
int project_change_number_in_use(project_ty *, long);
string_ty *project_version_short_get(project_ty *);
string_ty *project_version_get(project_ty *);

inline DEPRECATED int
project_uid_get(project_ty *pp)
{
    return pp->uid_get();
}

inline DEPRECATED int
project_gid_get(project_ty *pp)
{
    return pp->gid_get();
}

user_ty::pointer project_user(project_ty *);
void project_become(project_ty *);
void project_become_undo(project_ty *pp);
long project_next_test_number_get(project_ty *);
int project_is_readable(project_ty *);
long project_minimum_change_number_get(project_ty *);
void project_minimum_change_number_set(project_ty *, long);
bool project_reuse_change_numbers_get(project_ty *);
void project_reuse_change_numbers_set(project_ty *, bool);
long project_minimum_branch_number_get(project_ty *);
void project_minimum_branch_number_set(project_ty *, long);
bool project_skip_unlucky_get(project_ty *);
void project_skip_unlucky_set(project_ty *, bool);
bool project_compress_database_get(project_ty *);
void project_compress_database_set(project_ty *, bool);
int project_develop_end_action_get(project_ty *);
void project_develop_end_action_set(project_ty *, int);
bool project_protect_development_directory_get(project_ty *);
void project_protect_development_directory_set(project_ty *, bool);

int break_up_version_string(const char *, long *, int, int *, int);
void extract_version_from_project_name(string_ty **, long *, int, int *);
int project_name_ok(string_ty *);

pconf_ty *project_pconf_get(project_ty *);

project_ty *project_new_branch(project_ty *pp, user_ty::pointer up,
    long change_number, string_ty *topdir = 0, string_ty *reason = 0);

inline DEPRECATED void
project_file_list_invalidate(project_ty *pp)
{
    pp->file_list_invalidate();
}

string_ty *project_brief_description_get(project_ty *);

change::pointer project_uuid_find(project_ty *pp, string_ty *uuid);


class project
{
public:
    ~project();

    project(const project &arg);

    project &operator=(const project &arg);

    project(string_ty *name);

    project(const nstring &name);

    project_ty *operator->() const { return ref; }

private:
    project_ty *ref;

    project();
};

#endif // PROJECT_H

---