Skip to content

Instantly share code, notes, and snippets.

@jotux
Last active November 21, 2018 21:30

Revisions

  1. jotux revised this gist Nov 21, 2018. 1 changed file with 2 additions and 3 deletions.
    5 changes: 2 additions & 3 deletions dirty_array.cpp
    Original file line number Diff line number Diff line change
    @@ -65,8 +65,7 @@ class Register
    {
    uint32_t old = reinterpret_cast<uint32_t&>(data);
    memcpy(data,&val,4);
    uint32_t current = reinterpret_cast<uint32_t&>(data);
    if (old != current)
    if (old != val)
    {
    dirty = true;
    }
    @@ -94,7 +93,7 @@ int main()
    PrintData();
    sample[1]++;
    PrintData();
    sample[0] += 5;
    sample[0] += (uint8_t)5;
    PrintData();
    sample.dirty = false;
    PrintData();
  2. jotux revised this gist Nov 21, 2018. 1 changed file with 64 additions and 27 deletions.
    91 changes: 64 additions & 27 deletions dirty_array.cpp
    Original file line number Diff line number Diff line change
    @@ -1,68 +1,105 @@
    #include <iostream>
    #include <stdio.h>
    #include <string.h>
    #include <stdint.h>

    using namespace std;

    template<int N>
    class X
    template<uint8_t N>
    class Register
    {
    private:
    int data[N];
    uint8_t data[N];
    class Proxy
    {
    private:
    X<N>& parent;
    int index;
    Register<N>& parent;
    uint8_t index;
    public:
    Proxy(X<N>& p, int x) : parent(p), index(x){}
    void operator=(int i)
    Proxy(Register<N>& p, uint8_t i) : parent(p), index(i){}
    void operator=(uint8_t val)
    {
    if (i != parent.data[index])
    if (val != parent.data[index])
    {
    parent.dirty = true;
    }
    parent.data[index] = i;
    parent.data[index] = val;
    }
    operator int const &()
    operator uint8_t&()
    {
    return parent.data[index];
    }
    int operator++(int)
    uint8_t operator++(int)
    {
    parent.data[index]++;
    parent.dirty = true;
    return parent.data[index];
    }
    uint8_t operator--(int)
    {
    parent.data[index]--;
    parent.dirty = true;
    return parent.data[index];
    }
    uint8_t operator+=(uint8_t val)
    {
    parent.data[index] += val;
    parent.dirty = true;
    return parent.data[index];
    }
    };
    public:
    bool dirty;
    X<N>()
    Register<N>()
    {
    memset(data,0,N*sizeof(int));
    memset(data,0,N);
    dirty = false;
    }
    Proxy operator[](int index)
    Proxy operator[](uint8_t index)
    {
    return Proxy(*this,index);
    }
    void operator=(uint32_t val)
    {
    if (N == 4)
    {
    uint32_t old = reinterpret_cast<uint32_t&>(data);
    memcpy(data,&val,4);
    uint32_t current = reinterpret_cast<uint32_t&>(data);
    if (old != current)
    {
    dirty = true;
    }
    }
    }
    operator uint32_t&()
    {
    return reinterpret_cast<uint32_t&>(data);
    }
    };

    const uint8_t size = 4;
    Register<size> sample;

    void PrintData()
    {
    printf("Data\n----\n");
    for (int i = 0;i < size;i++){printf("%d%s\n",(uint8_t)sample[i],sample.dirty?"~":"");}
    }

    int main()
    {
    X<3> sample;
    for (int i = 0;i < 3;i++)
    {
    printf("%d %d\n",(int)sample[i],sample.dirty);
    }
    PrintData();
    sample[1] = 0;
    for (int i = 0;i < 3;i++)
    {
    printf("%d %d\n",(int)sample[i],sample.dirty);
    }
    PrintData();
    sample[1]++;
    for (int i = 0;i < 3;i++)
    {
    printf("%d %d\n",(int)sample[i],sample.dirty);
    }
    PrintData();
    sample[0] += 5;
    PrintData();
    sample.dirty = false;
    PrintData();
    sample = 0x04030201;
    PrintData();
    uint32_t foo = (uint32_t)sample;
    printf("Foo: 0x%x\n",foo);
    }
  3. jotux created this gist Nov 20, 2018.
    68 changes: 68 additions & 0 deletions dirty_array.cpp
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,68 @@
    #include <iostream>
    #include <stdio.h>
    #include <string.h>

    using namespace std;

    template<int N>
    class X
    {
    private:
    int data[N];
    class Proxy
    {
    private:
    X<N>& parent;
    int index;
    public:
    Proxy(X<N>& p, int x) : parent(p), index(x){}
    void operator=(int i)
    {
    if (i != parent.data[index])
    {
    parent.dirty = true;
    }
    parent.data[index] = i;
    }
    operator int const &()
    {
    return parent.data[index];
    }
    int operator++(int)
    {
    parent.data[index]++;
    parent.dirty = true;
    return parent.data[index];
    }
    };
    public:
    bool dirty;
    X<N>()
    {
    memset(data,0,N*sizeof(int));
    dirty = false;
    }
    Proxy operator[](int index)
    {
    return Proxy(*this,index);
    }
    };

    int main()
    {
    X<3> sample;
    for (int i = 0;i < 3;i++)
    {
    printf("%d %d\n",(int)sample[i],sample.dirty);
    }
    sample[1] = 0;
    for (int i = 0;i < 3;i++)
    {
    printf("%d %d\n",(int)sample[i],sample.dirty);
    }
    sample[1]++;
    for (int i = 0;i < 3;i++)
    {
    printf("%d %d\n",(int)sample[i],sample.dirty);
    }
    }