- more refactoring >> YMarkEntry
- integration of SurrogateReader as bookmark importer
- various small bug fixes e.g. get_xbel.xml

git-svn-id: https://svn.berlios.de/svnroot/repos/yacy/trunk@7668 6c8d7289-2bf4-0310-a012-ef5d649a1542
pull/1/head
apfelmaennchen 14 years ago
parent 7c149e0f9d
commit 60412d2bb3

@ -1,6 +1,5 @@
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@ -11,6 +10,7 @@ import net.yacy.cora.protocol.RequestHeader;
import net.yacy.kelondro.blob.Tables;
import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil;
import de.anomic.search.Switchboard;
@ -159,7 +159,7 @@ public class Table_YMark_p {
}
if (!post.get("commitrow", "").isEmpty()) {
final HashMap<String, String> bmk = new HashMap<String, String>();
final YMarkEntry bmk = new YMarkEntry();
for (final Map.Entry<String, String> entry: post.entrySet()) {
if (entry.getKey().startsWith("col_")) {
bmk.put(entry.getKey().substring(4), entry.getValue());
@ -244,7 +244,7 @@ public class Table_YMark_p {
mapIterator = sb.tables.bookmarks.getBookmarksByFolder(bmk_user, post.get("folders"));
} else if(post.containsKey("tags") && !post.get("tags").isEmpty()) {
// mapIterator = sb.tables.orderByPK(sb.tables.bookmarks.tags.getBookmarks(bmk_user, post.get("tags")), maxcount).iterator();
final String[] tagArray = YMarkUtil.cleanTagsString(post.get(YMarkTables.BOOKMARK.TAGS.key())).split(YMarkUtil.TAGS_SEPARATOR);
final String[] tagArray = YMarkUtil.cleanTagsString(post.get(YMarkEntry.BOOKMARK.TAGS.key())).split(YMarkUtil.TAGS_SEPARATOR);
mapIterator = sb.tables.bookmarks.getBookmarksByTag(bmk_user, tagArray);
} else {
mapIterator = sb.tables.orderByPK(sb.tables.iterator(table, matcher), maxcount).iterator();

@ -1,10 +1,9 @@
import java.io.IOException;
import java.util.HashMap;
import net.yacy.cora.protocol.RequestHeader;
import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil;
import de.anomic.search.Switchboard;
@ -25,7 +24,7 @@ public class add_ymark {
if(isAdmin || isAuthUser) {
final String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN);
String url = post.get(YMarkTables.BOOKMARK.URL.key(),YMarkTables.BOOKMARK.URL.deflt());
String url = post.get(YMarkEntry.BOOKMARK.URL.key(),YMarkEntry.BOOKMARK.URL.deflt());
boolean hasProtocol = false;
for (YMarkTables.PROTOCOLS p : YMarkTables.PROTOCOLS.values()) {
hasProtocol = url.toLowerCase().startsWith(p.protocol());
@ -34,17 +33,17 @@ public class add_ymark {
url=YMarkTables.PROTOCOLS.HTTP.protocol(url);
}
final HashMap<String,String> data = new HashMap<String,String>();
final YMarkEntry bmk = new YMarkEntry();
data.put(YMarkTables.BOOKMARK.URL.key(), url);
data.put(YMarkTables.BOOKMARK.TITLE.key(), post.get(YMarkTables.BOOKMARK.TITLE.key(),YMarkTables.BOOKMARK.TITLE.deflt()));
data.put(YMarkTables.BOOKMARK.DESC.key(), post.get(YMarkTables.BOOKMARK.DESC.key(),YMarkTables.BOOKMARK.DESC.deflt()));
data.put(YMarkTables.BOOKMARK.PUBLIC.key(), post.get(YMarkTables.BOOKMARK.PUBLIC.key(),YMarkTables.BOOKMARK.PUBLIC.deflt()));
data.put(YMarkTables.BOOKMARK.TAGS.key(), YMarkUtil.cleanTagsString(post.get(YMarkTables.BOOKMARK.TAGS.key(),YMarkTables.BOOKMARK.TAGS.deflt())));
data.put(YMarkTables.BOOKMARK.FOLDERS.key(), YMarkUtil.cleanFoldersString(post.get(YMarkTables.BOOKMARK.FOLDERS.key(),YMarkTables.FOLDERS_UNSORTED)));
bmk.put(YMarkEntry.BOOKMARK.URL.key(), url);
bmk.put(YMarkEntry.BOOKMARK.TITLE.key(), post.get(YMarkEntry.BOOKMARK.TITLE.key(),YMarkEntry.BOOKMARK.TITLE.deflt()));
bmk.put(YMarkEntry.BOOKMARK.DESC.key(), post.get(YMarkEntry.BOOKMARK.DESC.key(),YMarkEntry.BOOKMARK.DESC.deflt()));
bmk.put(YMarkEntry.BOOKMARK.PUBLIC.key(), post.get(YMarkEntry.BOOKMARK.PUBLIC.key(),YMarkEntry.BOOKMARK.PUBLIC.deflt()));
bmk.put(YMarkEntry.BOOKMARK.TAGS.key(), YMarkUtil.cleanTagsString(post.get(YMarkEntry.BOOKMARK.TAGS.key(),YMarkEntry.BOOKMARK.TAGS.deflt())));
bmk.put(YMarkEntry.BOOKMARK.FOLDERS.key(), YMarkUtil.cleanFoldersString(post.get(YMarkEntry.BOOKMARK.FOLDERS.key(),YMarkEntry.FOLDERS_UNSORTED)));
try {
sb.tables.bookmarks.addBookmark(bmk_user, data, false);
sb.tables.bookmarks.addBookmark(bmk_user, bmk, false);
} catch (IOException e) {
Log.logException(e);
} catch (RowSpaceExceededException e) {

@ -4,6 +4,7 @@ import net.yacy.cora.protocol.RequestHeader;
import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil;
import de.anomic.search.Switchboard;
@ -27,10 +28,10 @@ public class delete_ymark {
final String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN);
byte[] urlHash = null;
try {
if(post.containsKey(YMarkTables.BOOKMARKS_ID)) {
urlHash = post.get(YMarkTables.BOOKMARKS_ID).getBytes();
} else if(post.containsKey(YMarkTables.BOOKMARK.URL.key())) {
urlHash = YMarkUtil.getBookmarkId(post.get(YMarkTables.BOOKMARK.URL.key()));
if(post.containsKey(YMarkEntry.BOOKMARKS_ID)) {
urlHash = post.get(YMarkEntry.BOOKMARKS_ID).getBytes();
} else if(post.containsKey(YMarkEntry.BOOKMARK.URL.key())) {
urlHash = YMarkUtil.getBookmarkId(post.get(YMarkEntry.BOOKMARK.URL.key()));
} else {
prop.put("result", "0");
return prop;

@ -17,6 +17,7 @@ import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkCrawlStart;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkMetadata;
import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil;
@ -112,8 +113,8 @@ public class get_treeview {
while (bit.hasNext()) {
bmk_row = bit.next();
if(bmk_row != null) {
final String url = UTF8.String(bmk_row.get(YMarkTables.BOOKMARK.URL.key()));
final String title = bmk_row.get(YMarkTables.BOOKMARK.TITLE.key(), YMarkTables.BOOKMARK.TITLE.deflt());
final String url = UTF8.String(bmk_row.get(YMarkEntry.BOOKMARK.URL.key()));
final String title = bmk_row.get(YMarkEntry.BOOKMARK.TITLE.key(), YMarkEntry.BOOKMARK.TITLE.deflt());
// TODO: get_treeview - get rid of bmtype
if (post.containsKey("bmtype")) {
@ -164,8 +165,8 @@ public class get_treeview {
if (key.equals("url"))
url = value;
prop.put("folders_"+count+"_foldername","<small><b>"+key+":</b> " + value + "</small>");
if(YMarkTables.BOOKMARK.contains(key))
putProp(count, YMarkTables.BOOKMARK.get(key).type());
if(YMarkEntry.BOOKMARK.contains(key))
putProp(count, YMarkEntry.BOOKMARK.get(key).type());
else
putProp(count, "meta");
count++;

@ -9,6 +9,7 @@ import net.yacy.kelondro.blob.Tables;
import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkDate;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil;
import de.anomic.data.ymark.YMarkXBELImporter;
@ -64,8 +65,6 @@ public class get_xbel {
Log.logException(e);
}
Log.logInfo(YMarkTables.BOOKMARKS_LOG, "root: "+root+" root_deph: "+root_depth);
while (fit.hasNext()) {
String folder = fit.next();
foldername = folder.split(YMarkUtil.FOLDERS_SEPARATOR);
@ -114,29 +113,29 @@ public class get_xbel {
buffer.append(" id=\"b:");
buffer.append(urlHash);
buffer.append(YMarkTables.BOOKMARK.URL.xbel());
buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkTables.BOOKMARK.URL.key(), YMarkTables.BOOKMARK.URL.deflt()), true));
buffer.append(YMarkEntry.BOOKMARK.URL.xbel());
buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkEntry.BOOKMARK.URL.key(), YMarkEntry.BOOKMARK.URL.deflt()), true));
buffer.append(YMarkTables.BOOKMARK.DATE_ADDED.xbel());
date.set(bmk_row.get(YMarkTables.BOOKMARK.DATE_ADDED.key()));
buffer.append(YMarkEntry.BOOKMARK.DATE_ADDED.xbel());
date.set(bmk_row.get(YMarkEntry.BOOKMARK.DATE_ADDED.key()));
buffer.append(CharacterCoding.unicode2xml(date.toISO8601(), true));
buffer.append(YMarkTables.BOOKMARK.DATE_MODIFIED.xbel());
date.set(bmk_row.get(YMarkTables.BOOKMARK.DATE_MODIFIED.key()));
buffer.append(YMarkEntry.BOOKMARK.DATE_MODIFIED.xbel());
date.set(bmk_row.get(YMarkEntry.BOOKMARK.DATE_MODIFIED.key()));
buffer.append(CharacterCoding.unicode2xml(date.toISO8601(), true));
buffer.append(YMarkTables.BOOKMARK.DATE_VISITED.xbel());
date.set(bmk_row.get(YMarkTables.BOOKMARK.DATE_VISITED.key()));
buffer.append(YMarkEntry.BOOKMARK.DATE_VISITED.xbel());
date.set(bmk_row.get(YMarkEntry.BOOKMARK.DATE_VISITED.key()));
buffer.append(CharacterCoding.unicode2xml(date.toISO8601(), true));
buffer.append(YMarkTables.BOOKMARK.TAGS.xbel());
buffer.append(bmk_row.get(YMarkTables.BOOKMARK.TAGS.key(), YMarkTables.BOOKMARK.TAGS.deflt()));
buffer.append(YMarkEntry.BOOKMARK.TAGS.xbel());
buffer.append(bmk_row.get(YMarkEntry.BOOKMARK.TAGS.key(), YMarkEntry.BOOKMARK.TAGS.deflt()));
buffer.append(YMarkTables.BOOKMARK.PUBLIC.xbel());
buffer.append(bmk_row.get(YMarkTables.BOOKMARK.PUBLIC.key(), YMarkTables.BOOKMARK.PUBLIC.deflt()));
buffer.append(YMarkEntry.BOOKMARK.PUBLIC.xbel());
buffer.append(bmk_row.get(YMarkEntry.BOOKMARK.PUBLIC.key(), YMarkEntry.BOOKMARK.PUBLIC.deflt()));
buffer.append(YMarkTables.BOOKMARK.VISITS.xbel());
buffer.append(bmk_row.get(YMarkTables.BOOKMARK.VISITS.key(), YMarkTables.BOOKMARK.VISITS.deflt()));
buffer.append(YMarkEntry.BOOKMARK.VISITS.xbel());
buffer.append(bmk_row.get(YMarkEntry.BOOKMARK.VISITS.key(), YMarkEntry.BOOKMARK.VISITS.deflt()));
buffer.append("\"\n>");
prop.put("xbel_"+count+"_elements", buffer.toString());
@ -144,14 +143,14 @@ public class get_xbel {
buffer.setLength(0);
buffer.append(YMarkXBELImporter.XBEL.TITLE.startTag(false));
buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkTables.BOOKMARK.TITLE.key(), YMarkTables.BOOKMARK.TITLE.deflt()), true));
buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkEntry.BOOKMARK.TITLE.key(), YMarkEntry.BOOKMARK.TITLE.deflt()), true));
buffer.append(YMarkXBELImporter.XBEL.TITLE.endTag(false));
prop.put("xbel_"+count+"_elements", buffer.toString());
count++;
buffer.setLength(0);
buffer.append(YMarkXBELImporter.XBEL.DESC.startTag(false));
buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkTables.BOOKMARK.DESC.key(), YMarkTables.BOOKMARK.DESC.deflt()), true));
buffer.append(CharacterCoding.unicode2xml(bmk_row.get(YMarkEntry.BOOKMARK.DESC.key(), YMarkEntry.BOOKMARK.DESC.deflt()), true));
buffer.append(YMarkXBELImporter.XBEL.DESC.endTag(false));
prop.put("xbel_"+count+"_elements", buffer.toString());
count++;
@ -163,11 +162,14 @@ public class get_xbel {
}
}
}
if(root_depth < 3)
n--;
while(n > root_depth) {
prop.put("xbel_"+count+"_elements", YMarkXBELImporter.XBEL.FOLDER.endTag(false));
count++;
n--;
}
prop.put("root", root);
prop.put("user", bmk_user.substring(0,1).toUpperCase() + bmk_user.substring(1));
prop.put("xbel", count);

@ -4,7 +4,7 @@
<!ENTITY % local.url.att "yacy:public CDATA #IMPLIED yacy:tags CDATA #IMPLIED yacy:visits CDATA #IMPLIED">
]>
<xbel version="1.0" xmlns:yacy="http://www.yacy.net">
<title>#[user]# YaCy Bookmarks</title>
<title>#[user]# YaCy Bookmarks: #[root]#</title>
<info>
<metadata owner="http://www.yacy.net" />
</info>

