/home/archives/aegis/branch.4/branch.25/delta28933.505/libaegis/project.h

Go to the documentation of this file.

//
// aegis - project change supervisor
// Copyright (C) 1992-1999, 2001-2008, 2011, 2012 Peter Miller
// Copyright (C) 2007, 2008 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.fmtgen.h>
#include <libaegis/pstate.fmtgen.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
{
public:
    typedef project *pointer;

    ~project();

    project(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.
    //
    // Note: public or protected or private, it doesn't matter, keep
    // them sorted.

    // ----------  A  ------------------------------------------------------

    nstring attribute_get(const nstring &name);

    bool attribute_get_boolean(const nstring &name);

    // ----------  B  ------------------------------------------------------

    string_ty *baseline_path_get(bool resolve = false);

    project *bind_branch(change::pointer bp);

    void bind_existing();

    bool bind_existing_errok();

    void bind_keep(const nstring &path);

    void bind_new();

    // ----------  C  ------------------------------------------------------

    time_t change_completion_timestamp(long change_number);

    change::pointer change_get(void);

    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 *pp);

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

    // ----------  D  ------------------------------------------------------
    // ----------  E  ------------------------------------------------------
    // ----------  F  ------------------------------------------------------

    bool file_directory_query(const nstring &filename, nstring_list &result_in,
        nstring_list &result_out, view_path_ty as_view_path);

    void file_directory_query(string_ty *filename,
        struct string_list_ty *result_in, struct string_list_ty *result_out,
        view_path_ty as_view_path);

    bool file_exists(const nstring &filename);

    fstate_src_ty *file_find(const nstring &filename,
        view_path_ty as_view_path);

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

    fstate_src_ty *file_find(fstate_src_ty *c_src, view_path_ty as_view_path);

    fstate_src_ty *file_find(cstate_src_ty *c_src, view_path_ty as_view_path);

    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 *find_branch(const char *number);

    // ----------  G  ------------------------------------------------------

private:
    void get_the_owner();

public:
    user_ty::pointer get_user() const;

    int gid_get();

    // ----------  H  ------------------------------------------------------

    string_ty *history_path_get();

    string_ty *home_path_get();

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

    // ----------  I  ------------------------------------------------------

    string_ty *info_path_get();

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

    // ----------  J  ------------------------------------------------------
    // ----------  K  ------------------------------------------------------
    // ----------  L  ------------------------------------------------------

    void list_inner(string_list_ty &result);

    void lock_prepare_everything();

private:
    void lock_sync();

    // ----------  M  ------------------------------------------------------
    // ----------  N  ------------------------------------------------------

public:
    string_ty *name_get() const;

    // ----------  O  ------------------------------------------------------
    // ----------  P  ------------------------------------------------------

    long parent_branch_number_get() const { return parent_bn; }

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

    pstate_ty *pstate_get();

    void pstate_lock_prepare();

    string_ty *pstate_path_get();

    void search_path_get(string_list_ty *result, bool resolve);

    void search_path_get(nstring_list &result, bool resolve);

    void pstate_write();

    // ----------  Q  ------------------------------------------------------
    // ----------  R  ------------------------------------------------------
    // ----------  S  ------------------------------------------------------
    // ----------  T  ------------------------------------------------------

    project *trunk_get();

    // ----------  U ------------------------------------------------------
    // ----------  V  ------------------------------------------------------
    // ----------  W  ------------------------------------------------------
    // ----------  X  ------------------------------------------------------
    // ----------  Y  ------------------------------------------------------
    // ----------  Z  ------------------------------------------------------
    // ---------------------------------------------------------------------

    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 *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();

    project(const project &);

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

project *project_alloc(string_ty *name);

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

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

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

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

void project_list_get(struct string_list_ty *);

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

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

void project_free(project *);

inline nstring
project_name_get(project *pp)
{
    return nstring(pp->name_get());
}

project *project_copy(project *);

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

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

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

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

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

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

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

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

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

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

DEPRECATED
string_ty *project_change_path_get(project *, long);

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

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

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

void project_pstate_write_top(project *);

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

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

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

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

user_ty::pointer project_user(project *);
void project_become(project *);
void project_become_undo(project *pp);
long project_next_test_number_get(project *);
int project_is_readable(project *);
long project_minimum_change_number_get(project *);
void project_minimum_change_number_set(project *, long);
bool project_reuse_change_numbers_get(project *);
void project_reuse_change_numbers_set(project *, bool);
long project_minimum_branch_number_get(project *);
void project_minimum_branch_number_set(project *, long);
bool project_skip_unlucky_get(project *);
void project_skip_unlucky_set(project *, bool);
bool project_compress_database_get(project *);
void project_compress_database_set(project *, bool);
int project_develop_end_action_get(project *);
void project_develop_end_action_set(project *, int);
bool project_protect_development_directory_get(project *);
void project_protect_development_directory_set(project *, 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 *);

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

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

string_ty *project_brief_description_get(project *);

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

// vim: set ts=8 sw=4 et :
#endif // PROJECT_H