Compiler Explorer

Source code

#include <cstdio>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <iterator>
#include <string>
#include <type_traits>
#include <stdarg.h> 
#include <sstream> 
#include <functional>
#include <exception>
#include <utility>
#include <vector>
#include <array>

namespace sd{
//libnd4j current logger part
class Logger{
    public:
    static void  info(const char *format, ...) {
        va_list args;
        va_start(args, format);
        vprintf(format, args);
        va_end(args);
        fflush(stdout);
    }
};

class Environment{
    public:
            static Environment& getInstance(){
                static Environment ex;
                return ex;
            }
     
    bool isDebug() {
        return d;
    }

bool isVerbose() {
        return v;
    }

void setVerbose(bool reallyVerbose) {v=reallyVerbose;}
    void setDebug(bool reallyDebug){d=reallyDebug;};
private:
  bool v;
  bool d=false;
};

#define Nd4jLong int

struct NDArray{
    NDArray(bool sameshape=true):returnVal{sameshape}{}

bool  isSameShape(const NDArray *other) const {
        return returnVal;
    }

bool isSameShape(const std::vector<Nd4jLong> &expected ) const{
          return returnVal;
    }
    int rankOf(){return 5;}
bool returnVal=true;
};

struct ShapeUtils{
    static std::string  shapeAsString(const NDArray* array) {
        std::string result;

result.append("[ bla bla");
 
        result.append("]");

return result;
    }

static std::string  shapeAsString(const std::vector<Nd4jLong>& shape) {
        std::string result;

result.append("[");
        for (int e = 0; e < shape.size(); e++) {
            result += std::to_string(shape.at(e));
            if (e < shape.size() - 1)
                result.append(", ");
        }
        result.append("]");

return result;
    }
};

}

