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: 
In C, you can use pointers to incomplete types to prevent all dereferencing: 

---

```
/* writeonly.h */
typedef struct writeonly *wo_ptr_t;

```

---

```
/* writeonly.c */
#include "writeonly.h"

struct writeonly {
  int value 
};

/*...*/

   FOO_REGISTER->value = 42;

```

---

```
/* someother.c */
#include "writeonly.h"

/*...*/

   int x = FOO_REGISTER->value; /* error: deref'ing pointer to incomplete type */

```

---

Only `writeonly.c`, or in general any code that has a definition `struct writeonly`, can dereference the pointer. That code, of course, can accidentally read the value also, but at least all other code is prevented from dereferencing the pointers all together, while being able to pass those pointers around and store them in variables, arrays and structures.

`writeonly.[ch]` could provide a function for writing a value.
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.