Cosmetic changes

[libs/datafile.git] / source / binarywriter.cpp

diff --git a/source/binarywriter.cpp b/source/binarywriter.cpp
index d1433304c251744a7a51c702a2b80b73b3d24139..87111f00d091ecada4056e70f5c5c299190f20bc 100644 (file)
--- a/source/binarywriter.cpp
+++ b/source/binarywriter.cpp
@@ -11,14 +11,11 @@ namespace Msp {
 namespace DataFile {
 
 BinaryWriter::BinaryWriter(Output &o):
-       WriterMode(o),
-       next_kwd_id(1),
-       next_str_id(1),
-       float_precision(32)
+       WriterMode(o)
 {
-       dict[DictEntry("__kwd", "iss")] = -1;
-       dict[DictEntry("__str", "is")] = -2;
-       dict[DictEntry("__flt", "i")] = -3;
+       dict[StatementKey("__kwd", "iss")] = -1;
+       dict[StatementKey("__str", "is")] = -2;
+       dict[StatementKey("__flt", "i")] = -3;
 }
 
 void BinaryWriter::set_float_precision(unsigned fp)
@@ -40,49 +37,49 @@ void BinaryWriter::write(const Statement &st)
 
 void BinaryWriter::write_(const Statement &st)
 {
-       int id = get_item(dict, DictEntry(st.keyword, st.get_signature()));
+       int id = get_item(dict, StatementKey(st.keyword, st.get_signature()));
 
        write_int(id);
-       for(Statement::Arguments::const_iterator j = st.args.begin(); j!=st.args.end(); ++j)
-               switch(j->get_signature())
+       for(const Value &a: st.args)
+               switch(a.get_signature())
                {
-               case IntType::signature:    write_int   (j->get<IntType::Store>()); break;
-               case StringType::signature: write_string(j->get<StringType::Store>()); break;
-               case BoolType::signature:   write_int   (j->get<BoolType::Store>()); break;
-               case FloatType::signature:  write_float (j->get<FloatType::Store>()); break;
-               case SymbolType::signature: write_symbol(j->get<SymbolType::Store>()); break;
+               case IntType::signature:    write_int   (a.get<IntType::Store>()); break;
+               case StringType::signature: write_string(a.get<StringType::Store>()); break;
+               case BoolType::signature:   write_int   (a.get<BoolType::Store>()); break;
+               case FloatType::signature:  write_float (a.get<FloatType::Store>()); break;
+               case SymbolType::signature: write_symbol(a.get<SymbolType::Store>()); break;
                }
 
        write_int(st.sub.size());
-       for(list<Statement>::const_iterator j = st.sub.begin(); j!=st.sub.end(); ++j)
-               write(*j);
+       for(const Statement &s: st.sub)
+               write(s);
 }
 
 void BinaryWriter::collect_keywords(const Statement &st)
 {
-       DictEntry de(st.keyword, st.get_signature());
+       StatementKey key(st.keyword, st.get_signature());
 
-       if(!dict.count(de))
+       if(!dict.count(key))
        {
                Statement kst;
                kst.keyword = "__kwd";
                kst.args.push_back(next_kwd_id);
-               kst.args.push_back(de.keyword);
-               kst.args.push_back(de.args);
+               kst.args.push_back(key.keyword);
+               kst.args.push_back(key.signature);
                write_(kst);
 
-               dict[de] = next_kwd_id++;
+               dict[key] = next_kwd_id++;
        }
 
-       for(ValueArray::const_iterator i = st.args.begin(); i!=st.args.end(); ++i)
+       for(const Value &a: st.args)
        {
-               char sig = i->get_signature();
+               char sig = a.get_signature();
                string str;
                if(sig==SymbolType::signature)
-                       str = i->get<Symbol>().name;
+                       str = a.get<Symbol>().name;
                else if(sig==StringType::signature)
                {
-                       str = i->get<string>();
+                       str = a.get<string>();
                        if(str.size()>32)
                                continue;
                }
@@ -101,8 +98,8 @@ void BinaryWriter::collect_keywords(const Statement &st)
                strings[str] = next_str_id++;
        }
 
-       for(list<Statement>::const_iterator i = st.sub.begin(); i!=st.sub.end(); ++i)
-               collect_keywords(*i);
+       for(const Statement &s: st.sub)
+               collect_keywords(s);
 }
 
 void BinaryWriter::write_int(IntType::Store n)
@@ -167,7 +164,7 @@ void BinaryWriter::write_float(FloatType::Store f)
                }
        }
 
-       UInt64 encoded = bf.compose(float_precision);
+       uint64_t encoded = bf.compose(float_precision);
        for(unsigned i=float_precision/8; i--; )
                out.put((encoded>>(i*8))&0xFF);
 }