misc/rosetta/src/main/java/org/onap/aaf/misc/rosetta/Saved.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.misc.rosetta;
  23
  24 import java.io.IOException;
  25 import java.io.Reader;
  26 import java.io.Writer;
  27 import java.util.List;
  28
  29 import org.onap.aaf.misc.env.Env;
  30 import org.onap.aaf.misc.env.TimeTaken;
  31 import org.onap.aaf.misc.rosetta.Saved.State;
  32
  33 /**
  34  * An Out Object that will save off produced Parsed Stream and
  35  * a Parse (In) Object that will reproduce Parsed Stream on demand
  36  *
  37  * @author Jonathan
  38  *
  39  */
  40 public class Saved extends Out implements Parse<Reader, State>{
  41         private static final String ROSETTA_SAVED = "Rosetta Saved";
  42         private final static int INIT_SIZE=128;
  43         private Content content[];
  44         private int idx;
  45         private boolean append = false;
  46
  47         /**
  48          * Read from Parsed Stream and save
  49          */
  50         // @Override
  51         public<IN,S> void extract(IN in, Writer ignore, Parse<IN,S> parser, boolean ... options) throws IOException, ParseException {
  52                 Parsed<S> p = parser.newParsed();
  53                 if(!append) {
  54                         // reuse array  if not too big
  55                         if(content==null||content.length>INIT_SIZE*3) {
  56                                 content = new Content[INIT_SIZE];
  57                                 idx = -1;
  58                         } else do {
  59                                 content[idx]=null;
  60                         } while(--idx>=0);
  61                 }
  62
  63                 // Note: idx needs to be -1 on initialization and no appendages
  64                 while((p = parser.parse(in,p.reuse())).valid()) {
  65                         if(!(append && (p.event==START_DOC || p.event==END_DOC))) { // skip any start/end of document in appendages
  66                                 if(++idx>=content.length) {
  67                                         Content temp[] = new Content[content.length*2];
  68                                         System.arraycopy(content, 0, temp, 0, idx);
  69                                         content = temp;
  70                                 }
  71                                 content[idx]= new Content(p);
  72                         }
  73                 }
  74         }
  75
  76         // @Override
  77         public Parsed<State> parse(Reader ignore, Parsed<State> parsed) throws ParseException {
  78                 int i;
  79                 if((i=parsed.state.count++)<=idx)
  80                         content[i].load(parsed);
  81                 else
  82                         parsed.event = Parse.NONE;
  83                 return parsed;
  84         }
  85
  86         public Content[] cut(char event, int count) {
  87                 append = true;
  88                 for(int i=idx;i>=0;--i) {
  89                         if(content[i].event==event) count--;
  90                         if(count==0) {
  91                                 Content[] appended = new Content[idx-i+1];
  92                                 System.arraycopy(content, i, appended, 0, appended.length);
  93                                 idx = i-1;
  94                                 return appended;
  95                         }
  96                 }
  97                 return new Content[0];
  98         }
  99
 100         public void paste(Content[] appended) {
 101                 if(appended!=null) {
 102                         if(idx+appended.length>content.length) {
 103                                 Content temp[] = new Content[content.length*2];
 104                                 System.arraycopy(content, 0, temp, 0, idx);
 105                                 content = temp;
 106                         }
 107                         System.arraycopy(appended,0,content,idx+1,appended.length);
 108                         idx+=appended.length;
 109                 }
 110                 this.append = false;
 111         }
 112
 113         public static class State {
 114                 public int count = 0;
 115         }
 116
 117         public static class Content {
 118                 private boolean isString;
 119                 private char event;
 120                 private String name;
 121                 private List<Prop> props;
 122                 private String str;
 123
 124                 public Content(Parsed<?> p) {
 125                         isString = p.isString;
 126                         event = p.event;
 127                         name = p.name;
 128                         // avoid copying, because most elements don't have content
 129                         // Cannot set to "equals", because sb ends up being cleared (and reused)
 130                         str = p.sb.length()==0?null:p.sb.toString();
 131                 }
 132
 133                 public void load(Parsed<State> p) {
 134                         p.isString = isString;
 135                         p.event = event;
 136                         p.name = name;
 137                         if(str!=null)
 138                                 p.sb.append(str);
 139                 }
 140
 141                 public String toString() {
 142                         StringBuilder sb = new StringBuilder();
 143                         sb.append(event);
 144                         sb.append(" - ");
 145                         sb.append(name);
 146                         sb.append(": ");
 147                         if(isString)sb.append('"');
 148                         sb.append(str);
 149                         if(isString)sb.append('"');
 150                         sb.append(' ');
 151                         if(props!=null) {
 152                                 boolean comma = false;
 153                                 for(Prop prop : props) {
 154                                         if(comma)sb.append(',');
 155                                         else comma = true;
 156                                         sb.append(prop.tag);
 157                                         sb.append('=');
 158                                         sb.append(prop.value);
 159                                 }
 160                         }
 161                         return sb.toString();
 162                 }
 163         }
 164
 165         //// @Override
 166         public Parsed<State> newParsed() {
 167                 Parsed<State> ps = new Parsed<State>(new State());
 168                 return ps;
 169         }
 170
 171         /**
 172          * Convenience function
 173          * @param rdr
 174          * @param in
 175          * @throws IOException
 176          * @throws ParseException
 177          */
 178         public<IN,S> void load(IN in, Parse<IN, S> parser) throws IOException, ParseException {
 179                 extract(in,(Writer)null, parser);
 180         }
 181
 182
 183         // @Override
 184         public TimeTaken start(Env env) {
 185                 return env.start(ROSETTA_SAVED, 0);
 186         }
 187
 188         @Override
 189         public String logName() {
 190                 return ROSETTA_SAVED;
 191         }
 192
 193
 194 }