namespace sd{
    #define IS_EMPTY_MSG_INPUT_ "the Emptiness of the Input NDArray"
    #define IS_EMPTY_MSG_OUTPUT_ "the Emptiness of the Output NDArray"
    #define RANK_MSG_INPUT_ "the Rank of the Input NDArray"
    #define LENGTH_MSG_INPUT_ "the Length of the Input NDArray"
    #define SHAPE_MSG_INPUT_ "the Shape of the Input NDArray"
    #define SHAPE_MSG_OUTPUT_ "the Shape of the Output NDArray"
    #define RANK_MSG_OUTPUT_ "the Rank of the Output NDArray"
    #define TYPE_MSG_INPUT_ "the Type of the Input NDArray"
    #define TYPE_MSG_OUTPUT_ "the Type of the Output NDArray"
    #define EWS_MSG_INPUT_ "the EWS of the Input NDArray"
    #define EWS_MSG_OUTPUT_ "the EWS of the Output NDArray"
    #define ORDERING_MSG_INPUT_ "the Ordering of the Input NDArray"
    #define ORDERING_MSG_OUTPUT_ "the Ordering of the Output NDArray"

const char* OP_VALIDATION_FAIL_MSG = "Op validation failed";
    const char* HAVE_PEEPHOLE = "Having the Peephole connections";
    const char* HAVE_SEQLENARR = "Having theSequence length array";
    const char* MSG_CELL_CLIPPING = "Cell clipping";
    const char* TYPECHECK_MSG = "Checking the Type requirments for the NDArrays";
    const char* NO_MSG = "";
    const char* EXPECTED_TRUE = "expected to be True";
    const char* EXPECTED_FALSE = "expected to be False";
    const char* EXPECTED_NOT_SUPPORTED = "not supported";
    const char* EXPECTED_EQ_MSG = "expected to be equal to";
    const char* EXPECTED_NE_MSG = "expected to be different than";
    const char* EXPECTED_LT_MSG = "expected to be less than";
    const char* EXPECTED_LE_MSG = "expected to be less than or equal";
    const char* EXPECTED_GT_MSG = "expected to be greater than";
    const char* EXPECTED_GE_MSG = "expected to be greater than or equal";

const char* EXPECTED_IN = "expected to be one of these";

const char* IS_EMPTY_MSG_INPUT= IS_EMPTY_MSG_INPUT_;
    const char* IS_EMPTY_MSG_INPUT0= IS_EMPTY_MSG_INPUT_ "#0";
    const char* IS_EMPTY_MSG_INPUT1= IS_EMPTY_MSG_INPUT_ "#1";
    const char* IS_EMPTY_MSG_INPUT2= IS_EMPTY_MSG_INPUT_ "#2";
    const char* IS_EMPTY_MSG_INPUT3= IS_EMPTY_MSG_INPUT_ "#3";

const char* RANK_MSG_INPUT= RANK_MSG_INPUT_;
    const char* RANK_MSG_INPUT0= RANK_MSG_INPUT_ "#0";
    const char* RANK_MSG_INPUT1= RANK_MSG_INPUT_ "#1";
    const char* RANK_MSG_INPUT2= RANK_MSG_INPUT_ "#2";
    const char* RANK_MSG_INPUT3= RANK_MSG_INPUT_ "#3";

const char* LENGTH_MSG_INPUT= LENGTH_MSG_INPUT_;
    const char* LENGTH_MSG_INPUT0= LENGTH_MSG_INPUT_ "#0";
    const char* LENGTH_MSG_INPUT1= LENGTH_MSG_INPUT_ "#1";
    const char* LENGTH_MSG_INPUT2= LENGTH_MSG_INPUT_ "#2";
    const char* LENGTH_MSG_INPUT3= LENGTH_MSG_INPUT_ "#3";

const char* SHAPE_MSG_INPUT= SHAPE_MSG_INPUT_;
    const char* SHAPE_MSG_INPUT0= SHAPE_MSG_INPUT_ "#0";
    const char* SHAPE_MSG_INPUT1= SHAPE_MSG_INPUT_ "#1";
    const char* SHAPE_MSG_INPUT2= SHAPE_MSG_INPUT_ "#2";
    const char* SHAPE_MSG_INPUT3= SHAPE_MSG_INPUT_ "#3";

const char* TYPE_MSG_INPUT= TYPE_MSG_INPUT_;
    const char* TYPE_MSG_INPUT0= TYPE_MSG_INPUT_ "#0";
    const char* TYPE_MSG_INPUT1= TYPE_MSG_INPUT_ "#1";
    const char* TYPE_MSG_INPUT2= TYPE_MSG_INPUT_ "#2";
    const char* TYPE_MSG_INPUT3= TYPE_MSG_INPUT_ "#3";

const char* EWS_MSG_INPUT= EWS_MSG_INPUT_;
    const char* EWS_MSG_INPUT0= EWS_MSG_INPUT_ "#0";
    const char* EWS_MSG_INPUT1= EWS_MSG_INPUT_ "#1";
    const char* EWS_MSG_INPUT2= EWS_MSG_INPUT_ "#2";
    const char* EWS_MSG_INPUT3= EWS_MSG_INPUT_ "#3";

const char* ORDERING_MSG_INPUT= ORDERING_MSG_INPUT_;
    const char* ORDERING_MSG_INPUT0= ORDERING_MSG_INPUT_ "#0";
    const char* ORDERING_MSG_INPUT1= ORDERING_MSG_INPUT_ "#1";
    const char* ORDERING_MSG_INPUT2= ORDERING_MSG_INPUT_ "#2";
    const char* ORDERING_MSG_INPUT3= ORDERING_MSG_INPUT_ "#3";

const char* RANK_MSG_OUTPUT= RANK_MSG_OUTPUT_;
    const char* RANK_MSG_OUTPUT0= RANK_MSG_OUTPUT_ "#0";
    const char* RANK_MSG_OUTPUT1= RANK_MSG_OUTPUT_ "#1";

const char* IS_EMPTY_MSG_OUTPUT= IS_EMPTY_MSG_OUTPUT_;
    const char* IS_EMPTY_MSG_OUTPUT0= IS_EMPTY_MSG_OUTPUT_ "#0";
    const char* IS_EMPTY_MSG_OUTPUT1= IS_EMPTY_MSG_OUTPUT_ "#1";

const char* TYPE_MSG_OUTPUT= TYPE_MSG_OUTPUT_;
    const char* TYPE_MSG_OUTPUT0= TYPE_MSG_OUTPUT_ "#0";
    const char* TYPE_MSG_OUTPUT1= TYPE_MSG_OUTPUT_ "#1";

const char* EWS_MSG_OUTPUT= EWS_MSG_OUTPUT_;
    const char* EWS_MSG_OUTPUT0= EWS_MSG_OUTPUT_ "#0";
    const char* EWS_MSG_OUTPUT1= EWS_MSG_OUTPUT_ "#1";

const char* ORDERING_MSG_OUTPUT= ORDERING_MSG_OUTPUT_;
    const char* ORDERING_MSG_OUTPUT0= ORDERING_MSG_OUTPUT_ "#0";
    const char* ORDERING_MSG_OUTPUT1= ORDERING_MSG_OUTPUT_ "#1";

const char* SHAPE_MSG_OUTPUT= SHAPE_MSG_OUTPUT_;
    const char* SHAPE_MSG_OUTPUT0= SHAPE_MSG_OUTPUT_ "#0";
    const char* SHAPE_MSG_OUTPUT1= SHAPE_MSG_OUTPUT_ "#1";

const char* IS_USE_ONEDNN_MSG = "isUseONEDNN should be enabled to use ONEDNN";
    const char * ONEDNN_STREAM_NOT_SUPPORTED = "ONEDNN stream is not supported";

const char* REQUIREMENTS_MEETS_MSG = "meets the requirements";
    const char* REQUIREMENTS_FAILS_MSG = "fails the requirements";
template <class T, std::size_t N>
std::ostream& operator<<(std::ostream& o, const std::array<T, N>& arr)
{
    o<<'[';
    for(auto &x : arr){
        o<<x<<", ";
    }
    o<<']';
    return o;
}

template <class T>
std::ostream& operator<<(std::ostream& o, const std::initializer_list<T>& arr)
{
    o<<'[';
    for(auto &x : arr){
        o<<x<<", ";
    }
    o<<']';
    return o;
}

template<typename T>
using remove_cvref_t = typename std::remove_cv< typename std::remove_reference<T>::type >::type;

template <class F>
struct Check_callable
{
  template <class... Args>
  static std::false_type try_call(Args&&...);
 
