app.h

Go to the documentation of this file.

/*
-------------------------------------------------------------------------------
                            PLEBBLE
-------------------------------------------------------------------------------
 Copyright (C) 2019-2020 KATLAS Technology. (http://katlastechnology.com)
 Copyright (C) 2017-2020 Marcos Mayorga. (mm@mm-studios.com)
 
 This file is part of our Plebble(R) Platform.
 
 The code below cannot be copied, used for any purpose other than the one
 agreed and/or distributed without the express permission of
 KATLAS Technology.
-------------------------------------------------------------------------------
 
 
*/
#ifndef USGOV_ab4c3f8b32c28ebe389cd176419697be221f06c33dafc174ba9b3c3cf56ff3fe
#define USGOV_ab4c3f8b32c28ebe389cd176419697be221f06c33dafc174ba9b3c3cf56ff3fe
 
#include <us/gov/peer.h>
#include <us/gov/socket.h>
#include "evidence.h"
 
#include <vector>
#include <cassert>
#include <thread>
#include <chrono>
#include <mutex>
#include <us/gov/crypto.h>
 
namespace us { namespace gov {
namespace engine {
    using namespace std;
    using socket::datagram;
    struct peer_t;
    struct local_delta;
    struct delta;
    struct block;
    struct pow_t;
    struct daemon;
    struct block;
 
    struct app {
        typedef crypto::ripemd160 hasher_t;
        typedef hasher_t::value_type hash_t;
 
        struct local_delta {
            typedef app::hasher_t hasher_t;
            typedef app::hash_t hash_t;
            virtual ~local_delta() {}
            static local_delta* create(int id);
            static local_delta* create(istream&);
            static local_delta* create(int appid, istream&);
            static local_delta* create_prev(int appid, istream&);
 
            virtual void to_stream(ostream&) const=0;
            virtual void from_stream(istream&)=0;
            virtual void from_stream_prev(istream&)=0;
            virtual void hash_data_to_sign(crypto::ec::sigmsg_hasher_t&) const=0;
            virtual void hash_data(hasher_t&) const=0;
//            virtual void dump(ostream&os) const=0;
 
            virtual int app_id() const=0;
            hash_t compute_hash() const;
        };
 
        struct delta {
            delta() {}
            virtual ~delta() {}
            static delta* create(int id);
            static delta* create(istream&);
            static delta* create(int id,istream&);
            static delta* create_prev(int id,istream&);
            virtual uint64_t merge(local_delta* other);
            virtual void end_merge()=0;
            virtual void to_stream(ostream&) const=0;
            uint64_t multiplicity{0};
        };
 
        app(daemon&e):demon(e) {}
        virtual ~app() {}
        virtual int get_id() const=0;
        virtual string get_name() const=0;
        virtual void clear()=0;
        virtual void import(const delta&, const pow_t&)=0;
        virtual void save_db(ostream&) const=0;
        virtual bool load_db(istream&)=0;
        virtual bool load_db_prev(istream&)=0;
        virtual bool process(const evidence&)=0;
        virtual bool process_query(peer_t *, datagram*) { return false; }
        virtual local_delta* create_local_delta()=0;
        virtual bool shell_command(istream&, ostream&);
        static unsigned int get_seed();
 
 
        struct chaininfo_t {
            chaininfo_t():last_delta_imported(0) {}
            hash_t last_delta_imported;
        };
        static chaininfo_t chaininfo;
        daemon& demon;
    };
 
    template<typename D>
    struct average_merger {
        void merge(D& v1, const D& v2) const {
            v1+=v2;
        }
        void end_merge(D& v, const uint64_t& multiplicity) const {
            double m=multiplicity;
            v/=m;
        }
    };
 
    template<typename D>
    struct majority_merger {
        void merge(const D& v) {
            auto i=m.find(v);
            if (i!=m.end()) {
                ++i->second;
                return;
            }
            m.emplace(v,1);
        }
 
        void end_merge(D& v) {
            const D* x=0;
            uint64_t z=0;
            for (auto& i:m) {
                if (i.second>z) {
                    z=i.second;
                    x=&i.first;
                }
            }
            if (likely(z!=0)) v=*x;
            else v=0;
            m.clear();
        }
 
        unordered_map<D,uint64_t> m;
    };
 
 
}}
}
 
#endif