cs_directory_decl.hpp

Go to the documentation of this file.

/*
 *      Copyright (c) 2023, an unpublished work by CodeSecure, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      Copyright (c) 2013-2023, an unpublished work by GrammaTech, Inc.
 *                      ALL RIGHTS RESERVED
 *
 *      This software is furnished under a license and may be used and
 *      copied only in accordance with the terms of such license and the
 *      inclusion of the above copyright notice.  This software or any
 *      other copies thereof may not be provided or otherwise made
 *      available to any other person.  Title to and ownership of the
 *      software is retained by CodeSecure, Inc.
 */

#ifndef CS_DIRECTORY_DECL_HPP
#define CS_DIRECTORY_DECL_HPP

#include "cs_directory.h"
#include "cs_directory_fwd.hpp"
#include "cs_ir_boilerplate.hpp"
#include "cs_sfile_decl.hpp"

namespace cs{
    class directory_children_iterator_policy_container{
        directory_children_iterator_policy_container();
    public:
        cs_directory parent;
        directory_children_iterator_policy_container(
            cs_directory _parent)
            : parent(_parent){}
    };

    class directory_children_iterator_policy{
    public:
        typedef cs_directory_child_directory_iter iterator_impl;
        typedef directory key;
        typedef directory_children_iterator_policy_container ctype;

        static cs_result iter_first(
            const ctype &container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_directory_child_directory_iter_first( container.parent, val, it ); }
        static cs_result iter_next(
            const ctype &container,
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_directory_child_directory_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_directory_child_directory_iter_close( it ); }
        static const char *name()
        { return "directory_children_iterator"; }
    };

    class directory_files_iterator_policy{
    public:
        typedef cs_directory_file_iter iterator_impl;
        typedef sfile key;
        typedef cs_directory ctype;

        static cs_result iter_first(
            ctype container,
            cglue<key>::ctype *val,
            iterator_impl *it)
        { return cs_directory_file_iter_first( container, val, it ); }
        static cs_result iter_next(
            ctype container, 
            cglue<key>::ctype *val, 
            iterator_impl *it)
        { return cs_directory_file_iter_next( val, it ); }
        static cs_result iter_close(iterator_impl *it)
        { return cs_directory_file_iter_close( it ); }
        static const char *name()
        { return "directory_files_iterator"; }
    };

    class directory{
        CS_IR_BOILERPLATE(directory);

        csuint64 stable_hash() const
        {
            return cs_directory_stable_hash(inner);
        }

        int stable_cmp(const directory& other) const
        {
            return cs_directory_stable_compare(inner, other.inner);
        }

        directory_children_iterator children() const
        {   return directory_children_iterator(
                directory_children_iterator_policy_container(inner)); }


        size_t child_count() const
        {
            size_t rv;
            check(cs_directory_child_directory_count(inner, &rv));
            return rv;
        }


        directory_files_iterator files() const
        {   return directory_files_iterator(inner); }


        size_t file_count() const
        {
            size_t rv;
            check(cs_directory_file_count(inner, &rv));
            return rv;
        }


        directory parent() const;


        csuint32 depth() const;


        std::string name() const
        {   return cs_directory_string(inner); }


        std::string normalized_name() const
        {   return cs_directory_normalized_string(inner); }


        std::string as_string() const
        {
#if !CS_CPP_NO_EXCEPTIONS
            try{
#endif
                return name();
#if !CS_CPP_NO_EXCEPTIONS
            }catch(result){
                return "<unknown_directory>";
            }
#endif
        }

        std::string as_repr() const
        {    return CS_AS_REPR_FROM_STRING(directory); }
    };
    CS_IR_BOILERPLATE_FRIENDS_PLUS_OSTREAM(directory, cs)
}

#endif /* CS_DIRECTORY_DECL_HPP */