cs_result.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_RESULT_HPP
#define CS_RESULT_HPP

#include "cs_sysutil.h"
#include "cs_enum_boilerplate.hpp"
#include "cs_std_includes.hpp"
#include "cs_api_defs.hpp"

namespace cs{
    // result not inheriting from std::exception is a deliberate
    // decision; a cs::result potentially gets created in nearly every
    // API call, and subclassing exception would more than double its
    // size on 64-bit systems.
    //
    // (There is also an implementation complication: exception
    // declares its destructor as throw(), so result would have a
    // throw() destructor, and a class called SwigDirector_result
    // inherits from result so its destructor would need to be
    // throw(). But SwigDirector_result also inherits from Director,
    // which (at least under our settings) does not have a throw()
    // destructor, which means that SwigDirector_result cannot have a
    // throw() destructor.)

    class result{
        CS_ENUM_BOILERPLATE_UB(result, cs_result,
                               rv = cs_resolve_error(inner) + 3,
                               ((csuint64)CS_INTERNAL_ERROR_UNKNOWN)+1);

    public:
        void check() const
        { cs::check(inner); }
        
#include "cs_result_decls.hpp"

    };
#ifndef CSFE_API
    CS_ENUM_BOILERPLATE_FRIENDS(result,
                                friend class rpc_handler;
                                template <typename T>
                                friend class metric_function;
                                template <typename T>
                                friend class metric_granularity_policy;
                                friend void check(cs_result r);
                                template<typename T>
                                friend class set_mixin;
                                friend class xr_query_iterator_policy_container;
                                friend class derived_metric_compilation_error;
                                friend class warningclass;,
                                cs
        )
#else /* CSFE_API */
    CS_ENUM_BOILERPLATE_FRIENDS(result,
                                friend void check(cs_result r);
                                friend void check(cs_result r, const char * file, unsigned line);,
                                cs
        )
#endif /* CSFE_API */
#include "cs_result_defs.hpp"

#ifndef SWIG
    inline void check(cs_result r)
    {
        if( r != CS_SUCCESS )
        {
#if CS_CPP_NO_EXCEPTIONS
            cs_fatal( "Uncaught exception from CS C++ API: %s\n", 
                      cs_resolve_error(r) + 3 );
#else
            throw result::;
#endif
        }
    }
#endif

#ifdef SWIGCSHARP
    static std::string result_number_to_name(csint64 r)
    {
        result obj = result::from_integer(r);
        return obj.name();
    }
#endif
}

#endif /* CS_RESULT_HPP */