  template <class... Args>
  static auto try_call( F&& f, Args&&... args)
    -> decltype((void)f(std::forward<Args>(args)...),
                std::true_type{});
};
 
template <class F, class... Args>
using is_callable = decltype
  (
    Check_callable<F>::try_call(std::declval<F>(),
          std::forward<Args>(std::declval<Args>())...)
  );

template<typename S, typename T>
class is_streamable
{
    template<typename SS, typename TT>
    static auto test(int)
        -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());

template<typename, typename>
    static auto test(...)->std::false_type;

public:
    static const bool value = decltype(test<S, T>(0))::value;
};

template<typename T>
class has_getMsg
{
    template<typename TT>
    static auto test(int)
        -> decltype(std::declval<TT&>().getMsg(), std::true_type());

template<typename>
    static auto test(...)->std::false_type;

public:
    static const bool value = decltype(test<T>(0))::value;
};

template<typename T>
class has_getValue
{
    template<typename TT>
    static auto test(int)
        -> decltype(std::declval<TT&>().getValue(), std::true_type());

template<typename>
    static auto test(...)->std::false_type;

public:
    static const bool value = decltype(test<T>(0))::value;
};

template<typename T>
class has_getValueStr
{
    template<typename TT>
    static auto test(int)
        -> decltype(std::declval<TT&>().getValueStr(), std::true_type());

template<typename>
    static auto test(...)->std::false_type;

public:
    static const bool value = decltype(test<T>(0))::value;
};

template<typename T, typename Enable=void>
struct Underline{
   using type = T; 
};
template<typename T >
struct Underline<T,  typename std::enable_if<has_getValue<T>::value>::type>{
   using type = remove_cvref_t<decltype(std::declval<T&>().getValue())>; 
};

template<typename T, typename Enable=void>
struct UnderlineMsg{
   using type = T; 
};

template<typename T >
struct UnderlineMsg<T,  typename std::enable_if<has_getMsg<T>::value>::type>{
   using type = decltype(std::declval<T&>().getMsg()); 
};

template<typename T>
using UnderlineType=typename Underline<T>::type;
template<typename T>
using UnderlineMsgType=typename UnderlineMsg<T>::type;

