postman::ClusterUpdate postman::deserialize_cluster_update(std::string s) {
ClusterUpdate cu;
auto lines = util::split(s, '\n');
cu.initiator = storage::Host(storage::deserialize_host(lines[0]));
enum Mode {
NEW_USERS,
NEW_POSTS,
NEW_FOLLOWS,
NEW_HOSTS,
DEL_HOSTS,
ERROR
};
#define DECODER(a) do { \
if (modeline == #a) return a; \
} while(0)
auto decode_mode = [] (std::string modeline) {
DECODER(NEW_USERS);
DECODER(NEW_POSTS);
DECODER(NEW_FOLLOWS);
DECODER(NEW_HOSTS);
DECODER(DEL_HOSTS);
return ERROR;
};
#undef DECODER
Mode curr_mode = ERROR;
for (size_t curr_line = 1; curr_line < lines.size()-1; curr_line++) {
if (lines[curr_line] == "DONE") break;
if (decode_mode(lines[curr_line]) != ERROR) {
DEBUG("Switching mode to %s\n", lines[curr_line].c_str());
curr_mode = decode_mode(lines[curr_line]);
} else {
switch (curr_mode) {
case NEW_USERS:
cu.new_users.push_back(storage::deserialize_user(lines[curr_line]));
break;
case NEW_POSTS:
cu.new_posts.push_back(storage::deserialize_post(lines[curr_line]));
break;
case NEW_FOLLOWS:
cu.new_follows.push_back(storage::deserialize_follow(lines[curr_line]));
break;
case NEW_HOSTS:
cu.new_hosts.push_back(storage::deserialize_host(lines[curr_line]));
break;
case DEL_HOSTS:
cu.del_hosts.push_back(storage::deserialize_host(lines[curr_line]));
break;
case ERROR:
ERR("This should never be hit!!!\n");
break;
}
}
}
return cu;
}
Mgmt_Type decode_mgmt_type(std::string s_type) {
DECODER(ADD_NODE);
DECODER(CONNECT);
DECODER(GET_HOSTS);
DECODER(CLUSTER_UPDATE);
DECODER(SAVE);
DECODER(LOAD);
return MGMT_INVALID;
}
void execute_program(char** instructions, int n_instructions, var** vars) {
int i;
char instruction[16];
char argument[128];
for (i = 2; i < n_instructions; i++) {
sscanf(instructions[i], "%s %[^\n]\n", instruction, argument);
if (strcmp(instruction, "AND") == 0) {
vars[(int) argument[4]] -> value = AND(vars[(int)argument[0]], vars[(int)argument[2]]);
} else if (strcmp(instruction, "OR") == 0) {
vars[(int) argument[4]] -> value = OR(vars[(int) argument[0]], vars[(int) argument[2]]);
} else if (strcmp(instruction, "MULTIPLEXER") == 0) {
int num_inputs;
sscanf(argument, "%d ", &num_inputs);
int num_selectors = (int) ceil(log2(num_inputs));
var* inputs[num_inputs];
var* selectors[num_selectors];
int g;
for (g = 0; g < num_inputs; g++) {
inputs[g] = vars[(int) argument[g*2+2]];
}
for (g = 0; g < num_selectors; g++) {
selectors[g] = vars[(int) argument[(2 * num_inputs + 2) + g * 2]];
}
var* output = vars[(int) argument[num_inputs*2 + num_selectors*2 + 2]];
MULTIPLEXER(num_inputs, inputs, selectors, output);
} else if (strcmp(instruction, "DECODER") == 0) {
int num_inputs;
sscanf(argument, "%d ", &num_inputs);
int num_outputs = pow(num_inputs, 2);
var* inputs[num_inputs];
var* outputs[num_outputs];
int g;
for (g = 0; g < num_inputs; g++) {
inputs[g] = vars[(int) argument[g*2 + 2]];
}
for (g = 0; g < num_outputs; g++) {
outputs[g] = vars[(int) argument[(2 * num_inputs + 2) + g * 2]];
}
DECODER(num_inputs, inputs, outputs);
}
}
}
static void
decoder_set_property(GObject *obj,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
Decoder *self = DECODER(obj);
DecoderPrivate *priv = DECODER_GET_PRIVATE(self);
switch (property_id) {
case PROP_CHAIN:
if (priv->chain != NULL)
g_object_unref(priv->chain);
priv->chain = g_value_get_pointer(value);
break;
case PROP_ENC_SIZE:
priv->enc_size = g_value_get_ulong (value);
break;
case PROP_RAW_SIZE:
priv->raw_size = g_value_get_ulong (value);
break;
case PROP_ENC_DATA:
if (priv->enc_data != NULL)
g_free(priv->enc_data);
priv->enc_data = g_value_get_pointer(value);
break;
case PROP_RAW_DATA:
if (priv->raw_data != NULL)
g_free(priv->raw_data);
priv->raw_data = g_value_get_pointer(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, property_id, pspec);
break;
}
}
static void
decoder_dispose(GObject *obj)
{
Decoder *self = DECODER(obj);
DecoderPrivate *priv = DECODER_GET_PRIVATE (self);
if (priv->disposed)
return;
priv->disposed = TRUE;
/* unref other objects */
if (priv->chain)
g_object_unref(priv->chain);
g_free(priv->enc_data);
/* dont free priv->raw_data, it is never allocated by us */
if (G_OBJECT_CLASS (decoder_parent_class)->dispose)
G_OBJECT_CLASS (decoder_parent_class)->dispose (obj);
}
namespace rawspeed {
TiffParser::TiffParser(const Buffer* file) : RawParser(file) {}
std::unique_ptr<RawDecoder> TiffParser::getDecoder(const CameraMetaData* meta) {
return TiffParser::makeDecoder(TiffParser::parse(*mInput), *mInput);
}
TiffRootIFDOwner TiffParser::parse(const Buffer& data) {
ByteStream bs(data, 0);
bs.setByteOrder(getTiffByteOrder(bs, 0, "TIFF header"));
bs.skipBytes(2);
ushort16 magic = bs.getU16();
if (magic != 42 && magic != 0x4f52 && magic != 0x5352 && magic != 0x55) // ORF has 0x4f52/0x5352, RW2 0x55 - Brillant!
ThrowTPE("Not a TIFF file (magic 42)");
TiffRootIFDOwner root = std::make_unique<TiffRootIFD>(
nullptr, nullptr, bs,
UINT32_MAX); // tell TiffIFD constructur not to parse bs as IFD
NORangesSet<Buffer> ifds;
for (uint32 IFDOffset = bs.getU32(); IFDOffset;
IFDOffset = root->getSubIFDs().back()->getNextIFD()) {
root->add(std::make_unique<TiffIFD>(root.get(), &ifds, bs, IFDOffset));
}
return root;
}
std::unique_ptr<RawDecoder> TiffParser::makeDecoder(TiffRootIFDOwner root,
const Buffer& data) {
const Buffer* mInput = &data;
if (!root)
ThrowTPE("TiffIFD is null.");
for (const auto& decoder : Map) {
checker_t dChecker = nullptr;
constructor_t dConstructor = nullptr;
std::tie(dChecker, dConstructor) = decoder;
assert(dChecker);
assert(dConstructor);
if (!dChecker(root.get(), mInput))
continue;
return dConstructor(move(root), mInput);
}
ThrowTPE("No decoder found. Sorry.");
}
template <class Decoder>
std::unique_ptr<RawDecoder> TiffParser::constructor(TiffRootIFDOwner&& root,
const Buffer* data) {
return std::make_unique<Decoder>(std::move(root), data);
}
#define DECODER(name) \
{ std::make_pair(&name::isAppropriateDecoder, &constructor<name>) }
const std::array<std::pair<TiffParser::checker_t, TiffParser::constructor_t>,
17>
TiffParser::Map = {{
DECODER(DngDecoder),
DECODER(MosDecoder),
DECODER(IiqDecoder),
DECODER(Cr2Decoder),
DECODER(RafDecoder),
DECODER(NefDecoder),
DECODER(OrfDecoder),
DECODER(ArwDecoder),
DECODER(PefDecoder),
DECODER(Rw2Decoder),
DECODER(SrwDecoder),
DECODER(MefDecoder),
DECODER(DcrDecoder),
DECODER(DcsDecoder),
DECODER(KdcDecoder),
DECODER(ErfDecoder),
DECODER(ThreefrDecoder),
}};
} // namespace rawspeed
int main (int argc, char** argv){
FILE* circ;
FILE* inp;
char c;
char str[20];
char* outs;
char * outsig;
int num =0;
int numout = 0;
int i;
char* inputs;
char* inputx;
char* inputz;
inp = fopen(argv[2],"r");
int* outx;
int a;
int b;
int* greys;
while(1){
circ = fopen(argv[1],"r");
createdatamap();
while(1){
if(fscanf(circ,"%s",str)==EOF){
break;
}
if(strcmp("INPUTVAR",str)==0){
fscanf(circ,"%d",&num);
inputs = (char*) malloc(num * sizeof(char));
for(i=0;i<num;i++){
fscanf(circ," %c",&inputs[i]);
}
for(i=0;i<num;i++){
if( fscanf(inp,"%d",&datamap[getindex(inputs[i])])==EOF){
return 0;
}
}
free(inputs);
}
else if(strcmp("OUTPUTVAR",str) ==0){
fscanf(circ,"%d",&numout);
outs = (char*) malloc(numout * sizeof(char));
for(i=0;i<numout;i++){
fscanf(circ," %c",&outs[i]);
}
}
else if(strcmp("AND",str)==0){
fscanf(circ," %c",&c);
if(isalpha(c)){
a = datamap[getindex(c)];
}
else{
a = (int)c - '0';
}
fscanf(circ," %c",&c);
if(isalpha(c)){
b = datamap[getindex(c)];
}
else{
b = (int)c - '0';
}
fscanf(circ," %c",&c);
AND(a,b,&datamap[getindex(c)]);
}
else if(strcmp("OR",str)== 0){
fscanf(circ," %c",&c);
if(isalpha(c)){
a = datamap[getindex(c)];
}
else{
a = (int)c - '0';
}
fscanf(circ," %c",&c);
if(isalpha(c)){
b = datamap[getindex(c)];
}
else{
b = (int)c - '0';
}
fscanf(circ," %c",&c);
OR(a,b,&datamap[getindex(c)]);
}
else if(strcmp("NOT",str)== 0){
fscanf(circ," %c",&c);
if(isalpha(c)){
a = datamap[getindex(c)];
}
else{
a = (int)c - '0';
}
fscanf(circ," %c",&c);
NOT(a,&datamap[getindex(c)]);
}
else if(strcmp("DECODER",str)==0){
fscanf(circ,"%d",&num);
inputz = (char*) malloc(num * sizeof(char));
greys = (int*) malloc(num * sizeof(int));
for(i=0;i<num;i++){
fscanf(circ," %c",&inputz[i]);
}
for(i = 0;i<num;i++){
if(isalpha(inputz[i])){
greys[i]=datamap[getindex(inputz[i])];
}
else{
greys[i] = (int)inputz[i]- '0';
}
}
a = pow(2,num);
outsig = (char*)malloc(a*sizeof(char));
for( i=0;i<a;i++){
fscanf(circ," %c",&outsig[i]);
}
DECODER(greys,num,outsig);
free(outsig);
free(greys);
free(inputz);
}
else if(strcmp("MULTIPLEXER",str)==0){
fscanf(circ,"%d",&num);
outx = (int*)malloc(num*sizeof(int));
for(i=0;i<num;i++){
fscanf(circ," %c",&c);
if(isalpha(c)){
outx[i] = datamap[getindex(c)];
}
else{
outx[i] = (int)c - '0';
}
}
num = (int)(log(num)/log(2));
inputx = (char*)calloc(num,sizeof(char));
for(i=0;i<num;i++){
fscanf(circ," %c",&inputx[i]);
}
greys = (int*) malloc(num * sizeof(int));
for(i = 0;i<num;i++){
if(isalpha(inputx[i])){
greys[i]=datamap[getindex(inputx[i])];
}
else{
greys[i] = (int)inputx[i] - '0';
}
}
fscanf(circ," %c",&c);
MUX(greys,num,outx,&datamap[getindex(c)]);
free(greys);
free(outx);
free(inputx);
}
}
printout(numout,outs);
destroydatamap();
fclose(circ);
}
}
