Rewrite the type system

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

diff --git a/source/binarywriter.cpp b/source/binarywriter.cpp
index 0e118c9eb0ceb4542eda97752633e8f95848f9ef..09e36c0085be33c8ad7c0ff0eb5c8a611ca33a95 100644 (file)
--- a/source/binarywriter.cpp
+++ b/source/binarywriter.cpp
@@ -1,7 +1,7 @@
 /* $Id$
 
 This file is part of libmspdatafile
-Copyright © 2006  Mikko Rasa, Mikkosoft Productions
+Copyright © 2007-2008, 2010  Mikko Rasa, Mikkosoft Productions
 Distributed under the LGPL
 */
 
@@ -30,19 +30,19 @@ void BinaryWriter::write(const Statement &st)
 
 void BinaryWriter::write_(const Statement &st)
 {
-       Dictionary::iterator i = dict.find(create_entry(st));
+       Dictionary::iterator i = dict.find(DictEntry(st.keyword, st.get_signature()));
        if(i==dict.end())
                throw InvalidParameterValue("Unknown statement");
 
        write_int(i->second);
-       for(ValueArray::const_iterator j = st.args.begin(); j!=st.args.end(); ++j)
-               switch(j->get_type())
+       for(Statement::Arguments::const_iterator j = st.args.begin(); j!=st.args.end(); ++j)
+               switch(j->get_signature())
                {
-               case INTEGER: write_int   (j->get<long long>()); break;
-               case STRING:  write_string(j->get<const string &>()); break;
-               case BOOLEAN: write_int   (j->get<bool>()); break;
-               case FLOAT:   write_float (j->get<float>()); break;
-               case ENUM:    write_enum  (j->get_raw()); break;
+               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_enum  (j->get<SymbolType::Store>()); break;
                }
 
        write_int(st.sub.size());
@@ -50,24 +50,9 @@ void BinaryWriter::write_(const Statement &st)
                write(*j);
 }
 
-DictEntry BinaryWriter::create_entry(const Statement &st)
-{
-       static const char types[] = "ifsbe";
-
-       string args;
-       for(ValueArray::const_iterator i = st.args.begin(); i!=st.args.end(); ++i)
-       {
-               if(i->get_type()>=5)
-                       throw InvalidParameterValue("Invalid argument type");
-               args += types[i->get_type()];
-       }
-
-       return DictEntry(st.keyword, args);
-}
-
 void BinaryWriter::collect_keywords(const Statement &st)
 {
-       DictEntry de = create_entry(st);
+       DictEntry de(st.keyword, st.get_signature());
 
        if(!dict.count(de))
        {
@@ -83,18 +68,29 @@ void BinaryWriter::collect_keywords(const Statement &st)
 
        for(ValueArray::const_iterator i = st.args.begin(); i!=st.args.end(); ++i)
        {
-               const Type t = i->get_type();
-               const string &r = i->get_raw();
-               if((t==ENUM || (t==STRING && r.size()<32)) && !strings.count(r))
+               char sig = i->get_signature();
+               string str;
+               if(sig==SymbolType::signature)
+                       str = i->get<Symbol>().name;
+               else if(sig==StringType::signature)
                {
-                       Statement sst;
-                       sst.keyword = "__str";
-                       sst.args.push_back(next_str_id);
-                       sst.args.push_back(r);
-                       write_(sst);
-
-                       strings[r] = next_str_id++;
+                       str = i->get<string>();
+                       if(str.size()>32)
+                               continue;
                }
+               else
+                       continue;
+
+               if(strings.count(str))
+                       continue;
+
+               Statement sst;
+               sst.keyword = "__str";
+               sst.args.push_back(next_str_id);
+               sst.args.push_back(str);
+               write_(sst);
+
+               strings[str] = next_str_id++;
        }
 
        for(list<Statement>::const_iterator i = st.sub.begin(); i!=st.sub.end(); ++i)