bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/RecordType.cpp

   1 #include "RecordType.h"
   2
   3 #include "Component.h"
   4
   5 #include <string>
   6 #include <iostream>
   7 #include <sstream>
   8
   9 namespace Databoard {
  10         namespace Type {
  11
  12                 RecordType::RecordType()
  13                 {
  14                 }
  15
  16                 RecordType::RecordType(bool referable, std::vector<Component*> components)
  17                 {
  18                         this->referable = referable;
  19
  20                         this->components.resize(components.size(), NULL);
  21
  22                         for(int i = 0; i < (int)this->components.size(); ++i)
  23                         {
  24                                 this->components[i] = components[i];
  25                         }
  26                 }
  27
  28                 RecordType::~RecordType()
  29                 {
  30                         for(int i = 0; i < (int)components.size(); ++i)
  31                         {
  32                                 delete components.at(i);
  33                         }
  34
  35                         components.clear();
  36                 }
  37
  38                 bool RecordType::isReferable()
  39                 {
  40                         return referable;
  41                 }
  42
  43                 void RecordType::addComponent(std::string name, DataType* type)
  44                 {
  45                         Component* component = new Component(name, type);
  46
  47                         components.push_back(component);
  48                 }
  49
  50                 int RecordType::getComponentIndex(std::string fieldName)
  51                 {
  52                         for(int i = 0; i < (int)components.size(); ++i)
  53                         {
  54                                 if(components.at(i)->getName() == fieldName)
  55                                 {
  56                                         return i;
  57                                 }
  58                         }
  59
  60                         return -1;
  61                 }
  62
  63                 Component* RecordType::getComponent(std::string fieldName)
  64                 {
  65                         for(int i = 0; i < (int)components.size(); ++i)
  66                         {
  67                                 if(components.at(i)->getName() == fieldName)
  68                                 {
  69                                         return components.at(i);
  70                                 }
  71                         }
  72
  73                         return NULL;
  74                 }
  75
  76                 int RecordType::count()
  77                 {
  78                         return (int)components.size();
  79                 }
  80
  81                 Component* RecordType::getComponent(int i)
  82                 {
  83                         return components.at(i);
  84                 }
  85
  86                 //std::vector<Component*> RecordType::getComponents()
  87                 //{
  88                 //}
  89
  90                 std::string RecordType::writeOut(int indent)
  91                 {
  92                         bool isTuple = true;
  93
  94                         for(int i = 0; i < (int)components.size(); ++i)
  95                         {
  96                                 std::istringstream oss(components.at(i)->getName());
  97
  98                                 int name;
  99
 100                                 oss >> name;
 101
 102                                 if(name != i)
 103                                 {
 104                                         isTuple = false;
 105
 106                                         break;
 107                                 }
 108                         }
 109
 110                         std::string s;
 111
 112                         if(isTuple == false)
 113                         {
 114                                 s += "{\n";
 115                         }
 116                         else
 117                         {
 118                                 s += "( ";
 119                         }
 120
 121                         indent += 1;
 122
 123                         for(int i = 0; i < (int)components.size(); ++i)
 124                         {
 125                                 if(isTuple == false)
 126                                 {
 127                                         s.append(indent * 2, ' ');
 128
 129                                         s += components.at(i)->getName() + " : ";
 130                                 }
 131
 132                                 s += components.at(i)->getDataBoard()->writeOut(indent);
 133
 134                                 if(i != ((int)components.size()-1))
 135                                 {
 136                                         s += ",";
 137                                 }
 138
 139                                 if(isTuple == false)
 140                                 {
 141                                         s += "\n";
 142                                 }
 143                                 else
 144                                 {
 145                                         s += " ";
 146                                 }
 147                         }
 148
 149                         indent -= 1;
 150
 151                         if(isTuple == false)
 152                         {
 153                                 s.append(indent * 2, ' ');
 154
 155                                 s += "}";
 156                         }
 157                         else
 158                         {
 159                                 s += ")";
 160                         }
 161
 162                         return s;
 163                 }
 164         }
 165 }