template<typename T>
typename std::enable_if<(!has_getMsg<T>::value ||  (has_getMsg<T>::value && !is_streamable<std::stringstream, UnderlineMsgType<T>>::value)), const char*>::type 
getMsg(T x){
    return "";
}

template<typename T>
typename std::enable_if<(has_getMsg<T>::value && is_streamable<std::stringstream, UnderlineMsgType<T>>::value) , UnderlineMsgType<T>>::type 
getMsg(const T& x){
    return x.getMsg();
}

template<typename T>
typename std::enable_if<!has_getValue<T>::value,T>::type
getValue(const T& x){
    return x;
}

template<typename T>
typename std::enable_if<has_getValue<T>::value, decltype(std::declval<T&>().getValue())>::type
getValue(const T& x){
    return x.getValue();
}

template<typename T>
typename std::enable_if<!has_getValueStr<T>::value && !std::is_same<remove_cvref_t<UnderlineType<T>>, bool>::value
 && is_streamable<std::stringstream,UnderlineType<T>>::value,UnderlineType<T>>::type
getStreamValue(const T& x){
    return getValue(x);
}

template<typename T>
typename std::enable_if<!has_getValueStr<T>::value && !is_streamable<std::stringstream,UnderlineType<T>>::value,std::string>::type
getStreamValue(T x){
    return "{//system can not stringify the variable}";
}

template<typename T>
typename std::enable_if<has_getValueStr<T>::value,std::string>::type
getStreamValue(const T& x){
    return x.getValueStr();
}

template<typename T>
typename std::enable_if<!has_getValueStr<T>::value && std::is_same<remove_cvref_t<UnderlineType<T>>, bool>::value, const char*>::type
getStreamValue(const T& x){
    return getValue(x) ? "True" : "False";
}