@ -6,6 +6,7 @@ import net.yacy.cora.protocol.RequestHeader;
import net.yacy.kelondro.blob.Tables;
import net.yacy.kelondro.logging.Log;
import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkTables;
import de.anomic.data.ymark.YMarkUtil;
import de.anomic.search.Switchboard;
@ -32,9 +33,9 @@ public class get_ymark {
if(isAdmin || isAuthUser) {
final String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN);
if(post.containsKey(YMarkTables.BOOKMARK.TAGS.key())) {
if(post.containsKey(YMarkEntry.BOOKMARK.TAGS.key())) {
//tags = true;
final String[] tagArray = YMarkUtil.cleanTagsString(post.get(YMarkTables.BOOKMARK.TAGS.key())).split(YMarkUtil.TAGS_SEPARATOR);
final String[] tagArray = YMarkUtil.cleanTagsString(post.get(YMarkEntry.BOOKMARK.TAGS.key())).split(YMarkUtil.TAGS_SEPARATOR);
try {
bookmarks = sb.tables.bookmarks.getBookmarksByTag(bmk_user, tagArray);
} catch (IOException e) {
@ -71,7 +72,7 @@ public class get_ymark {
Tables.Row bmk_row = bit.next();
if (bmk_row != null) {
prop.putXML("bookmarks_"+count+"_id", UTF8.String(bmk_row.getPK()));
for (YMarkTables.BOOKMARK bmk : YMarkTables.BOOKMARK.values()) {
for (YMarkEntry.BOOKMARK bmk : YMarkEntry.BOOKMARK.values()) {
prop.putXML("bookmarks_"+count+"_"+bmk.key(), bmk_row.get(bmk.key(),bmk.deflt()));
}
count++;

@ -2,11 +2,10 @@ import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import net.yacy.cora.document.UTF8;
import net.yacy.cora.protocol.RequestHeader;
import net.yacy.document.Parser.Failure;
import net.yacy.document.content.SurrogateReader;
import net.yacy.kelondro.data.meta.DigestURI;
import net.yacy.kelondro.index.RowSpaceExceededException;
import net.yacy.kelondro.logging.Log;
@ -14,6 +13,7 @@ import net.yacy.kelondro.logging.Log;
import org.xml.sax.SAXException;
import de.anomic.data.UserDB;
import de.anomic.data.ymark.YMarkEntry;
import de.anomic.data.ymark.YMarkHTMLImporter;
import de.anomic.data.ymark.YMarkJSONImporter;
import de.anomic.data.ymark.YMarkMetadata;
@ -33,9 +33,9 @@ public class import_ymark {
final boolean isAdmin = (sb.verifyAuthentication(header, true));
final boolean isAuthUser = user!= null && user.hasRight(UserDB.AccessRight.BOOKMARK_RIGHT);
Thread t;
HashMap<String,String> bmk;
String root = YMarkTables.FOLDERS_IMPORTED;
InputStreamReader reader = null;
YMarkEntry bmk;
String root = YMarkEntry.FOLDERS_IMPORTED;
ByteArrayInputStream stream = null;
if(isAdmin || isAuthUser) {
String bmk_user = (isAuthUser ? user.getUserName() : YMarkTables.USER_ADMIN);
@ -50,11 +50,30 @@ public class import_ymark {
root = post.get("root");
}
if(post.containsKey("bmkfile") && post.containsKey("importer")){
stream = new ByteArrayInputStream(UTF8.getBytes(post.get("bmkfile$file")));
if(post.get("importer").equals("surro") && stream != null) {
SurrogateReader surrogateReader;
try {
surrogateReader = new SurrogateReader(stream, 10);
} catch (IOException e) {
//TODO: display an error message
Log.logException(e);
prop.put("result", "0");
return prop;
}
t = new Thread(surrogateReader, "YMarks - Surrogate Reader");
t.start();
while ((bmk = new YMarkEntry(surrogateReader.take())) != YMarkEntry.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
} else {
InputStreamReader reader = null;
try {
reader = new InputStreamReader(new ByteArrayInputStream(UTF8.getBytes(post.get("bmkfile$file"))),"UTF-8");
reader = new InputStreamReader(stream,"UTF-8");
} catch (UnsupportedEncodingException e1) {
//TODO: display an error message
Log.logException(e1);
// return rewrite properties
prop.put("result", "0");
return prop;
}
@ -62,7 +81,7 @@ public class import_ymark {
final YMarkHTMLImporter htmlImporter = new YMarkHTMLImporter(reader, 10, root);
t = new Thread(htmlImporter, "YMarks - HTML Importer");
t.start();
while ((bmk = htmlImporter.take()) != YMarkTables.POISON) {
while ((bmk = htmlImporter.take()) != YMarkEntry.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
@ -79,7 +98,7 @@ public class import_ymark {
}
t = new Thread(xbelImporter, "YMarks - XBEL Importer");
t.start();
while ((bmk = xbelImporter.take()) != YMarkTables.POISON) {
while ((bmk = xbelImporter.take()) != YMarkEntry.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
@ -88,12 +107,13 @@ public class import_ymark {
jsonImporter = new YMarkJSONImporter(reader, 10, root);
t = new Thread(jsonImporter, "YMarks - JSON Importer");
t.start();
while ((bmk = jsonImporter.take()) != YMarkTables.POISON) {
while ((bmk = jsonImporter.take()) != YMarkEntry.POISON) {
putBookmark(sb, bmk_user, bmk);
}
prop.put("result", "1");
}
}
}
} else {
prop.put(YMarkTables.USER_AUTHENTICATE,YMarkTables.USER_AUTHENTICATE_MSG);
}
@ -101,16 +121,16 @@ public class import_ymark {
return prop;
}
public static void putBookmark(final Switchboard sb, final String bmk_user, final HashMap<String, String> bmk) {
public static void putBookmark(final Switchboard sb, final String bmk_user, final YMarkEntry bmk) {
try {
if(!bmk.containsKey(YMarkTables.BOOKMARK.TAGS.key()) || bmk.get(YMarkTables.BOOKMARK.TAGS.key()).equals(YMarkTables.BOOKMARK.TAGS.deflt())) {
final YMarkMetadata meta = new YMarkMetadata(new DigestURI(bmk.get(YMarkTables.BOOKMARK.URL.key())));
if(!bmk.containsKey(YMarkEntry.BOOKMARK.TAGS.key()) || bmk.get(YMarkEntry.BOOKMARK.TAGS.key()).equals(YMarkEntry.BOOKMARK.TAGS.deflt())) {
final YMarkMetadata meta = new YMarkMetadata(new DigestURI(bmk.get(YMarkEntry.BOOKMARK.URL.key())));
meta.loadDocument(sb.loader);
bmk.put(YMarkTables.BOOKMARK.TAGS.key(), meta.autoTag(3));
bmk.put(YMarkEntry.BOOKMARK.TAGS.key(), meta.autoTag(3));
}
sb.tables.bookmarks.addBookmark(bmk_user, bmk, true);
} catch (IOException e) {
Log.logWarning(YMarkTables.BOOKMARKS_LOG.toString(), "Importer - IOException for URL: "+bmk.get(YMarkTables.BOOKMARK.URL.key()));
Log.logWarning(YMarkTables.BOOKMARKS_LOG.toString(), "Importer - IOException for URL: "+bmk.get(YMarkEntry.BOOKMARK.URL.key()));
} catch (RowSpaceExceededException e) {
Log.logException(e);
} catch (Failure e) {

@ -25,6 +25,8 @@
XML Bookmark Exchange Language
</a>
</small>
<br />
<input type="radio" name="importer" value="surro" /> Surrogate Reader
</dd>
<br />
<dt>

@ -67,8 +67,12 @@ public class YMarkDate {
}
public String toISO8601() {
if(this.date == 0) {
return YMarkEntry.BOOKMARK.DATE_MODIFIED.deflt();
} else {
return ISO8601Formatter.FORMATTER.format(new Date(this.date));
}
}
public byte[] toBytes() {
return String.valueOf(this.date).getBytes();
@ -87,6 +91,11 @@ public class YMarkDate {
}
public void set(byte[] date) {
this.date = Long.parseLong(UTF8.String(date));
final String s = UTF8.String(date);
if(!s.isEmpty()) {
this.date = Long.parseLong(s);
} else {
this.date = 0;
}
}
}

@ -0,0 +1,158 @@
package de.anomic.data.ymark;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
import net.yacy.document.content.DCEntry;
import net.yacy.kelondro.blob.Tables;
public class YMarkEntry extends TreeMap<String, String> {
private static final long serialVersionUID = 2179622977348536148L;
public static final YMarkEntry POISON = new YMarkEntry();
public static final String BOOKMARKS_ID = "id";
public static final String BOOKMARKS_REF = "ref";
public static final String FOLDERS_IMPORTED = "/imported";
public static final String FOLDERS_UNSORTED = "/unsorted";
public static enum BOOKMARK {
// key dc_attrb dflt html_attrb xbel_attrb json_attrb type
URL ("url", "dc:identifier", "", "href", "href", "uri", "link"),
TITLE ("title", "dc:title", "", "", "", "title", "meta"),
DESC ("desc", "dc:description", "", "", "", "", "comment"),
DATE_ADDED ("date_added", "", "", "add_date", "added", "dateAdded", "date"),
DATE_MODIFIED ("date_modified", "", "", "last_modified", "modified", "lastModified", "date"),
DATE_VISITED ("date_visited", "", "", "last_visited", "visited", "", "date"),
PUBLIC ("public", "", "flase", "", "yacy:public", "", "lock"),
TAGS ("tags", "dc:subject", "unsorted", "shortcuturl", "yacy:tags", "keyword", "tag"),
VISITS ("visits", "", "0", "", "yacy:visits", "", "stat"),
FOLDERS ("folders", "", "/unsorted", "", "", "", "folder");
private String key;
private String dc_attrb;
private String dflt;
private String html_attrb;
private String xbel_attrb;
private String json_attrb;
private String type;
private static final Map<String,BOOKMARK> lookup = new HashMap<String,BOOKMARK>();
static {
for(BOOKMARK b : EnumSet.allOf(BOOKMARK.class))
lookup.put(b.key(), b);
}
private static StringBuilder buffer = new StringBuilder(25);
private BOOKMARK(final String k, final String d, final String s, final String a, final String x, final String j, final String t) {
this.key = k;
this.dc_attrb = d;
this.dflt = s;
this.html_attrb = a;
this.xbel_attrb = x;
this.json_attrb = j;
this.type = t;
}
public static BOOKMARK get(String key) {
return lookup.get(key);
}
public static boolean contains(String key) {
return lookup.containsKey(key);
}
public String key() {
return this.key;
}
public String deflt() {
return this.dflt;
}
public String html_attrb() {
return this.html_attrb;
}
public String xbel_attrb() {
return this.xbel_attrb;
}
public String json_attrb() {
return this.json_attrb;
}
public String dc_attrb() {
return this.dc_attrb;
}
public String xbel() {
buffer.setLength(0);
buffer.append('"');
buffer.append('\n');
buffer.append(' ');
buffer.append(this.xbel_attrb);
buffer.append('=');
buffer.append('"');
return buffer.toString();
}
public String type() {
return this.type;
}
}
public YMarkEntry() {
super();
setCurrentTimeMillis(BOOKMARK.DATE_ADDED);
setCurrentTimeMillis(BOOKMARK.DATE_MODIFIED);
setDefaults();
}
public YMarkEntry(final DCEntry dc) {
for (BOOKMARK b : BOOKMARK.values()) {
if(dc.containsKey(b.dc_attrb)) {
this.put(b.key(), dc.get(b.dc_attrb));
}
}
setCurrentTimeMillis(BOOKMARK.DATE_ADDED);
setCurrentTimeMillis(BOOKMARK.DATE_MODIFIED);
setDefaults();
}
public YMarkEntry(final Tables.Row bmk_row) {
for (BOOKMARK b : BOOKMARK.values()) {
if(bmk_row.containsKey(b.key())) {
this.put(b.key(), bmk_row.get(b.key(), b.deflt()));
}
}
}
private void setCurrentTimeMillis(BOOKMARK b) {
final String date = String.valueOf(System.currentTimeMillis());
this.put(b.key(), date);
}
private void setDefaults() {
for (BOOKMARK b : BOOKMARK.values()) {
if(!b.deflt().isEmpty() && !this.containsKey(b.key())) {
this.put(b.key(), b.deflt());
}
}
}
public DCEntry getDCEntry() {
final DCEntry dc = new DCEntry();
for (BOOKMARK b : BOOKMARK.values()) {
if(!b.dc_attrb.isEmpty() && this.containsKey(b.key())) {
dc.put(b.dc_attrb, this.get(b.key()));
}
}
return dc;
}
public Tables.Data getData() {
final Tables.Data data = new Tables.Data();
for (BOOKMARK b : BOOKMARK.values()) {
if(this.containsKey(b.key()) && this.get(b.key()) != null) {
data.put(b.key(), this.get(b.key()));
} else {
data.put(b.key(), b.deflt());
}
}
return data;
}
}

@ -28,7 +28,6 @@ package de.anomic.data.ymark;
import java.io.IOException;
import java.io.Reader;
import java.util.HashMap;
import java.util.concurrent.ArrayBlockingQueue;
import javax.swing.text.MutableAttributeSet;
@ -41,11 +40,11 @@ import net.yacy.kelondro.logging.Log;
public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements Runnable {
// Importer Variables
private final ArrayBlockingQueue<HashMap<String,String>> bookmarks;
private final ArrayBlockingQueue<YMarkEntry> bookmarks;
private final Reader bmk_file;
private final String RootFolder;
private final StringBuilder folderstring;
private HashMap<String,String> bmk;
private YMarkEntry bmk;
private final ParserDelegator htmlParser;
// Statics
@ -63,12 +62,12 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
private HTML.Tag prevTag;
public YMarkHTMLImporter(final Reader bmk_file, final int queueSize, final String root) {
this.bookmarks = new ArrayBlockingQueue<HashMap<String,String>>(queueSize);
this.bookmarks = new ArrayBlockingQueue<YMarkEntry>(queueSize);
this.bmk_file = bmk_file;
this.RootFolder = root;
this.folderstring = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE);
this.folderstring.append(this.RootFolder);
this.bmk = new HashMap<String,String>();
this.bmk = new YMarkEntry();
this.htmlParser = new ParserDelegator();
@ -83,7 +82,7 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
Log.logException(e);
} finally {
try {
this.bookmarks.put(YMarkTables.POISON);
this.bookmarks.put(YMarkEntry.POISON);
} catch (InterruptedException e) {
Log.logException(e);
}
@ -100,10 +99,10 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
case NOTHING:
break;
case BOOKMARK:
this.bmk.put(YMarkTables.BOOKMARK.TITLE.key(), new String(data));
this.bmk.put(YMarkTables.BOOKMARK.FOLDERS.key(), this.folderstring.toString());
this.bmk.put(YMarkTables.BOOKMARK.PUBLIC.key(), YMarkTables.BOOKMARK.PUBLIC.deflt());
this.bmk.put(YMarkTables.BOOKMARK.VISITS.key(), YMarkTables.BOOKMARK.VISITS.deflt());
this.bmk.put(YMarkEntry.BOOKMARK.TITLE.key(), new String(data));
this.bmk.put(YMarkEntry.BOOKMARK.FOLDERS.key(), this.folderstring.toString());
this.bmk.put(YMarkEntry.BOOKMARK.PUBLIC.key(), YMarkEntry.BOOKMARK.PUBLIC.deflt());
this.bmk.put(YMarkEntry.BOOKMARK.VISITS.key(), YMarkEntry.BOOKMARK.VISITS.deflt());
break;
case FOLDER:
this.folderstring.append(YMarkUtil.FOLDERS_SEPARATOR);
@ -113,7 +112,7 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
Log.logInfo(YMarkTables.BOOKMARKS_LOG, "YMarksHTMLImporter - folder: "+this.folderstring+" desc: " + new String(data));
break;
case BMK_DESC:
this.bmk.put(YMarkTables.BOOKMARK.DESC.key(), new String(data));
this.bmk.put(YMarkEntry.BOOKMARK.DESC.key(), new String(data));
break;
default:
break;
@ -125,15 +124,15 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
if (!this.bmk.isEmpty()) {
try {
this.bookmarks.put(this.bmk);
bmk = new HashMap<String,String>();
bmk = new YMarkEntry();
} catch (InterruptedException e) {
Log.logException(e);
}
}
final String url = (String)a.getAttribute(HTML.Attribute.HREF);
this.bmk.put(YMarkTables.BOOKMARK.URL.key(), url);
this.bmk.put(YMarkEntry.BOOKMARK.URL.key(), url);
for (YMarkTables.BOOKMARK bmk : YMarkTables.BOOKMARK.values()) {
for (YMarkEntry.BOOKMARK bmk : YMarkEntry.BOOKMARK.values()) {
final String s = (String)a.getAttribute(bmk.html_attrb());
if(s != null) {
switch(bmk) {
@ -175,7 +174,7 @@ public class YMarkHTMLImporter extends HTMLEditorKit.ParserCallback implements R
}
}
public HashMap<String,String> take() {
public YMarkEntry take() {
try {
return this.bookmarks.take();
} catch (InterruptedException e) {

@ -14,11 +14,11 @@ import org.json.simple.parser.ParseException;
public class YMarkJSONImporter implements Runnable, ContentHandler{
// Importer Variables
private final ArrayBlockingQueue<HashMap<String,String>> bookmarks;
private final ArrayBlockingQueue<YMarkEntry> bookmarks;
private final Reader bmk_file;
private final String RootFolder;
private final StringBuilder folderstring;
private HashMap<String,String> bmk;
private YMarkEntry bmk;
private final JSONParser parser;
// Statics
@ -40,12 +40,12 @@ public class YMarkJSONImporter implements Runnable, ContentHandler{
private Boolean isAnnos;
public YMarkJSONImporter(final Reader bmk_file, final int queueSize, final String root) {
this.bookmarks = new ArrayBlockingQueue<HashMap<String,String>>(queueSize);
this.bookmarks = new ArrayBlockingQueue<YMarkEntry>(queueSize);
this.bmk_file = bmk_file;
this.RootFolder = root;
this.folderstring = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE);
this.folderstring.append(this.RootFolder);
this.bmk = new HashMap<String,String>();
this.bmk = new YMarkEntry();
this.parser = new JSONParser();
@ -71,7 +71,7 @@ public class YMarkJSONImporter implements Runnable, ContentHandler{
if(key.equals(CHILDREN) && this.isFolder) {
if(this.depth > 0) {
this.folderstring.append(YMarkUtil.FOLDERS_SEPARATOR);
this.folderstring.append(this.obj.get(YMarkTables.BOOKMARK.TITLE.json_attrb()));
this.folderstring.append(this.obj.get(YMarkEntry.BOOKMARK.TITLE.json_attrb()));
}
this.depth++;
} else if(key.equals(ANNOS)) {
@ -102,26 +102,26 @@ public class YMarkJSONImporter implements Runnable, ContentHandler{
public boolean endObject() throws ParseException, IOException {
if(this.isBookmark) {
this.bmk.put(YMarkTables.BOOKMARK.TITLE.key(),obj.get(YMarkTables.BOOKMARK.TITLE.json_attrb()));
this.bmk.put(YMarkTables.BOOKMARK.URL.key(),obj.get(YMarkTables.BOOKMARK.URL.json_attrb()));
this.bmk.put(YMarkEntry.BOOKMARK.TITLE.key(),obj.get(YMarkEntry.BOOKMARK.TITLE.json_attrb()));
this.bmk.put(YMarkEntry.BOOKMARK.URL.key(),obj.get(YMarkEntry.BOOKMARK.URL.json_attrb()));
date.setLength(0);
date.append(obj.get(YMarkTables.BOOKMARK.DATE_ADDED.json_attrb()));
date.append(obj.get(YMarkEntry.BOOKMARK.DATE_ADDED.json_attrb()));
date.setLength(date.length()-3);
this.bmk.put(YMarkTables.BOOKMARK.DATE_ADDED.key(), date.toString());
this.bmk.put(YMarkEntry.BOOKMARK.DATE_ADDED.key(), date.toString());
date.setLength(0);
date.append(obj.get(YMarkTables.BOOKMARK.DATE_MODIFIED.json_attrb()));
date.append(obj.get(YMarkEntry.BOOKMARK.DATE_MODIFIED.json_attrb()));
date.setLength(date.length()-3);
this.bmk.put(YMarkTables.BOOKMARK.DATE_MODIFIED.key(), date.toString());
this.bmk.put(YMarkTables.BOOKMARK.FOLDERS.key(),this.folderstring.toString());
if(this.obj.containsKey(YMarkTables.BOOKMARK.TAGS.json_attrb())) {
this.bmk.put(YMarkTables.BOOKMARK.TAGS.key(),obj.get(YMarkTables.BOOKMARK.TAGS.json_attrb()));
this.bmk.put(YMarkEntry.BOOKMARK.DATE_MODIFIED.key(), date.toString());
this.bmk.put(YMarkEntry.BOOKMARK.FOLDERS.key(),this.folderstring.toString());
if(this.obj.containsKey(YMarkEntry.BOOKMARK.TAGS.json_attrb())) {
this.bmk.put(YMarkEntry.BOOKMARK.TAGS.key(),obj.get(YMarkEntry.BOOKMARK.TAGS.json_attrb()));
}
try {
this.bookmarks.put(this.bmk);
} catch (InterruptedException e) {
Log.logException(e);
}
this.bmk = new HashMap<String,String>();
this.bmk = new YMarkEntry();
}
this.isBookmark = false;
return true;
@ -176,14 +176,14 @@ public class YMarkJSONImporter implements Runnable, ContentHandler{
} finally {
try {
Log.logInfo(YMarkTables.BOOKMARKS_LOG, "JSON Importer inserted poison pill in queue");
this.bookmarks.put(YMarkTables.POISON);
this.bookmarks.put(YMarkEntry.POISON);
} catch (InterruptedException e) {
Log.logException(e);
}
}
}
public HashMap<String,String> take() {
public YMarkEntry take() {
try {
return this.bookmarks.take();
} catch (InterruptedException e) {

@ -27,18 +27,14 @@
package de.anomic.data.ymark;
import java.io.IOException;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.TreeSet;
import java.util.regex.Pattern;
import de.anomic.data.WorkTables;
import net.yacy.kelondro.blob.Tables;
import net.yacy.kelondro.blob.Tables.Data;
import net.yacy.kelondro.index.RowSpaceExceededException;
public class YMarkTables {
@ -78,88 +74,9 @@ public class YMarkTables {
}
}
public static enum BOOKMARK {
// key dflt html_attrb xbel_attrb json_attrb type
URL ("url", "", "href", "href", "uri", "link"),
TITLE ("title", "", "", "", "title", "meta"),
DESC ("desc", "", "", "", "", "comment"),
DATE_ADDED ("date_added", "", "add_date", "added", "dateAdded", "date"),
DATE_MODIFIED ("date_modified", "", "last_modified", "modified", "lastModified", "date"),
DATE_VISITED ("date_visited", "", "last_visited", "visited", "", "date"),
PUBLIC ("public", "flase", "", "yacy:public", "", "lock"),
TAGS ("tags", "unsorted", "shortcuturl", "yacy:tags", "keyword", "tag"),
VISITS ("visits", "0", "", "yacy:visits", "", "stat"),
FOLDERS ("folders", "/unsorted", "", "", "", "folder");
private String key;
private String dflt;
private String html_attrb;
private String xbel_attrb;
private String json_attrb;
private String type;
private static final Map<String,BOOKMARK> lookup = new HashMap<String,BOOKMARK>();
static {
for(BOOKMARK b : EnumSet.allOf(BOOKMARK.class))
lookup.put(b.key(), b);
}
private static StringBuilder buffer = new StringBuilder(25);;
private BOOKMARK(String k, String s, String a, String x, String j, String t) {
this.key = k;
this.dflt = s;
this.html_attrb = a;
this.xbel_attrb = x;
this.json_attrb = j;
this.type = t;
}
public static BOOKMARK get(String key) {
return lookup.get(key);
}
public static boolean contains(String key) {
return lookup.containsKey(key);
}
public String key() {
return this.key;
}
public String deflt() {
return this.dflt;
}
public String html_attrb() {
return this.html_attrb;
}
public String xbel_attrb() {
return this.xbel_attrb;
}
public String json_attrb() {
return this.json_attrb;
}
public String xbel() {
buffer.setLength(0);
buffer.append('"');
buffer.append('\n');
buffer.append(' ');
buffer.append(this.xbel_attrb);
buffer.append('=');
buffer.append('"');
return buffer.toString();
}
public String type() {
return this.type;
}
}
public final static HashMap<String,String> POISON = new HashMap<String,String>();
public final static String FOLDERS_ROOT = "/";
public final static String FOLDERS_UNSORTED = "/unsorted";
public final static String FOLDERS_IMPORTED = "/imported";
public static final int FOLDER_BUFFER_SIZE = 100;
public final static int FOLDER_BUFFER_SIZE = 100;
public final static String BOOKMARKS_LOG = "BOOKMARKS";
public final static String BOOKMARKS_ID = "id";
public final static String USER_ADMIN = "admin";
public final static String USER_AUTHENTICATE = "AUTHENTICATE";
public final static String USER_AUTHENTICATE_MSG = "Authentication required!";
@ -204,15 +121,15 @@ public class YMarkTables {
this.patternBuilder.append(p8);
final Pattern r = Pattern.compile(this.patternBuilder.toString());
final Iterator<Tables.Row> bit = this.worktables.iterator(bmk_table, YMarkTables.BOOKMARK.FOLDERS.key(), r);
final Iterator<Tables.Row> bit = this.worktables.iterator(bmk_table, YMarkEntry.BOOKMARK.FOLDERS.key(), r);
final TreeSet<String> folders = new TreeSet<String>();
final StringBuilder path = new StringBuilder(200);
Tables.Row bmk_row = null;
while(bit.hasNext()) {
bmk_row = bit.next();
if(bmk_row.containsKey(BOOKMARK.FOLDERS.key())) {
final String[] folderArray = (new String(bmk_row.get(BOOKMARK.FOLDERS.key()),"UTF8")).split(YMarkUtil.TAGS_SEPARATOR);
if(bmk_row.containsKey(YMarkEntry.BOOKMARK.FOLDERS.key())) {
final String[] folderArray = (new String(bmk_row.get(YMarkEntry.BOOKMARK.FOLDERS.key()),"UTF8")).split(YMarkUtil.TAGS_SEPARATOR);
for (final String folder : folderArray) {
if(folder.length() > root.length() && folder.substring(0, root.length()+1).equals(root+'/')) {
if(!folders.contains(folder)) {
@ -243,7 +160,7 @@ public class YMarkTables {
this.patternBuilder.append(')');
this.patternBuilder.append(p4);
final Pattern p = Pattern.compile(this.patternBuilder.toString());
return this.worktables.iterator(bmk_table, YMarkTables.BOOKMARK.FOLDERS.key(), p);
return this.worktables.iterator(bmk_table, YMarkEntry.BOOKMARK.FOLDERS.key(), p);
}
public Iterator<Tables.Row> getBookmarksByTag(final String bmk_user, final String[] tagArray) throws IOException {
@ -262,59 +179,28 @@ public class YMarkTables {
this.patternBuilder.append(tagArray.length);
this.patternBuilder.append('}');
final Pattern p = Pattern.compile(this.patternBuilder.toString());
return this.worktables.iterator(bmk_table, YMarkTables.BOOKMARK.TAGS.key(), p);
return this.worktables.iterator(bmk_table, YMarkEntry.BOOKMARK.TAGS.key(), p);
}
public void addBookmark(final String bmk_user, final HashMap<String,String> bmk, final boolean importer) throws IOException, RowSpaceExceededException {
public void addBookmark(final String bmk_user, final YMarkEntry bmk, final boolean importer) throws IOException, RowSpaceExceededException {
final String bmk_table = TABLES.BOOKMARKS.tablename(bmk_user);
final String date = String.valueOf(System.currentTimeMillis());
final byte[] urlHash = YMarkUtil.getBookmarkId(bmk.get(BOOKMARK.URL.key()));
final byte[] urlHash = YMarkUtil.getBookmarkId(bmk.get(YMarkEntry.BOOKMARK.URL.key()));
Tables.Row bmk_row = null;
if (urlHash != null) {
bmk_row = this.worktables.select(bmk_table, urlHash);
if (bmk_row == null) {
// create and insert new entry
final Data data = new Data();
for (BOOKMARK b : BOOKMARK.values()) {
switch(b) {
case DATE_ADDED:
case DATE_MODIFIED:
if(bmk.containsKey(b.key()) && bmk.get(b.key()) != null) {
data.put(b.key(), bmk.get(b.key()));
} else {
data.put(b.key(), String.valueOf(System.currentTimeMillis()).getBytes());
}
break;
case TAGS:
if(bmk.containsKey(b.key()) && bmk.get(b.key()) != null) {
data.put(b.key(), bmk.get(b.key()));
} else {
data.put(b.key(), b.deflt());
}
break;
case FOLDERS:
if(bmk.containsKey(b.key()) && bmk.get(b.key()) != null) {
data.put(b.key(), bmk.get(b.key()));
} else {
data.put(b.key(), b.deflt());
}
break;
default:
if(bmk.containsKey(b.key()) && bmk.get(b.key()) != null) {
data.put(b.key(), bmk.get(b.key()));
}
}
}
this.worktables.insert(bmk_table, urlHash, data);
this.worktables.insert(bmk_table, urlHash, bmk.getData());
} else {
// modify and update existing entry
HashSet<String> oldSet;
HashSet<String> newSet;
for (BOOKMARK b : BOOKMARK.values()) {
for (YMarkEntry.BOOKMARK b : YMarkEntry.BOOKMARK.values()) {
switch(b) {
case DATE_ADDED:
if(!bmk_row.containsKey(b.key))
if(!bmk_row.containsKey(b.key()))
bmk_row.put(b.key(), date);
break;
case DATE_MODIFIED:
@ -329,11 +215,11 @@ public class YMarkTables {
bmk_row.put(b.key(), YMarkUtil.keySetToString(newSet));
oldSet.clear();
} else {
bmk_row.put(b.key, bmk.get(b.key()));
bmk_row.put(b.key(), bmk.get(b.key()));
}
} else {
newSet = new HashSet<String>();
bmk_row.put(b.key, bmk_row.get(b.key(), b.deflt()));
bmk_row.put(b.key(), bmk_row.get(b.key(), b.deflt()));
}
break;
case FOLDERS:
@ -345,18 +231,18 @@ public class YMarkTables {
bmk_row.put(b.key(), YMarkUtil.keySetToString(newSet));
oldSet.clear();
} else {
bmk_row.put(b.key, bmk.get(b.key()));
bmk_row.put(b.key(), bmk.get(b.key()));
}
} else {
newSet = new HashSet<String>();
bmk_row.put(b.key, bmk_row.get(b.key(), b.deflt()));
bmk_row.put(b.key(), bmk_row.get(b.key(), b.deflt()));
}
break;
default:
if(bmk.containsKey(b.key())) {
bmk_row.put(b.key, bmk.get(b.key()));
bmk_row.put(b.key(), bmk.get(b.key()));
} else {
bmk_row.put(b.key, bmk_row.get(b.key(), b.deflt()));
bmk_row.put(b.key(), bmk_row.get(b.key(), b.deflt()));
}
}
}

@ -86,7 +86,7 @@ public class YMarkUtil {
public final static String cleanTagsString(final String tagsString) {
StringBuilder ts = new StringBuilder(tagsString);
if(ts.length() == 0)
return YMarkTables.BOOKMARK.TAGS.deflt();
return YMarkEntry.BOOKMARK.TAGS.deflt();
// get rid of double commas and space characters following a comma
for (int i = 0; i < ts.length()-1; i++) {
if (ts.charAt(i) == TAGS_SEPARATOR.charAt(0)) {
@ -107,7 +107,7 @@ public class YMarkUtil {
public final static String cleanFoldersString(final String foldersString) {
StringBuilder fs = new StringBuilder(cleanTagsString(foldersString));
if(fs.length() == 0)
return YMarkTables.BOOKMARK.FOLDERS.deflt();
return YMarkEntry.BOOKMARK.FOLDERS.deflt();
for (int i = 0; i < fs.length()-1; i++) {
if (fs.charAt(i) == FOLDERS_SEPARATOR.charAt(0)) {
if (fs.charAt(i+1) == TAGS_SEPARATOR.charAt(0) || fs.charAt(i+1) == FOLDERS_SEPARATOR.charAt(0)) {

@ -46,11 +46,11 @@ import org.xml.sax.helpers.XMLReaderFactory;
public class YMarkXBELImporter extends DefaultHandler implements Runnable {
// Importer Variables
private final ArrayBlockingQueue<HashMap<String,String>> bookmarks;
private final ArrayBlockingQueue<YMarkEntry> bookmarks;
private final Reader bmk_file;
private final String RootFolder;
private final StringBuilder folderstring;
private HashMap<String,String> bmk;
private YMarkEntry bmk;
private final XMLReader xmlReader;
// Statics
@ -96,23 +96,23 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
}
// Parser Variables
private final HashMap<String,HashMap<String,String>> bmkRef;
private final HashSet<HashMap<String,String>> aliasRef;
private final HashMap<String,YMarkEntry> bmkRef;
private final HashSet<YMarkEntry> aliasRef;
private final StringBuilder buffer;
private final StringBuilder folder;
private HashMap<String,String> ref;
private YMarkEntry ref;
private XBEL outer_state; // BOOKMARK, FOLDER, NOTHING
private XBEL inner_state; // DESC, TITLE, INFO, ALIAS, (METADATA), NOTHING
private boolean parse_value;
public YMarkXBELImporter (final Reader bmk_file, final int queueSize, final String root) throws SAXException {
this.bookmarks = new ArrayBlockingQueue<HashMap<String,String>>(queueSize);
this.bookmarks = new ArrayBlockingQueue<YMarkEntry>(queueSize);
this.bmk_file = bmk_file;
this.RootFolder = root;
this.folderstring = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE);
this.folderstring.append(this.RootFolder);
this.bmk = new HashMap<String,String>();
this.bmk = new YMarkEntry();
this.xmlReader = XMLReaderFactory.createXMLReader();
this.xmlReader.setContentHandler(this);
@ -120,8 +120,8 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
this.xmlReader.setFeature("http://xml.org/sax/features/namespaces", false);
this.xmlReader.setFeature("http://xml.org/sax/features/validation", false);
this.bmkRef = new HashMap<String,HashMap<String,String>>();
this.aliasRef = new HashSet<HashMap<String,String>>();
this.bmkRef = new HashMap<String,YMarkEntry>();
this.aliasRef = new HashSet<YMarkEntry>();
this.buffer = new StringBuilder();
this.folder = new StringBuilder(YMarkTables.FOLDER_BUFFER_SIZE);
this.folder.append(this.RootFolder);
@ -139,7 +139,7 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
} finally {
try {
Log.logInfo(YMarkTables.BOOKMARKS_LOG, "XBEL Importer inserted poison pill in queue");
this.bookmarks.put(YMarkTables.POISON);
this.bookmarks.put(YMarkEntry.POISON);
} catch (InterruptedException e1) {
Log.logException(e1);
}
@ -159,27 +159,27 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
if (tag == null) return;
tag = tag.toLowerCase();
if (XBEL.BOOKMARK.tag().equals(tag)) {
this.bmk = new HashMap<String,String>();
this.bmk.put(YMarkTables.BOOKMARK.URL.key(), atts.getValue(uri, YMarkTables.BOOKMARK.URL.xbel_attrb()));
this.bmk = new YMarkEntry();
this.bmk.put(YMarkEntry.BOOKMARK.URL.key(), atts.getValue(uri, YMarkEntry.BOOKMARK.URL.xbel_attrb()));
try {
date.parseISO8601(atts.getValue(uri, YMarkTables.BOOKMARK.DATE_ADDED.xbel_attrb()));
date.parseISO8601(atts.getValue(uri, YMarkEntry.BOOKMARK.DATE_ADDED.xbel_attrb()));
} catch (ParseException e) {
// TODO: exception handling
}
this.bmk.put(YMarkTables.BOOKMARK.DATE_ADDED.key(), date.toString());
this.bmk.put(YMarkEntry.BOOKMARK.DATE_ADDED.key(), date.toString());
try {
date.parseISO8601(atts.getValue(uri, YMarkTables.BOOKMARK.DATE_VISITED.xbel_attrb()));
date.parseISO8601(atts.getValue(uri, YMarkEntry.BOOKMARK.DATE_VISITED.xbel_attrb()));
} catch (ParseException e) {
// TODO: exception handling
}
this.bmk.put(YMarkTables.BOOKMARK.DATE_VISITED.key(), date.toString());
this.bmk.put(YMarkEntry.BOOKMARK.DATE_VISITED.key(), date.toString());
try {
date.parseISO8601(atts.getValue(uri, YMarkTables.BOOKMARK.DATE_MODIFIED.xbel_attrb()));
date.parseISO8601(atts.getValue(uri, YMarkEntry.BOOKMARK.DATE_MODIFIED.xbel_attrb()));
} catch (ParseException e) {
// TODO: exception handling
}
this.bmk.put(YMarkTables.BOOKMARK.DATE_MODIFIED.key(), date.toString());
UpdateBmkRef(atts.getValue(uri, "id"), true);
this.bmk.put(YMarkEntry.BOOKMARK.DATE_MODIFIED.key(), date.toString());
UpdateBmkRef(atts.getValue(uri, YMarkEntry.BOOKMARKS_ID), true);
outer_state = XBEL.BOOKMARK;
inner_state = XBEL.NOTHING;
this.parse_value = false;
@ -200,7 +200,7 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
atts.getValue(uri, "owner");
*/
} else if (XBEL.ALIAS.tag().equals(tag)) {
final String r = atts.getValue(uri, "ref");
final String r = atts.getValue(uri, YMarkEntry.BOOKMARKS_REF);
UpdateBmkRef(r, false);
this.aliasRef.add(this.bmkRef.get(r));
}
@ -217,10 +217,10 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
if(XBEL.BOOKMARK.tag().equals(tag)) {
// write bookmark
if (!this.bmk.isEmpty()) {
this.bmk.put(YMarkTables.BOOKMARK.FOLDERS.key(), this.folder.toString());
this.bmk.put(YMarkEntry.BOOKMARK.FOLDERS.key(), this.folder.toString());
try {
this.bookmarks.put(this.bmk);
bmk = new HashMap<String,String>();
bmk = new YMarkEntry();
} catch (InterruptedException e) {
Log.logException(e);
}
@ -253,10 +253,10 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
case BOOKMARK:
switch(inner_state) {
case DESC:
this.bmk.put(YMarkTables.BOOKMARK.DESC.key(), buffer.toString());
this.bmk.put(YMarkEntry.BOOKMARK.DESC.key(), buffer.toString());
break;
case TITLE:
this.bmk.put(YMarkTables.BOOKMARK.TITLE.key(), buffer.toString());
this.bmk.put(YMarkEntry.BOOKMARK.TITLE.key(), buffer.toString());
break;
case METADATA:
// TODO: handle xbel bookmark metadata
@ -288,7 +288,7 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
}
}
public HashMap<String,String> take() {
public YMarkEntry take() {
try {
return this.bookmarks.take();
} catch (InterruptedException e) {
@ -301,16 +301,16 @@ public class YMarkXBELImporter extends DefaultHandler implements Runnable {
this.folderstring.setLength(0);
if(this.bmkRef.containsKey(id)) {
this.folderstring.append(this.bmkRef.get(id).get(YMarkTables.BOOKMARK.FOLDERS.key()));
this.folderstring.append(this.bmkRef.get(id).get(YMarkEntry.BOOKMARK.FOLDERS.key()));
this.folderstring.append(',');
this.ref = this.bmkRef.get(id);
} else {
this.ref = new HashMap<String,String>();
this.ref = new YMarkEntry();
}
this.folderstring.append(this.folder);
if(url)
this.ref.put(YMarkTables.BOOKMARK.URL.key(), this.bmk.get(YMarkTables.BOOKMARK.URL.key()));
this.ref.put(YMarkTables.BOOKMARK.FOLDERS.key(), this.folderstring.toString());
this.ref.put(YMarkEntry.BOOKMARK.URL.key(), this.bmk.get(YMarkEntry.BOOKMARK.URL.key()));
this.ref.put(YMarkEntry.BOOKMARK.FOLDERS.key(), this.folderstring.toString());
this.bmkRef.put(id, ref);
}
}

Loading…
Cancel
Save