Question: I am attempting to store css files inside database and call them in the most effective wa using PHP. I know I can include a style.php file and just do a query to get the data; however, not sure if that is the best way or not. I'd prefer to not have 

```
<style>
#blah { }
#blah 2 { }
etc.
</style>

```

show up on every page. I am attempting to make this work similar to how a typical css file would work where it is just a link similar to the way it is below. I have read about people using 
html page:

```
<link rel="stylesheet" type="text/css" href="style.php" />

```

style.php page:

```
header("Content-Type: text/css");

```

however, have also seen that that doesn't work well with IE.

So does anyone have any recommendations on how I can do this in the best way for all browsers?

Answer: 
I'd probably write a tiny wrapper class for each:

```
template <class T>
class read_only {
    T volatile *addr;
public:
    read_only(int address) : addr((T *)address) {}
    operator T() volatile const { return *addr; }
};

template <class T>
class write_only { 
    T volatile *addr;
public:
    write_only(int address) : addr ((T *)address) {}

    // chaining not allowed since it's write only.
    void operator=(T const &t) volatile { *addr = t; } 
};

```

At least assuming your system has a reasonable compiler, I'd expect both of these to be optimized so the generated code was indistinguishable from using a raw pointer. Usage:

```
read_only<unsigned char> x(0x1234);
write_only<unsigned char> y(0x1235);

y = x + 1;         // No problem

x = y;             // won't compile

```
Dan Saks has a Youtube presentation, that I couldn't, find where he introduces write-only registers for embedded devices.

Fortunately he wrote an article, that was easier to search, here: <https://www.embedded.com/how-to-enforce-write-only-access/>

This is the code from the article, updated for C++11

```
class write_only_T{
public:
    write_only_T(){}
    write_only_T(T const& v) : m(v){}
    write_only_T(T&& v) : m(std::move(v)){}
    write_only_T& operator=(T const& v){
        m = v;
        return *this;
    }
    write_only_T& operator=(T&& v){
        m = std::move(v);
        return *this;
    }
    write_only_T(write_only_T const&) = delete;
    write_only_T(write_only_T&&) = delete;
    write_only_T& operator=(write_only_T const&) = delete;
    write_only_T& operator=(write_only_T&&) = delete;
private:
    T m;
};

```

I don't think you need a special pointer type if you used this because write-only is a property of the value, but I can imagine a synthetic pointer-type that skips the value type.
Likely you will need to introduce a write-only reference-type and so on.