class Requirements{
    public:

Requirements(const char *prefix_msg=""):prefix(prefix_msg), ok(true){
#if defined(ENABLE_LOG_TO_TEST)
        sd::Environment::getInstance().setDebug(true);
        sd::Environment::getInstance().setVerbose(true);
#endif
    };

//Requirements is implicitly converted to bool.
    //Note: this way you can use shortcircuit operators && to chain requirements
    //      req.expect && req.expect && ... 
    //      This way you will get the shortcircuit that will not evaluate the laters
    //      it is better than using calls chaining like: req.expect( ).expect
    operator bool() {
         return this->ok;
    }

//sets the prefix message
    Requirements& setPrefix(const char *prefix_msg){
        prefix = prefix_msg;
        return *this;
    }

//Compares two values with comparision
    //Note: to achive full lazy evaluation of the obtained values or messages
    //        you should wrap them and use getValue getMsg functions
    template<typename T, typename T1, typename Op >
    Requirements& expect(const T& expVar,const T1& reqVar, Op comparision, const char *first_half=""){
        if(!this->ok)  return *this; 
        bool cmp  = comparision(getValue(expVar), getValue(reqVar));
        if(!cmp && sd::Environment::getInstance().isDebug() && sd::Environment::getInstance().isVerbose()){
            std::stringstream stream;
            stream<<prefix<<": "<<getMsg(expVar)<<" {"<<getStreamValue(expVar)<<"} "<<first_half<<' '<<getMsg(reqVar)<<' '<<getStreamValue(reqVar);
            sd::Logger::info("%s\n", stream.str().c_str());
        }
        this->ok  = this->ok && cmp;
        return *this;
    }

template<typename T, typename T1>
   Requirements& expectEq(const T& exp,const T1& req){
        return expect(exp, req, std::equal_to<UnderlineType<T1>>{}, EXPECTED_EQ_MSG);
   }

template<typename T, typename T1>
   Requirements& expectNotEq(const T& exp,const T1& req){
        return expect(exp, req, std::not_equal_to<UnderlineType<T1>>{}, EXPECTED_NE_MSG);
   }

template<typename T, typename T1>
   Requirements& expectLess(const T& exp,const T1& req){
        return expect(exp, req, std::less<UnderlineType<T1>>{}, EXPECTED_LT_MSG);
   }

template<typename T, typename T1>
   Requirements& expectLessEq(const T& exp,const T1& req){
        return expect(exp, req, std::less_equal<UnderlineType<T1>>{}, EXPECTED_LE_MSG);
   }

template<typename T, typename T1>
   Requirements& expectGreater(T exp, T1 req){
        return expect(exp, req, std::greater<UnderlineType<T1>>{}, EXPECTED_GT_MSG);
   }

template<typename T, typename T1>
   Requirements& expectGreaterEq(const T& exp,const T1& req){
        return expect(exp, req, std::greater_equal<UnderlineType<T1>>{}, EXPECTED_GE_MSG);
   }

//throws. use this if you want to throw an exception if there is any failure
    void throws(){
        if(!this->ok) throw std::invalid_argument(OP_VALIDATION_FAIL_MSG);
    }

template<typename T>
    Requirements& expectTrue(const T& expVar, const char *msg=EXPECTED_TRUE){
        if(!this->ok)  return *this; 
        bool cmp  = static_cast<bool>(getValue(expVar));
        if(!cmp && sd::Environment::getInstance().isDebug() && sd::Environment::getInstance().isVerbose()){
            std::stringstream stream;
            stream<<prefix<<": "<<getMsg(expVar)<<" {"<<getStreamValue(expVar)<<"} "<<msg;
            sd::Logger::info("%s\n", stream.str().c_str());
        }
        this->ok  = this->ok && cmp;
        return *this;
    }

template<typename T>
    Requirements& expectFalse(const T& expVar, const char *msg=EXPECTED_FALSE){
        if(!this->ok)  return *this; 
        bool cmp  = static_cast<bool>(getValue(expVar));
        if(cmp && sd::Environment::getInstance().isDebug() && sd::Environment::getInstance().isVerbose()){
            std::stringstream stream;
            stream<<prefix<<": "<<getMsg(expVar)<<" {"<<getStreamValue(expVar)<<"} "<<msg;
            sd::Logger::info("%s\n", stream.str().c_str());
        }
        this->ok  = this->ok && !cmp;
        return *this;
    }

template<typename T, typename T2>
    Requirements expectIn( const T& expVar, std::initializer_list<T2> vals){
        if(!ok)  return *this;
        auto val=getValue(expVar);
        for(const auto& r_i : vals){
            if(val==r_i) return *this;
        }
        
        if(sd::Environment::getInstance().isDebug() && sd::Environment::getInstance().isVerbose()){
            std::stringstream stream;
            stream<<prefix<<": "<<getMsg(expVar)<<'{'<<getStreamValue(expVar)<<"} "<<EXPECTED_IN<<" {"<<getStreamValue(vals)<<"}\n";
            sd::Logger::info("%s", stream.str().c_str());
        }
        ok = false;
        return *this;
    }

//Logs the Successfull cases to know if the requiremets met the conditions
    void logTheSuccess(){
        if(this->ok && sd::Environment::getInstance().isDebug() && sd::Environment::getInstance().isVerbose()){
            sd::Logger::info("%s: %s\n", prefix, REQUIREMENTS_MEETS_MSG);
        }
    }

private:
    //the prefix used to add messages in each log
    const char *prefix;
    //bool value used for the Requirements to mimick bool
    bool ok;
};

//generic wrapVar. if msg will be generated one then for lazy evaluation use lambda

//Generic wrapper where sides can be lazy evaluated using the lambda or functions
template<typename T1, typename T2>
struct InfoVariable{

InfoVariable(T1 valOrOp, T2 msgOrOp):value_or_op(valOrOp), message_or_op(msgOrOp){ 
    }

// InfoVariable(const T1& valOrOp, T2&& msgOrOp):value_or_op(valOrOp), message_or_op(std::move(msgOrOp)){
    //     std::cout<<"called "<<__LINE__<<std::endl;
    // }

T1 value_or_op;
    T2 message_or_op;

template<typename U=T1, typename std::enable_if<!is_callable<U>::value, int>::type = 0>
    U getValue() const{
        return value_or_op;
    }

template<typename U=T1, typename std::enable_if<is_callable<U>::value, int>::type = 0>
    auto getValue() const -> decltype(std::declval<U&>()()){
        return value_or_op();
    }

template<typename U=T2,  typename std::enable_if<!is_callable<U>::value, int>::type = 0>
    U getMsg() const{
        return message_or_op;
    }

template<typename U=T2, typename std::enable_if<is_callable<U>::value, int>::type = 0>
    auto getMsg() const -> decltype(std::declval<U&>()()) {
        return message_or_op();
    }

};

template<typename T1, typename T2>
InfoVariable<T1, T2> makeInfoVariable( T1&& v1,  T2&& v2){
    return InfoVariable<T1, T2>(std::forward<T1>(v1), std::forward<T2>(v2));
}

template<typename T>
struct ShapeInfoVariable{

explicit ShapeInfoVariable(const T& val, const char *msg=""):value(val), message(msg){}  
    const T& value;
    const char* message;

const char* getMsg() const{
        return message;
    }
  
    const T& getValue() const { return value;}

std::string getValueStr() const { return ShapeUtils::shapeAsString(value); }

};

template<typename T>
ShapeInfoVariable<T> makeShapeInfoVariable( T&& v, const char *msg){
    return ShapeInfoVariable<T>(std::forward<T>(v), msg);
}
}
using namespace sd;

struct TMPKLASS{
 int h=9;

std::string getValueStr(){ 
     return "haha";
 }
};

template<typename T>
struct ShapeMsg{

explicit ShapeMsg(const T& val, const char *name=""):value(val), message(name){}  
    const T &value;
    std::string message;

std::string getMsg() const{
        return message;
    }
  
    T getValue() const { return value;}

std::string getValueStr(){ return ShapeUtils::shapeAsString(value); }

};

int getAge(){
    std::cout<<"getAge() was called"<<std::endl;
    return 15;
}
 
int main(int argc, const char** argv)
{ 
    sd::Environment::getInstance().setDebug(true);
    sd::Environment::getInstance().setVerbose(true);   
    Requirements req1("Requirement Helper Example#1");
    int x = 20;
    req1.expectLess(x, 22);
    req1.expectEq(x, 21);

int age = 15;
    Requirements req2("Requirement Helper Example#2");
    req2.expectGreaterEq(makeInfoVariable(age, "the user's age"), 18);
Requirements req3("Requirement Helper Example#3");
int z = 20;
req3.expectEq(z, 21); 
req3.expectGreaterEq(makeInfoVariable(getAge(), "the user's age"), 18);
    Requirements req4("Requirement Helper Example#4");
    int zz = 20;
    req4.expectEq(zz, 21) && //shortcicuit and
    req4.expectGreaterEq(makeInfoVariable(getAge(), "the user's age"), 18);

Requirements req5("Requirement Helper Example#5"); 
    req5.expectEq( 21, 
                makeInfoVariable(21, []{
                       std::cout<<"lambda call#1"<<std::endl;
                       return "twenty one";
                   }));
    req5.expectEq(makeInfoVariable([]{ return 20;}, []{return "twenty";}), 
                   makeInfoVariable(21, []{
                       std::cout<<"lambda call#2"<<std::endl;
                       return "twenty one";
                   }));
    req5.expectGreaterEq(makeInfoVariable([]{
                            std::cout<<"lambda call#3" <<std::endl;
                            return 15;
                            }, 
                            []{ return "the user's age";}), 
                         makeInfoVariable([]{return 18;}, []{return "the allowed age";})
          );

Requirements req6("Requirement Helper Example#6");
    NDArray * arr= nullptr;
    arr !=nullptr && req6.expectEq(arr->rankOf(), 3) ;
    req6.logTheSuccess();

Requirements req7("Requirement Helper Example#7");
req7.expect(makeShapeInfoVariable(std::vector<int>{2,3,4,5}, SHAPE_MSG_INPUT0), makeShapeInfoVariable(std::vector<int>{2,3,4,7}, SHAPE_MSG_INPUT1),
                    [](const std::vector<int>& l, const std::vector<int>& r){
                        if(l.size()!=r.size()) return false;
                        for (int i = 0; i < l.size(); i++) {
                            if (l.at(i) != r.at(i)) {
                                return false;
                            }
                        }
                        return true;
                    }
                 , EXPECTED_EQ_MSG);

Requirements req8("Requirement Helper Example#8");
req8.expectEq(6,6) &&
req8.expectIn(6, {1,2,3,7,8,9});
req8.throws();
}